diff --git a/assets/logback.xml b/assets/logback.xml
index 1815027..a527b1b 100644
--- a/assets/logback.xml
+++ b/assets/logback.xml
@@ -1,5 +1,7 @@
 <configuration>
   <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
+      <file>/sdcard/MedtronicUploader.log</file>
+    <append>true</append>
     <rollingPolicy class="ch.qos.logback.core.rolling.FixedWindowRollingPolicy">
       <fileNamePattern>/sdcard/MedtronicUploader.%i.log.zip</fileNamePattern>
       <minIndex>1</minIndex>
diff --git a/libs/mongo-java-driver-3.0.2.jar b/libs/mongo-java-driver-3.0.2.jar
new file mode 100644
index 0000000..0ebe7c6
Binary files /dev/null and b/libs/mongo-java-driver-3.0.2.jar differ
diff --git a/libs/physicaloidlibrary.jar b/libs/physicaloidlibrary.jar
index 080d1e5..9ec2cc4 100644
Binary files a/libs/physicaloidlibrary.jar and b/libs/physicaloidlibrary.jar differ
diff --git a/res/values/strings.xml b/res/values/strings.xml
index 7dbacaa..fed3b04 100644
--- a/res/values/strings.xml
+++ b/res/values/strings.xml
@@ -13,7 +13,7 @@
     <string name="eula_title">Disclaimer</string>
     <string name="eula_accept">Accept</string>
     <string name="eula_refuse">Refuse</string>
-    <string  name="version">Version: 10.02.15</string>
+    <string  name="version">Version: 03.07.15</string>
     <style name="ButtonText">
     <item name="android:layout_width">fill_parent</item>
     <item name="android:layout_height">wrap_content</item>
diff --git a/src/com/nightscout/android/dexcom/DexcomG4Activity.java b/src/com/nightscout/android/dexcom/DexcomG4Activity.java
index abfb1da..9192523 100644
--- a/src/com/nightscout/android/dexcom/DexcomG4Activity.java
+++ b/src/com/nightscout/android/dexcom/DexcomG4Activity.java
@@ -87,6 +87,7 @@ public class DexcomG4Activity extends Activity implements OnSharedPreferenceChan
     boolean mIsBound;
     boolean keepServiceAlive = true;
     Boolean mHandlerActive = false;
+    Object mHandlerActiveLock = new Object();
     Boolean usbAllowedPermission = false;
     final Messenger mMessenger = new Messenger(new IncomingHandler());
     ActivityManager manager = null;
@@ -123,6 +124,9 @@ public void handleMessage(Message msg) {
                 mHandler.removeCallbacks(updateDataView);
 	        	mHandler.post(updateDataView);
                 break;
+            case MedtronicConstants.MSG_MEDTRONIC_GLUCMEASURE_DETECTED:
+            	showUseCalibConfirmation(msg.getData().getFloat("data"), msg.getData().getBoolean("calibrating"), msg.getData().getBoolean("isCalFactorFromPump"));
+            	break;
             case MedtronicConstants.MSG_MEDTRONIC_CGM_USB_GRANTED:
                 usbAllowedPermission = true;
                 mHandler.removeCallbacks(updateDataView);
@@ -148,11 +152,93 @@ public void handleMessage(Message msg) {
             	mHandler.removeCallbacks(updateDataView);
  	        	mHandler.post(updateDataView);
                 break;
+            case MedtronicConstants.MSG_REFRESH_DB_CONNECTION:
+            	if (mService != null){
+	            	 try {
+	                     Message message = Message.obtain(null, MedtronicConstants.MSG_REFRESH_DB_CONNECTION);
+	                     msg.replyTo = mMessenger;
+	                     mService.send(message);
+	                 } catch (RemoteException e) {
+	                	 StringBuffer sb1 = new StringBuffer("");
+	            		 sb1.append("EXCEPTION!!!!!! "+ e.getMessage()+" "+e.getCause());
+	            		 for (StackTraceElement st : e.getStackTrace()){
+	            			 sb1.append(st.toString()).append("\n");
+	            		 }
+	            		 Log.e("ApprovingGlucValReceived", "Error approving gluc. value \n "+sb1.toString());
+	                	 if (ISDEBUG){
+	                		 display.setText(display.getText()+"Error approving gluc. value\n", BufferType.EDITABLE);
+	                	 }
+	                 }
+	    		}
+            	break;
             default:
                 super.handleMessage(msg);
             }
         }
     }
+	private void showUseCalibConfirmation(final float num, final boolean calibrate, final boolean isCalFactorFromPump){
+		AlertDialog.Builder alert = new AlertDialog.Builder(ctx);
+    	alert.setTitle("Calibration Detected!!!");
+    	alert.setMessage("Do you want to use the received glucometer value for calibration?");
+
+    	alert.setPositiveButton("Yes", new DialogInterface.OnClickListener() {
+	    	public void onClick(DialogInterface dialog, int whichButton) {
+	    		if (mService != null){
+	            	 try {
+	                     Message msg = Message.obtain(null, MedtronicConstants.MSG_MEDTRONIC_GLUCMEASURE_APPROVED);
+	                     Bundle b = new Bundle();
+	                	 b.putBoolean("approved", true);
+	 					 b.putFloat("data", num);
+	 					 b.putBoolean("calibrating", calibrate);
+	 					 b.putBoolean("isCalFactorFromPump", isCalFactorFromPump);
+	 					 msg.setData(b);
+	                     msg.replyTo = mMessenger;
+	                     mService.send(msg);
+	                 } catch (RemoteException e) {
+	                	 StringBuffer sb1 = new StringBuffer("");
+	            		 sb1.append("EXCEPTION!!!!!! "+ e.getMessage()+" "+e.getCause());
+	            		 for (StackTraceElement st : e.getStackTrace()){
+	            			 sb1.append(st.toString()).append("\n");
+	            		 }
+	            		 Log.e("ApprovingGlucValReceived", "Error approving gluc. value \n "+sb1.toString());
+	                	 if (ISDEBUG){
+	                		 display.setText(display.getText()+"Error approving gluc. value\n", BufferType.EDITABLE);
+	                	 }
+	                 }
+	    		}
+	    	}
+    	});
+
+    	alert.setNegativeButton("Cancel", new DialogInterface.OnClickListener() {
+    	  public void onClick(DialogInterface dialog, int whichButton) {
+    		  if (mService != null){
+	            	 try {
+	                     Message msg = Message.obtain(null, MedtronicConstants.MSG_MEDTRONIC_GLUCMEASURE_APPROVED);
+	                     Bundle b = new Bundle();
+	 					
+	 					 b.putBoolean("approved", false);
+	 					
+	 					 msg.setData(b);
+	                     msg.replyTo = mMessenger;
+	                     mService.send(msg);
+	                 } catch (RemoteException e) {
+	                	 StringBuffer sb1 = new StringBuffer("");
+	            		 sb1.append("EXCEPTION!!!!!! "+ e.getMessage()+" "+e.getCause());
+	            		 for (StackTraceElement st : e.getStackTrace()){
+	            			 sb1.append(st.toString()).append("\n");
+	            		 }
+	            		 Log.e("ApprovingGlucValReceived", "Error approving gluc. value \n "+sb1.toString());
+	                	 if (ISDEBUG){
+	                		 display.setText(display.getText()+"Error approving gluc. value\n", BufferType.EDITABLE);
+	                	 }
+	                 }
+	    		}
+    	  }
+    	});
+
+    	alert.show();
+	}
+
     private ServiceConnection mConnection = new ServiceConnection() {
         public void onServiceConnected(ComponentName className, IBinder service) {
         	bService = service;
@@ -179,6 +265,7 @@ public void onServiceConnected(ComponentName className, IBinder service) {
         public void onServiceDisconnected(ComponentName className) {
             // This is called when the connection with the service has been unexpectedly disconnected - process crashed.
             mService = null;
+            bService = null;
             Log.i("DXCG4_MEDTRONICSERVICE_ONSERVICEDISCONNECTED","Service Disconnected\n");
             if (ISDEBUG){
             	display.setText(display.getText()+"Service Disconnected\n", BufferType.EDITABLE);
@@ -191,7 +278,7 @@ public void onServiceDisconnected(ComponentName className) {
     //All I'm really doing here is creating a simple activity to launch and maintain the service
     private Runnable updateDataView = new Runnable() {
         public void run() {
-        	synchronized (mHandlerActive) {
+        	synchronized (mHandlerActiveLock) {
         		if (!mHandlerActive)
         			return;
 		        if (!isMyServiceRunning()) {
@@ -442,7 +529,7 @@ public void onClick(View v) {
         b1.setOnClickListener(new OnClickListener() {
             @Override
             public void onClick(View v) {
-            	synchronized (mHandlerActive) {
+            	synchronized (mHandlerActiveLock) {
             		 if (b1.getText() == "Stop Uploading CGM Data") {
                      	mHandlerActive = false;
                          mHandler.removeCallbacks(updateDataView);
@@ -785,6 +872,16 @@ public void onClick(DialogInterface dialog, int whichButton) {
 	        	// Set an EditText view to get user input 
 	        	input = new EditText(ctx);
 	        	input.setInputType(InputType.TYPE_CLASS_NUMBER|InputType.TYPE_NUMBER_FLAG_DECIMAL);
+	        	
+	        	float num = settings.getFloat("lastGlucometerValue", (float) -1f);
+	        	if (num <= 0)
+	        		num = 0;
+	        
+	        	if (prefs.getBoolean("mmolxl", false)){
+	        		DecimalFormat df = new DecimalFormat("#.#");
+	        		input.setText(df.format((num/18.0)));
+	        	}else
+	        		input.setText(""+(int)num);
 	        	alert2.setView(input);
 	
 	        	alert2.setPositiveButton("Ok", new DialogInterface.OnClickListener() {
@@ -873,7 +970,7 @@ protected void onDestroy() {
     	log.info("onDestroy called");
     	PreferenceManager.getDefaultSharedPreferences(getBaseContext()).unregisterOnSharedPreferenceChangeListener(this);
     	unregisterReceiver(mArrow);
-        synchronized (mHandlerActive) {
+        synchronized (mHandlerActiveLock) {
         	mHandler.removeCallbacks(updateDataView);
         	doUnbindService();
         	if (keepServiceAlive){
@@ -992,21 +1089,24 @@ else if ("2".equalsIgnoreCase(type)){
 				stopService(new Intent(DexcomG4Activity.this, DexcomG4Service.class));
 	        	SharedPreferences settings = getSharedPreferences(MedtronicConstants.PREFS_NAME, 0);
 	        	SharedPreferences.Editor editor = settings.edit();
-	        	editor.remove("lastGlucometerMessage");
-		        editor.remove("previousValue");
-		        editor.remove("expectedSensorSortNumber");
-		        editor.remove("knownDevices");
-		        editor.remove("isCalibrating");
-		        editor.remove("lastGlucometerMessage");
-		        editor.remove("previousValue");	
-		        editor.remove("lastGlucometerValue");
-		        editor.remove("lastGlucometerDate");
-		        editor.remove("expectedSensorSortNumberForCalibration0");
-		        editor.remove("expectedSensorSortNumberForCalibration1");
-		        editor.remove("lastPumpAwake");
-		        editor.commit();
+	        	String type = prefs.getString("monitor_type", "1");
+	        	if ("1".equalsIgnoreCase(type)){
+		        	editor.remove("lastGlucometerMessage");
+			        editor.remove("previousValue");
+			        editor.remove("expectedSensorSortNumber");
+			        editor.remove("knownDevices");
+			        editor.remove("isCalibrating");
+			        editor.remove("lastGlucometerMessage");
+			        editor.remove("previousValue");	
+			        editor.remove("lastGlucometerValue");
+			        editor.remove("lastGlucometerDate");
+			        editor.remove("expectedSensorSortNumberForCalibration0");
+			        editor.remove("expectedSensorSortNumberForCalibration1");
+			        editor.remove("lastPumpAwake");
+			        editor.commit();
+	        	}
 		        if (!sharedPreferences.getBoolean("IUNDERSTAND", false)){
-					 synchronized (mHandlerActive) {
+					 synchronized (mHandlerActiveLock) {
 				        	mHandler.removeCallbacks(updateDataView);
 				        	mHandlerActive = false;
 					 }
@@ -1023,7 +1123,7 @@ else if ("2".equalsIgnoreCase(type)){
 			 //If i do not
 			 if (key.equals("IUNDERSTAND")){
 				 if (!sharedPreferences.getBoolean("IUNDERSTAND", false)){
-					 synchronized (mHandlerActive) {
+					 synchronized (mHandlerActiveLock) {
 				        	mHandler.removeCallbacks(updateDataView);
 				        	mHandlerActive = false;
 					 }
diff --git a/src/com/nightscout/android/medtronic/CommandSenderThread.java b/src/com/nightscout/android/medtronic/CommandSenderThread.java
index efb1156..17f75c4 100644
--- a/src/com/nightscout/android/medtronic/CommandSenderThread.java
+++ b/src/com/nightscout/android/medtronic/CommandSenderThread.java
@@ -78,21 +78,21 @@ public void run() {
 			 }
 		 	if (wThread.retries >= MedtronicConstants.NUMBER_OF_RETRIES){
 		 		mHandler3.removeCallbacks(wThread);
-	    		synchronized (reader.sendingCommand) {
+	    		synchronized (reader.sendingCommandLock) {
 	    			reader.sendingCommand = false;
 				}
-	    		synchronized (reader.waitingCommand) {
+	    		synchronized (reader.waitingCommandLock) {
 	    			reader.waitingCommand = false;
 	    			reader.lastCommandSend = null;
 				}
-	    		synchronized (reader.processingCommand) {
+	    		synchronized (reader.processingCommandLock) {
 	    			reader.processingCommand = false;
 				}
 	    		sendMessageToUI("Timeout expired executing command list", false);
-	    		synchronized (reader.processingCommand) {
+	    		synchronized (reader.processingCommandLock) {
 	    			reader.processingCommand = false;
 				}
-	    		synchronized (reader.waitingCommand) {
+	    		synchronized (reader.waitingCommandLock) {
 	        		reader.waitingCommand = false;
 	        		reader.lastCommandSend = null;
 				}
@@ -100,22 +100,22 @@ public void run() {
 	    	}
 		 	
 		 	if (index >= commandList.length){
-        		synchronized (reader.processingCommand) {
+        		synchronized (reader.processingCommandLock) {
 	    			reader.processingCommand = false;
 				}
-        		synchronized (reader.waitingCommand) {
+        		synchronized (reader.waitingCommandLock) {
             		reader.waitingCommand = false;
             		reader.lastCommandSend = null;
     			}
         		return;
         	}
 		 	if (withoutConfirmation <= 0){
-				synchronized (reader.waitingCommand) {
+				synchronized (reader.waitingCommandLock) {
 					reader.waitingCommand = true;
 					reader.lastCommandSend = null;
 				}
 			}else{
-				synchronized (reader.waitingCommand) {
+				synchronized (reader.waitingCommandLock) {
 					reader.waitingCommand = false;
 					reader.lastCommandSend = null;
 				}
@@ -235,7 +235,7 @@ public void setCommand(byte command){
     	
     	public void run(){
     		try{
-			synchronized (reader.processingCommand) {
+			synchronized (reader.processingCommandLock) {
 				if (!reader.processingCommand)
 					return;
 			}
@@ -247,7 +247,7 @@ public void run(){
     		}
     		log.debug("sendcommand");
     		
-    		synchronized (reader.sendingCommand) {
+    		synchronized (reader.sendingCommandLock) {
         		if (reader.sendingCommand){
         			if (timeoutSending < 11){
         				log.debug("timeoutSending++ "+timeoutSending);
@@ -268,7 +268,7 @@ public void run(){
     			log.debug("sent ");
     			//if I have sent it, I will wait once to give the "enlite" time to answer, next time I will retry.
     			sent = false;
-    			synchronized (reader.waitingCommand) {
+    			synchronized (reader.waitingCommandLock) {
             		if (!reader.waitingCommand){
             			retries = 0;
             			mHandler4.removeCallbacks(instance);
@@ -282,7 +282,7 @@ public void run(){
 				mHandler3.postDelayed(wThread, delay);
     			return;
     		}
-    		synchronized (reader.waitingCommand) {
+    		synchronized (reader.waitingCommandLock) {
         		if (!reader.waitingCommand){
         			if (withoutConfirmation > 0){
         				log.debug("sending command without expecting confirmation still send -->"+ (withoutConfirmation--));
@@ -304,11 +304,11 @@ public void run(){
     		else
     			sendMedtronicPumpCommand(command, repeat, postCommandBytes);
  
-        	synchronized (reader.waitingCommand) {
+        	synchronized (reader.waitingCommandLock) {
         			reader.lastCommandSend = command;// register the command
     		}
     		
-			synchronized (reader.sendingCommand) {
+			synchronized (reader.sendingCommandLock) {
 				log.debug("send command "+retries);
 				reader.sendingCommand = true;
 				if (!sent){
diff --git a/src/com/nightscout/android/medtronic/HistoricGetterThread.java b/src/com/nightscout/android/medtronic/HistoricGetterThread.java
index fcd31fc..7788b99 100644
--- a/src/com/nightscout/android/medtronic/HistoricGetterThread.java
+++ b/src/com/nightscout/android/medtronic/HistoricGetterThread.java
@@ -37,21 +37,21 @@ public void init() {
 		mHandler3.removeCallbacks(wThread);
 		//mHandler4.removeCallbacks(this);
 		if (reader != null){
-			synchronized (reader.sendingCommand) {
+			synchronized (reader.sendingCommandLock) {
 				reader.sendingCommand = false;
 			}
-			synchronized (reader.waitingCommand) {
+			synchronized (reader.waitingCommandLock) {
 				reader.waitingCommand = false;
 				reader.lastCommandSend = null;
 			}
-			synchronized (reader.processingCommand) {
+			synchronized (reader.processingCommandLock) {
 				reader.processingCommand = false;
 			}
 			sendMessageToUI("Init historicGetter", false);
-			synchronized (reader.processingCommand) {
+			synchronized (reader.processingCommandLock) {
 				reader.processingCommand = false;
 			}
-			synchronized (reader.waitingCommand) {
+			synchronized (reader.waitingCommandLock) {
 				reader.waitingCommand = false;
 				reader.lastCommandSend = null;
 			}
@@ -90,27 +90,27 @@ public void run() {
 			}
 			if (wThread.retries >= MedtronicConstants.NUMBER_OF_RETRIES){
 				mHandler3.removeCallbacks(wThread);
-				synchronized (reader.sendingCommand) {
+				synchronized (reader.sendingCommandLock) {
 					reader.sendingCommand = false;
 				}
-				synchronized (reader.waitingCommand) {
+				synchronized (reader.waitingCommandLock) {
 					reader.waitingCommand = false;
 					reader.lastCommandSend = null;
 				}
-				synchronized (reader.processingCommand) {
+				synchronized (reader.processingCommandLock) {
 					reader.processingCommand = false;
 				}
 				sendMessageToUI("Timeout expired executing command list", false);
-				synchronized (reader.processingCommand) {
+				synchronized (reader.processingCommandLock) {
 					reader.processingCommand = false;
 				}
-				synchronized (reader.waitingCommand) {
+				synchronized (reader.waitingCommandLock) {
 					reader.waitingCommand = false;
 					reader.lastCommandSend = null;
 				}
 				return;
 			}
-			synchronized (reader.processingCommand) {//TODO: LAST
+			synchronized (reader.processingCommandLock) {//TODO: LAST
 				if (!reader.processingCommand)
 					return;
 			}
@@ -134,7 +134,7 @@ public void run() {
 					wThread.postCommandBytes[4] = lastHistoricPage[3];
 					isWaitingNextLine = true;
 				
-					synchronized (reader.waitingCommand) {
+					synchronized (reader.waitingCommandLock) {
 						reader.waitingCommand = true;
 						reader.lastCommandSend = null;
 					}
@@ -148,10 +148,10 @@ public void run() {
 					index++;
 					return;
 				}
-				synchronized (reader.processingCommand) {
+				synchronized (reader.processingCommandLock) {
 					reader.processingCommand = false;
 				}
-				synchronized (reader.waitingCommand) {
+				synchronized (reader.waitingCommandLock) {
 					reader.waitingCommand = false;
 					reader.lastCommandSend = null;
 				}
@@ -159,12 +159,12 @@ public void run() {
 			}
 			byte command = commandList[index];
 			if (withoutConfirmation <= 0 || command == MedtronicConstants.MEDTRONIC_INIT ){
-				synchronized (reader.waitingCommand) {
+				synchronized (reader.waitingCommandLock) {
 					reader.waitingCommand = true;
 					reader.lastCommandSend = null;
 				}
 			}else{
-				synchronized (reader.waitingCommand) {
+				synchronized (reader.waitingCommandLock) {
 					reader.waitingCommand = false;
 					reader.lastCommandSend = null;
 				}
diff --git a/src/com/nightscout/android/medtronic/MedtronicCGMService.java b/src/com/nightscout/android/medtronic/MedtronicCGMService.java
index 7f693ad..2ec074a 100644
--- a/src/com/nightscout/android/medtronic/MedtronicCGMService.java
+++ b/src/com/nightscout/android/medtronic/MedtronicCGMService.java
@@ -1,23 +1,32 @@
 package com.nightscout.android.medtronic;
 
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.ObjectInputStream;
+import java.text.DecimalFormat;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Date;
 import java.util.List;
 
+import org.bson.Document;
 import org.json.JSONArray;
 import org.json.JSONException;
 import org.slf4j.LoggerFactory;
 import ch.qos.logback.classic.Level;
 import ch.qos.logback.classic.Logger;
 
+import android.app.AlertDialog;
 import android.app.NotificationManager;
 import android.app.Service;
 import android.content.BroadcastReceiver;
 import android.content.Context;
+import android.content.DialogInterface;
 import android.content.Intent;
 import android.content.IntentFilter;
 import android.content.SharedPreferences;
 import android.content.SharedPreferences.OnSharedPreferenceChangeListener;
+import android.graphics.Color;
 import android.hardware.usb.UsbDevice;
 import android.hardware.usb.UsbManager;
 import android.net.ConnectivityManager;
@@ -46,10 +55,14 @@
 import com.mongodb.MongoClientURI;
 import com.mongodb.MongoCredential;
 import com.mongodb.ServerAddress;
+import com.mongodb.client.MongoCollection;
+import com.mongodb.client.MongoDatabase;
 import com.nightscout.android.dexcom.DexcomG4Activity;
 import com.nightscout.android.dexcom.USB.HexDump;
 import com.nightscout.android.dexcom.USB.USBPower;
 import com.nightscout.android.eula.Eula;
+import com.nightscout.android.upload.GlucometerRecord;
+import com.nightscout.android.upload.MedtronicSensorRecord;
 import com.nightscout.android.upload.Record;
 import com.nightscout.android.upload.UploadHelper;
 import com.physicaloid.lib.Physicaloid;
@@ -68,6 +81,7 @@ public class MedtronicCGMService extends Service implements
 	private static final String TAG = MedtronicCGMService.class.getSimpleName();
 	private NotificationManager NM;
 	
+	private MedtronicCGMService instance = null;
 	private boolean listenerAttached = false;
 	private UploadHelper uploader;
 	private String dbURI = null;
@@ -75,12 +89,12 @@ public class MedtronicCGMService extends Service implements
     private String dsCollectionName = null;
     private String gdCollectionName = null;
     private String devicesCollectionName = "devices";
-    private DB db = null;
-    private DBCollection dexcomData = null;
-    private DBCollection glucomData = null;
-    private DBCollection deviceData = null;
+    private MongoDatabase db = null;
+    private MongoCollection<Document> dexcomData = null;
+    private MongoCollection<Document> glucomData = null;
+    private MongoCollection<Document> deviceData = null;
     private MongoClient client = null;
-    private DBCollection dsCollection = null;
+    private MongoCollection<Document> dsCollection = null;
 	private Physicaloid mSerial;
 	private Handler mHandlerCheckSerial = new Handler();// This handler runs readAndUpload Runnable which checks the USB device and NET connection. 
 	private Handler mHandler2CheckDevice = new Handler(); // this Handler is used to read the device info each thirty minutes
@@ -106,11 +120,19 @@ public class MedtronicCGMService extends Service implements
 	private long pumpPeriod = MedtronicConstants.TIME_30_MIN_IN_MS;
 	private boolean connectedSent = false;
 	private boolean isDestroying = false;
+	private Object reloadLostLock = new Object();
+	private Object resultLock = new Object();
+	private Object checkSerialLock = new Object();
 	private Boolean isUploading = false;
+	private Object isUploadingLock = new Object();
+	private Object readByListenerSizeLock = new Object();
+	private Object buffMessagesLock = new Object();
+	private Object mSerialLock = new Object();
 	private boolean isDBInitialized = false;
 	private HistoricGetterThread hGetter = null;//Medtronic Historic Log retriever
 	private long historicLogPeriod = 0;
 	private ReadByListener readByListener = new ReadByListener();//Listener to read data
+	private boolean isReloaded = false;
 
 	@Override
 	public IBinder onBind(Intent intent) {
@@ -132,13 +154,31 @@ public void handleMessage(Message msg) {
 				break;
 			case MedtronicConstants.MSG_UNREGISTER_CLIENT:
 				mClients.remove(msg.replyTo);
+				break;
+			case MedtronicConstants.MSG_MEDTRONIC_GLUCMEASURE_APPROVED:
+				if (msg.getData().getBoolean("approved"))
+					medtronicReader.approveGlucValueForCalibration(msg.getData().getFloat("data"), msg.getData().getBoolean("calibrating"), msg.getData().getBoolean("isCalFactorFromPump"));
+				else{
+					medtronicReader.lastGlucometerRecord = new GlucometerRecord();
+					medtronicReader.lastGlucometerRecord.numGlucometerValue = msg.getData().getFloat("data");
+					medtronicReader.lastGlucometerValue = msg.getData().getFloat("data");
+					Date d = new Date();
+					medtronicReader.lastGlucometerRecord.lastDate = d.getTime();
+					medtronicReader.lastGlucometerDate = d.getTime();
+					medtronicReader.calculateDate(medtronicReader.lastGlucometerRecord, d, 0);
+					SharedPreferences.Editor editor = settings.edit();
+					editor.putFloat("lastGlucometerValue", (float) medtronicReader.lastGlucometerValue);
+					editor.putLong("glucometerLastDate", d.getTime());
+					editor.commit();
+				}
+					
 				break;
 			case MedtronicConstants.MSG_MEDTRONIC_SEND_MANUAL_CALIB_VALUE:
 				String value = msg.getData().getString("sgv");
 				if (value == null || value.equals("")){
 					value = prefs.getString("manual_sgv", "");
 				}
-				log.info("Manual Calibration Received SGV "+value);
+				log.debug("Manual Calibration Received SGV "+value);
 				try{
 					Float val = null;
 					if (medtronicReader != null && value != null && !value.equals("")){
@@ -146,9 +186,9 @@ public void handleMessage(Message msg) {
 							try {
 								if (value.indexOf(".") > -1){
 									val = Float.parseFloat(value);
-									medtronicReader.processManualCalibrationDataMessage(val, false);
+									medtronicReader.processManualCalibrationDataMessage(val, false, true);
 								}else{
-									medtronicReader.processManualCalibrationDataMessage(Integer.parseInt(value), false);
+									medtronicReader.processManualCalibrationDataMessage(Integer.parseInt(value), false, true);
 								}
 								sendMessageCalibrationDoneToUI();
 							} catch (Exception e) {
@@ -163,9 +203,9 @@ public void handleMessage(Message msg) {
 						}else{
 							if (value.indexOf(".") > -1){
 								val = Float.parseFloat(value);
-								medtronicReader.processManualCalibrationDataMessage(val.intValue(), false);
+								medtronicReader.processManualCalibrationDataMessage(val.intValue(), false, true);
 							}else{
-								medtronicReader.processManualCalibrationDataMessage(Integer.parseInt(value), false);
+								medtronicReader.processManualCalibrationDataMessage(Integer.parseInt(value), false, true);
 							}
 							sendMessageCalibrationDoneToUI();
 						}
@@ -185,7 +225,7 @@ public void handleMessage(Message msg) {
 				if (value == null || value.equals("")){
 					value = prefs.getString("instant_sgv", "");
 				}
-				log.info("Instant Calibration received SGV "+value);
+				log.debug("Instant Calibration received SGV "+value);
 				try{
 					Float val = null;
 					if (medtronicReader != null && value != null  && !value.equals("")){
@@ -216,6 +256,8 @@ public void handleMessage(Message msg) {
 							}
 							sendMessageCalibrationDoneToUI();
 						}
+					}else{
+						sendErrorMessageToUI("Error parsing Calibration");
 					}
 				}catch(Exception e){
 					sendErrorMessageToUI("Error parsing Calibration");	
@@ -229,18 +271,21 @@ public void handleMessage(Message msg) {
 				break;
 			case MedtronicConstants.MSG_MEDTRONIC_SEND_GET_PUMP_INFO:
 				sendMessageToUI("Retrieving Pump info...", false);
-				log.info("Retrieving Pump info...");
+				log.debug("Retrieving Pump info...");
 				mHandler3ActivatePump.removeCallbacks(activateNewPump);
 				mHandler3ActivatePump.post(activateNewPump);
 				break;
 			case MedtronicConstants.MSG_MEDTRONIC_SEND_GET_SENSORCAL_FACTOR:
 				sendMessageToUI("Retrieve calibration factor...Now!", false);
-				log.info("Retrieve calibration factor...Now!");
+				log.debug("Retrieve calibration factor...Now!");
 				mHandlerSensorCalibration.removeCallbacks(getCalibrationFromSensor);
 				mHandlerSensorCalibration.post(getCalibrationFromSensor);
 				break;
 			case MedtronicConstants.MSG_MEDTRONIC_CGM_REQUEST_PERMISSION:
-				openUsbSerial();
+				openUsbSerial(false);
+				break;
+			case MedtronicConstants.MSG_REFRESH_DB_CONNECTION:
+				initializeDB();
 				break;
 			default:
 				super.handleMessage(msg);
@@ -259,16 +304,18 @@ private boolean initializeDB(){
         devicesCollectionName = "devices";
         db = null;
         if (dbURI != null) {
-        	log.info("URI != null");
+        	log.debug("URI != null");
           
             try {
 
                 // connect to db
                 MongoClientURI uri = new MongoClientURI(dbURI.trim());
                 Builder b = MongoClientOptions.builder();
-                b.heartbeatConnectTimeout(60000);
-                b.heartbeatSocketTimeout(60000);
-                b.maxWaitTime(60000);
+                b.heartbeatConnectTimeout(150000);
+                b.heartbeatFrequency(120000);
+                b.heartbeatSocketTimeout(150000);
+                b.maxWaitTime(150000);
+                b.connectTimeout(150000);
                 boolean bAchieved = false;
                 String user = "";
                 String password = "";
@@ -301,7 +348,7 @@ private boolean initializeDB(){
                 		}
                 	}
                 }
-                log.info("Uri TO CHANGE user "+user+" host "+source+" password "+password);
+                log.debug("Uri TO CHANGE user "+user+" host "+source+" password "+password);
                 if (bAchieved){
 	                MongoCredential mc = MongoCredential.createMongoCRCredential(user, source , password.toCharArray());
 	                ServerAddress  sa = new ServerAddress(host, iPort);
@@ -312,22 +359,26 @@ private boolean initializeDB(){
 	                }
                 }
                 // get db
-                db = client.getDB(uri.getDatabase());
+                db = client.getDatabase(uri.getDatabase());
                 
 
                 // get collection
                 dexcomData = null;
                 glucomData = null;
                 deviceData = db.getCollection(devicesCollectionName);
-                if (deviceData == null)
-                	deviceData = db.createCollection("device", null);
+                if (deviceData == null){
+                	db.createCollection("device", null);
+                	deviceData = db.getCollection("device");
+                }
                 if (collectionName != null)
                 	dexcomData = db.getCollection(collectionName.trim());
                 if (gdCollectionName != null)
                 	glucomData = db.getCollection(gdCollectionName.trim());
                 dsCollection = db.getCollection(dsCollectionName);
-                if (dsCollection == null)
-                	dsCollection = db.createCollection("devicestatus", null);
+                if (dsCollection == null){
+                	db.createCollection("devicestatus", null);
+                	dsCollection =  db.getCollection("devicestatus");
+                }
             }catch (Exception e){
             	log.error("EXCEPTION INIT",e);
             	return false;
@@ -344,7 +395,7 @@ private boolean initializeDB(){
      */
 	private void sendMessageToUI(String valuetosend, boolean clear) {
 		Log.i("medtronicCGMService", valuetosend);
-		log.info("send Message To UI -> "+valuetosend);
+		log.debug("send Message To UI -> "+valuetosend);
 		if (mClients != null && mClients.size() > 0) {
 			for (int i = mClients.size() - 1; i >= 0; i--) {
 				try {
@@ -413,7 +464,7 @@ private void sendErrorMessageToUI(String valuetosend) {
 	private void sendMessageConnectedToUI() {
 		Log.i("medtronicCGMService", "Connected");
 		if (!connectedSent){
-			log.info("Send Message Connected to UI");
+			log.debug("Send Message Connected to UI");
 			connectedSent = true;
 		}
 		for (int i = mClients.size() - 1; i >= 0; i--) {
@@ -459,7 +510,7 @@ private void sendMessageCalibrationDoneToUI() {
 	private void sendMessageDisconnectedToUI() {
 		Log.i("medtronicCGMService", "Disconnected");
 		if (connectedSent)
-			log.info("Send Message Disconnected to UI");
+			log.debug("Send Message Disconnected to UI");
 		connectedSent = false;
 		for (int i = mClients.size() - 1; i >= 0; i--) {
 			try {
@@ -480,9 +531,9 @@ private void sendMessageDisconnectedToUI() {
 	@Override
 	public void onCreate() {
 		//Debug.startMethodTracing();
-		log.info("medCGM onCreate!");
+		log.debug("medCGM onCreate!");
 		super.onCreate();
-		
+		instance = this;
 		if (android.os.Build.VERSION.SDK_INT > 9) 
 		{
 		    StrictMode.ThreadPolicy policy = new StrictMode.ThreadPolicy.Builder().permitAll().build();
@@ -535,6 +586,65 @@ else if ("2".equalsIgnoreCase(type)){
 		mSerial = new Physicaloid(this);
 		medtronicReader = new MedtronicReader(mSerial, getBaseContext(),
 				mClients, null);
+		
+		 Record auxRecord =  MedtronicCGMService.this.loadClassFile(new File(getBaseContext().getFilesDir(), "save.bin"));
+         long calDate = -1;
+         
+     	if (settings.contains("lastCalibrationDate")){
+     		 calDate = settings.getLong("lastCalibrationDate", -1);
+     	}
+     	SharedPreferences prefs = PreferenceManager
+ 				.getDefaultSharedPreferences(getBaseContext());
+     	
+     	
+     
+     	DecimalFormat df =  null;
+     	if (prefs.getBoolean("mmolDecimals", false))
+     		df = new DecimalFormat("#.##");
+     	else
+     		df = new DecimalFormat("#.#");
+     	if (auxRecord instanceof MedtronicSensorRecord && auxRecord != null){
+            	
+    	    	MedtronicSensorRecord record = (MedtronicSensorRecord) auxRecord;
+     		
+     		if (prefs.getBoolean("mmolxl", false)){
+     			Float fBgValue = null;
+            		try{
+            			fBgValue =  (float)Integer.parseInt(record.bGValue);
+            			log.info("mmolxl true --> "+record.bGValue);
+            				record.bGValue = df.format(fBgValue/18f);
+            				log.info("mmolxl/18 true --> "+record.bGValue);
+            		}catch (Exception e){
+            			
+            		}
+     		}else
+     			log.info("mmolxl false --> "+record.bGValue);
+    	    	boolean isCalibrating = record.isCalibrating;
+    	    	String calib = "---";
+    	    	if (isCalibrating){
+    	    		calib = MedtronicConstants.CALIBRATING_STR;
+    	    	}else{
+    	    		calib = MedtronicConstants.getCalibrationStrValue(record.calibrationStatus);
+    	    	}
+    	    	calib += "\nlast cal. ";
+    	    	String tail = " min. ago";
+    	    	int lastCal = 0;
+    	    	if (calDate > 0){
+    	    		lastCal = (int)((System.currentTimeMillis() - calDate)/60000); 
+    	    		if (lastCal >= 60){
+    	    			lastCal = lastCal / 60;
+    	    			tail = " hour(s) ago";
+    	    		}
+    	    	}
+    	    	calib+= ""+ lastCal + tail;
+    	    	if (prefs.getBoolean("isWarmingUp",false)){
+    	    		calib = "";
+    	    		record.bGValue = "W_Up";
+    	    		record.trendArrow="---";
+    	    	}
+    	    	medtronicReader.previousRecord = record;           	
+            }
+		
 		medtronicReader.mHandlerSensorCalibration = mHandlerSensorCalibration;
 		medtronicReader.getCalibrationFromSensor = getCalibrationFromSensor;
 		checker = medtronicReader.new CalibrationStatusChecker(mHandlerReviewParameters);
@@ -549,16 +659,19 @@ else if ("2".equalsIgnoreCase(type)){
 		long currentTime = System.currentTimeMillis();
 		long diff = currentTime - settings.getLong("lastDestroy", 0);
 		if (diff == currentTime || diff > (2*MedtronicConstants.TIME_12_HOURS_IN_MS)) {
-			if (isConnected())
-				mHandler3ActivatePump.post(activateNewPump);
-			else
-				mHandler3ActivatePump.postDelayed(activateNewPump, MedtronicConstants.TIME_5_MIN_IN_MS);
+			if (calibrationSelected == MedtronicConstants.CALIBRATION_SENSOR || !prefs.getString("glucSrcTypes","1").equals("1"))
+			{
+				if (isConnected())
+					mHandler3ActivatePump.post(activateNewPump);
+				else
+					mHandler3ActivatePump.postDelayed(activateNewPump, MedtronicConstants.TIME_5_MIN_IN_MS);
+			}
 		}
 		//if I have selected "historic log read" then ...
 		if (prefs.getString("glucSrcTypes","1").equals("2")){
 			medtronicReader.mHandlerCheckLastRead = null;
 			medtronicReader.checkLastRead = null;
-			log.info("LOG READ ON CREATE");
+			log.debug("LOG READ ON CREATE");
         	String type = prefs.getString("historicPeriod", "1");
         	if ("2".equalsIgnoreCase(type))
         		historicLogPeriod = MedtronicConstants.TIME_10_MIN_IN_MS;
@@ -570,19 +683,19 @@ else  if ("4".equalsIgnoreCase(type))
         		historicLogPeriod = MedtronicConstants.TIME_5_MIN_IN_MS;
         
         	if (settings.getLong("lastHistoricRead", 0) != 0 ){
-        		log.info("PREVIOUS READ");
+        		log.debug("PREVIOUS READ");
 				if ((System.currentTimeMillis() - settings.getLong("lastHistoricRead", 0)) >= historicLogPeriod ){
-					log.info("periodRead "+(System.currentTimeMillis() - settings.getLong("lastHistoricRead", 0))+" >= "+historicLogPeriod);
+					log.debug("periodRead "+(System.currentTimeMillis() - settings.getLong("lastHistoricRead", 0))+" >= "+historicLogPeriod);
 					mHandlerReadFromHistoric.post(readDataFromHistoric);
 					SharedPreferences.Editor editor = settings.edit();
 					editor.putLong("lastHistoricRead", System.currentTimeMillis());
 					editor.commit();
 				}else{
-					log.info("Read after delay");
+					log.debug("Read after delay");
 					mHandlerReadFromHistoric.postDelayed(readDataFromHistoric, historicLogPeriod);
 				}
 			}else{
-				log.info("Read log immediatly");
+				log.debug("Read log immediatly");
 				mHandlerReadFromHistoric.post(readDataFromHistoric);
 				SharedPreferences.Editor editor = settings.edit();
 				editor.putLong("lastHistoricRead", System.currentTimeMillis());
@@ -625,21 +738,21 @@ else  if ("11".equalsIgnoreCase(type))
 	@Override
 	public void onDestroy() {
 		//Debug.stopMethodTracing();
-		log.info("medCGM onDestroy!");
+		log.debug("medCGM onDestroy!");
 		isDestroying = true;
 		prefs.unregisterOnSharedPreferenceChangeListener(this);
-		synchronized (medtronicReader.processingCommand) {
+		synchronized (medtronicReader.processingCommandLock) {
 			SharedPreferences.Editor editor = prefs.edit();
 			
 			editor.putBoolean("wasProcessing", medtronicReader.processingCommand);
 			editor.commit();			
 		}
-		synchronized (mHandlerReloadLost) {
+		synchronized (reloadLostLock) {
 			mHandlerReloadLost.removeCallbacks(reloadLostRecords);
 		}
-		synchronized (mHandlerCheckSerial) {
+		synchronized (checkSerialLock) {
 			Log.i(TAG, "onDestroy called");
-			log.info("Medtronic Service onDestroy called");
+			log.debug("Medtronic Service onDestroy called");
 			mHandlerCheckSerial.removeCallbacks(readAndUpload);
 
 			if (NM != null) {
@@ -655,7 +768,7 @@ public void onDestroy() {
 		}
 		mHandlerReadFromHistoric.removeCallbacks(readDataFromHistoric);
 		mHandlerCheckLastRead.removeCallbacks(checkLastRead);
-		synchronized (isUploading) {
+		synchronized (isUploadingLock) {
 			super.onDestroy();
 		}
 	}
@@ -729,7 +842,7 @@ else  if ("11".equalsIgnoreCase(type))
 
 		@Override
 		public void onRead(int size) {
-			synchronized (readByListener.size) {
+			synchronized (readByListenerSizeLock) {
 				if (readByListener.size > -1)
 					readByListener.size += size;
 				else
@@ -747,7 +860,7 @@ public void onRead(int size) {
 	 */
 	private Runnable readAndUpload = new Runnable() {
 		public void run() {
-			log.info("run readAndUpload");
+			log.debug("run readAndUpload");
 			try {
 				UsbManager usbManager = (UsbManager) getSystemService(Context.USB_SERVICE);
 				boolean hasPermission = false;
@@ -761,14 +874,14 @@ public void run() {
 					}
 				}
 				if (!hasPermission) {
-					synchronized (mHandlerCheckSerial) {
-						log.info("I have lost usb permission changing listener attached to false...");
+					synchronized (checkSerialLock) {
+						log.debug("I have lost usb permission changing listener attached to false...");
 						listenerAttached = false;
 						mSerial.clearReadListener();
 						mHandlerRead.removeCallbacks(readByListener);
 						sendMessageDisconnectedToUI();
 						if (!mHandlerActive || isDestroying){
-							log.info("destroy readAnd Upload "+ mHandlerActive + " isDes "+ isDestroying);
+							log.debug("destroy readAnd Upload "+ mHandlerActive + " isDes "+ isDestroying);
 							return;
 						}
 						mHandlerCheckSerial.removeCallbacks(readAndUpload);
@@ -778,14 +891,14 @@ public void run() {
 				} else
 					sendMessageConnectedToUI();
 				boolean connected = false;
-				synchronized (mSerial) {
+				synchronized (mSerialLock) {
 					connected = isConnected();
 				}
 				if (connected) {
 					if (!isOnline())
 						sendErrorMessageToUI("NET connection error");
 					if (!listenerAttached) {
-						log.info("!listener attached readByListener triggered");
+						log.debug("!listener attached readByListener triggered");
 						mSerial.clearReadListener();
 						mHandlerRead.removeCallbacks(readByListener);
 						mSerial.addReadListener(readListener);
@@ -822,7 +935,7 @@ else if (prefs.contains("lastPumpAwake")){
 				} else {
 
 					if (!connected)
-						openUsbSerial();
+						openUsbSerial(false);
 					connected = isConnected();
 
 					if (!connected)
@@ -847,9 +960,9 @@ else if (!isOnline())
 				sendMessageToUI(sb1.toString(), false);
 				log.error("Unable to read from receptor or upload \n"+ e.toString());
 			}
-			synchronized (mHandlerCheckSerial) {
+			synchronized (checkSerialLock) {
 				if (!mHandlerActive || isDestroying){
-					log.info("destroy readAnd Upload2 "+ mHandlerActive + " isDes "+ isDestroying);
+					log.debug("destroy readAnd Upload2 "+ mHandlerActive + " isDes "+ isDestroying);
 					return;
 				}
 				mHandlerCheckSerial.removeCallbacks(readAndUpload);
@@ -866,15 +979,21 @@ private class ReadByListener implements Runnable {
 		public Integer size = -1;
 		public void run() {
 			int auxSize = 0;
-			synchronized (size) {
+			synchronized (readByListenerSizeLock) {
 				auxSize = size;
 				size = -1;
 			}
 			if (auxSize >= 0){
-				log.info("Quiero leer "+auxSize+" bytes");
+				log.debug("Quiero leer "+auxSize+" bytes");
 				doReadAndUpload(auxSize);
-			}else
-				log.info("ReadByListener NO TIENE NADA QUE SUBIR");
+				isReloaded = false;
+			}else{
+				log.debug("ReadByListener NO TIENE NADA QUE SUBIR");
+				if (!isReloaded){
+					openUsbSerial(true);
+					medtronicReader.mSerialDevice = mSerial;
+				}
+			}
 		}
 	};
 
@@ -883,25 +1002,25 @@ public void run() {
 	 */
 	protected void doReadAndUpload(int size) {
 		try {
-			synchronized (mSerial) {
+			synchronized (mSerialLock) {
 				if (mSerial.isOpened() && !isDestroying) {
 
-					log.info("doREadAndUpload");
+					log.debug("doREadAndUpload");
 					ArrayList<byte[]> bufferedMessages = medtronicReader
 							.readFromReceiver(getApplicationContext(), size);
-					log.info("Stream Received--> READED");
+					log.debug("Stream Received--> READED");
 					if (bufferedMessages != null && bufferedMessages.size() > 0) {
-						log.info("Stream Received--> There are "+bufferedMessages.size()+" to process ");
-						synchronized (processBufferedMessages.bufferedMessages) {
+						log.debug("Stream Received--> There are "+bufferedMessages.size()+" to process ");
+						synchronized (buffMessagesLock) {
 							processBufferedMessages.bufferedMessages
 									.addAll(bufferedMessages);
 						}
 						if (!isDestroying){
-							log.info("Stream Received--> order process bufferedMessages ");
+							log.debug("Stream Received--> order process bufferedMessages ");
 							mHandlerProcessRead.post(processBufferedMessages);
 						}
 					}else{
-						log.info("NULL doReadAndUpload");
+						log.debug("NULL doReadAndUpload");
 					}
 
 				}
@@ -924,18 +1043,18 @@ protected void doReadAndUpload(int size) {
 	 */
 	private Runnable reloadLostRecords = new Runnable() {
 		public void run() {
-			log.info("Reloading Lost Records from medtronic service");
+			log.debug("Reloading Lost Records from medtronic service");
 
     		JSONArray recordsNotUploadedJson;
     		JSONArray recordsNotUploaded;
 			try {
 	        	recordsNotUploaded = new JSONArray(settings.getString("recordsNotUploaded","[]"));	
 				recordsNotUploadedJson = new JSONArray(settings.getString("recordsNotUploadedJson","[]"));
-				synchronized (mHandlerReloadLost) {
+				synchronized (reloadLostLock) {
 					if (isOnline()){
-						log.info("reloadnotupload is online "+recordsNotUploaded.length() +" -> "+recordsNotUploadedJson.length() +" "+ !isDestroying);
+						log.debug("reloadnotupload is online "+recordsNotUploaded.length() +" -> "+recordsNotUploadedJson.length() +" "+ !isDestroying);
 						if ((recordsNotUploaded.length() > 0 || recordsNotUploadedJson.length() > 0) && !isDestroying) {
-							log.info("to upload old records");
+							log.debug("to upload old records");
 							uploader = new UploadHelper(getApplicationContext(),
 									DexcomG4Activity.MEDTRONIC_CGM,
 									mClients);
@@ -959,9 +1078,9 @@ public void run() {
 						    uploader.dsCollection = dsCollection;
 							
 							Record[] params = new Record[0];
-							log.info("calling uploader");
+							log.debug("calling uploader");
 							uploader.execute(params);
-							log.info("uploader called");
+							log.debug("uploader called");
 						}
 					}else{
 						if (!isDestroying)
@@ -977,7 +1096,7 @@ public void run() {
 			
 			if (!isDestroying)
 				mHandlerReloadLost.postDelayed(reloadLostRecords, 60000);
-			log.info("lost records reloaded from medtronic service");
+			log.debug("lost records reloaded from medtronic service");
 		}
 	};
 	/**
@@ -988,21 +1107,21 @@ private class BufferedMessagesProcessor implements Runnable {
 		public ArrayList<byte[]> bufferedMessages = new ArrayList<byte[]>();
 		public String sResult = "";
 		public void run() {
-			log.info("Processing bufferedMessages ");
-			synchronized (isUploading) {
-				log.info("I am Not Uploading ");
+			log.debug("Processing bufferedMessages ");
+			synchronized (isUploadingLock) {
+				log.debug("I am Not Uploading ");
 				
 				try {
 					ArrayList<byte[]> bufferedMessages2Process = new ArrayList<byte[]>();
-					synchronized (sResult) {
+					synchronized (resultLock) {
 						sResult = "";
 					}
-					synchronized (bufferedMessages) {
+					synchronized (buffMessagesLock) {
 						bufferedMessages2Process.addAll(bufferedMessages);
 						bufferedMessages.clear();
 					}
-					log.info("I am going to process "+ bufferedMessages2Process.size()+" Messages");
-					synchronized (sResult) {
+					log.debug("I am going to process "+ bufferedMessages2Process.size()+" Messages");
+					synchronized (resultLock) {
 						sResult = medtronicReader
 								.processBufferedMessages(bufferedMessages2Process);
 					}
@@ -1040,7 +1159,7 @@ public void run() {
 						params[listToUpload.size() - 1 - i] = record;
 					}
 					if (params.length > 0) {
-						synchronized (mHandlerReloadLost) {
+						synchronized (reloadLostLock) {
 							uploader = new UploadHelper(getApplicationContext(),
 									DexcomG4Activity.MEDTRONIC_CGM,
 									mClients);
@@ -1077,7 +1196,7 @@ public void run() {
 					sendMessageToUI(sb1.toString() + "\n " + sResult, false);
 				}
 			}
-			log.info("Buffered Messages Processed ");
+			log.debug("Buffered Messages Processed ");
 		}
 
 	};
@@ -1129,9 +1248,9 @@ private boolean isOnline() {
             NetworkInfo[] info = connectivity.getAllNetworkInfo();
             if (info != null) {
                 for (int i = 0; (i < info.length) && !isOnline; i++) {
-                    log.info("INTERNET: "+String.valueOf(i));
+                    log.debug("INTERNET: "+String.valueOf(i));
                     if (info[i].getState() == NetworkInfo.State.CONNECTED) {
-                        log.info("INTERNET: connected!");
+                        log.debug("INTERNET: connected!");
                         return true; 
                     }
                 }
@@ -1160,42 +1279,63 @@ private void displayMessage(String message) {
 
 	}
 
-	private void openUsbSerial() {
+	private void openUsbSerial(boolean reload) {
 		if (mSerial == null) {
 			Toast.makeText(this, "cannot open", Toast.LENGTH_SHORT).show();
 			return;
 		}
-		synchronized (mSerial) {
+		if (mSerial.isOpened() && reload){
+			mSerial.close();
+			mSerial.clearReadListener();
+			listenerAttached = false;
+		}
+		
+		synchronized (mSerialLock) {
 			if (!mSerial.isOpened()) {
 				if (!mSerial.open()) {
-					USBPower.PowerOff();
-					try {
-						Thread.sleep(2500);
-					} catch (InterruptedException e) {
-						Log.w(TAG, "Interrupted during sleep after Power On", e);
-					}
-					USBPower.PowerOn();
-					try {
-						Thread.sleep(2500);
-					} catch (InterruptedException e) {
-						Log.w(TAG, "Interrupted during sleep after Power On", e);
-					}
 					Toast.makeText(this, "cannot open", Toast.LENGTH_SHORT)
 							.show();
 					return;
 				} else {
+					if (!isReloaded && reload)
+						isReloaded = true;
 					boolean dtrOn = true;
 					boolean rtsOn = false;
 					mSerial.setConfig(new UartConfig(57600, 8, 1, 0, dtrOn,
 							rtsOn));
-					Toast.makeText(this, "connected", Toast.LENGTH_SHORT)
+					if (!reload)
+						Toast.makeText(this, "connected", Toast.LENGTH_SHORT)
 							.show();
 				}
 			}
 		}
+		if (!listenerAttached && reload) {
+			mSerial.addReadListener(readListener);
+			listenerAttached = true;
+		}
 
 	}
 
+	 //Deserialize the EGVRecord (most recent) value
+    public Record loadClassFile(File f) {
+    	 ObjectInputStream ois = null;
+        try {
+            ois = new ObjectInputStream(new FileInputStream(f));
+            Object o = ois.readObject();
+            ois.close();
+            return (Record) o;
+        } catch (Exception ex) {
+            Log.w(TAG, " unable to loadEGVRecord");
+            try{
+	            if (ois != null)
+	            	ois.close();
+            }catch(Exception e){
+            	Log.e(TAG, " Error closing ObjectInputStream");
+            }
+        }
+        return new Record();
+    }
+	
 	private void closeUsbSerial() {
 		mSerial.clearReadListener();
 		mHandlerRead.removeCallbacks(readByListener);
@@ -1268,7 +1408,7 @@ else if ("4".equalsIgnoreCase(type))
 	        				calibrationSelected = MedtronicConstants.CALIBRATION_GLUCOMETER;
 	        				mHandlerSensorCalibration.removeCallbacks(getCalibrationFromSensor);
 	        			}
-						synchronized (medtronicReader.calibrationSelected) {
+						synchronized (medtronicReader.calibrationSelectedLock) {
 	        				medtronicReader.calibrationSelected = calibrationSelected;	
 						}
 	        			
@@ -1301,10 +1441,13 @@ else if ("4".equalsIgnoreCase(type))
     				calibrationSelected = MedtronicConstants.CALIBRATION_GLUCOMETER;
     				mHandlerSensorCalibration.removeCallbacks(getCalibrationFromSensor);
     			}
-				synchronized (medtronicReader.calibrationSelected) {
+				synchronized (medtronicReader.calibrationSelectedLock) {
     				medtronicReader.calibrationSelected = calibrationSelected;	
 				}
-    			
+				String type1 = sharedPreferences.getString("glucSrcTypes", "1");
+				 if (calibrationSelected != MedtronicConstants.CALIBRATION_SENSOR && type1.equals("1")){
+						mHandler3ActivatePump.removeCallbacks(getCalibrationFromSensor);
+					}
     		}
 			if (key.equalsIgnoreCase("pumpPeriod")){
 				 if (sharedPreferences.contains("pumpPeriod")){
@@ -1325,10 +1468,14 @@ else if ("4".equalsIgnoreCase(type))
 						else
 							mHandler3ActivatePump.post(getCalibrationFromSensor);
 				  }
+				 
 			}
 			if (key.equalsIgnoreCase("glucSrcTypes")){
-			
+					
 					String type1 = sharedPreferences.getString("glucSrcTypes", "1");
+					if (calibrationSelected != MedtronicConstants.CALIBRATION_SENSOR && type1.equals("1")){
+						mHandler3ActivatePump.removeCallbacks(getCalibrationFromSensor);
+					}
 					if (type1.equals("2")){
 						medtronicReader.mHandlerCheckLastRead = null;
 						medtronicReader.checkLastRead = null;
@@ -1413,12 +1560,15 @@ else  if ("4".equalsIgnoreCase(type))
 				editor.putLong("lastHistoricRead", System.currentTimeMillis());
 				editor.commit();
 			}
+			if (key.equals("MongoDB URI")){
+				initializeDB();
+			}
 			if (key.equals("medtronic_cgm_id") || key.equals("glucometer_cgm_id") || key.equals("sensor_cgm_id")) {
 				String newID = sharedPreferences.getString("medtronic_cgm_id", "");
 				if (newID != null && !"".equals(newID.replaceAll(" ", ""))) {
 					mHandlerCheckSerial.removeCallbacks(readAndUpload);
 					byte[] newIdPump = HexDump.hexStringToByteArray(newID);
-					if (!Arrays.equals(newIdPump, medtronicReader.idPump)) {
+					if (key.equals("medtronic_cgm_id") && !Arrays.equals(newIdPump, medtronicReader.idPump)) {
 						SharedPreferences.Editor editor = settings.edit();
 						editor.remove("lastGlucometerMessage");
 						editor.remove("previousValue");
@@ -1433,7 +1583,7 @@ else  if ("4".equalsIgnoreCase(type))
 						editor.remove("expectedSensorSortNumberForCalibration1");
 						editor.remove("lastPumpAwake");
 						editor.commit();
-						synchronized (mHandlerCheckSerial) {
+						synchronized (checkSerialLock) {
 
 							mHandlerCheckSerial.removeCallbacks(readAndUpload);
 
@@ -1443,7 +1593,7 @@ else  if ("4".equalsIgnoreCase(type))
 						medtronicReader = new MedtronicReader(mSerial,
 								getBaseContext(), mClients, null);
 						medtronicReader.idPump = newIdPump;
-						synchronized (mHandlerCheckSerial) {
+						synchronized (checkSerialLock) {
 							mHandlerCheckSerial.post(readAndUpload);
 							mHandlerActive = true;
 							if (medtronicReader != null) {
@@ -1528,6 +1678,32 @@ else  if ("11".equalsIgnoreCase(type))
 							}
 
 						}
+					}else{
+						if (key.equalsIgnoreCase("glucometer_cgm_id") && prefs.contains("glucometer_cgm_id")) {
+							if (prefs.getString("glucometer_cgm_id", "").length() > 0) {
+								if (!medtronicReader.knownDevices.contains(prefs.getString("glucometer_cgm_id", ""))){
+									medtronicReader.knownDevices.add(prefs.getString("glucometer_cgm_id", ""));
+								}
+								medtronicReader.idGluc = HexDump.hexStringToByteArray(prefs.getString(
+									"glucometer_cgm_id", ""));
+								
+							}
+						}
+						if (key.equalsIgnoreCase("sensor_cgm_id") && prefs.contains("sensor_cgm_id")) {
+							if (prefs.getString("sensor_cgm_id", "").length() > 0) {
+								String sensorID = HexDump.toHexString(Integer.parseInt(prefs
+										.getString("sensor_cgm_id", "0")));
+								while (sensorID != null && sensorID.length() > 6) {
+									sensorID = sensorID.substring(1);
+								}
+								if (!medtronicReader.knownDevices.contains(sensorID)){
+									medtronicReader.knownDevices.add(sensorID);
+								}
+								medtronicReader.idSensor = HexDump.hexStringToByteArray(sensorID);
+							}
+						}
+						medtronicReader.storeKnownDevices();
+						mHandlerCheckSerial.post(readAndUpload);
 					}
 				}
 			}
@@ -1552,10 +1728,10 @@ else  if ("11".equalsIgnoreCase(type))
 		public void run() {
 			boolean executed = false;
 			try {
-				synchronized (mSerial) {
+				synchronized (mSerialLock) {
 					
 					if (mSerial.isOpened()) {
-						synchronized (medtronicReader.processingCommand) {
+						synchronized (medtronicReader.processingCommandLock) {
 							if (medtronicReader.processingCommand){
 								while (medtronicReader.processingCommand) {
 									if (medtronicReader.processingCommand) {
@@ -1603,7 +1779,7 @@ public void run() {
 					;
 				}
 				sendMessageToUI(sb1.toString(), false);
-				synchronized (medtronicReader.processingCommand) {
+				synchronized (medtronicReader.processingCommandLock) {
 					medtronicReader.processingCommand = false;
 				}
 			}finally{
@@ -1624,18 +1800,18 @@ public void run() {
 		public void run() {
 			boolean bAfterPeriod = false;
 			try {
-				log.info("Read data from Historic");
-				synchronized (mSerial) {
+				log.debug("Read data from Historic");
+				synchronized (mSerialLock) {
 					if (mSerial.isOpened()) {
-						log.info("mserial open");
-						synchronized (medtronicReader.processingCommand) {
+						log.debug("mserial open");
+						synchronized (medtronicReader.processingCommandLock) {
 							if (medtronicReader.processingCommand){
 								while (medtronicReader.processingCommand) {
 									if (medtronicReader.processingCommand) {
 										if (!prefs.getString("glucSrcTypes","1").equals("1")){
 											mHandlerReadFromHistoric.postDelayed(readDataFromHistoric,
 													MedtronicConstants.TIMEOUT);
-											log.info("TIMEOUT");
+											log.debug("TIMEOUT");
 										}
 										bAfterPeriod = true;
 										return;
@@ -1650,7 +1826,7 @@ public void run() {
 						
 						
 						if (prefs.getString("glucSrcTypes","1").equals("2")){
-							log.info("EQUALS 2");
+							log.debug("EQUALS 2");
 							medtronicReader.mHandlerCheckLastRead = null;
 							medtronicReader.checkLastRead = null;
 				        	String type = prefs.getString("historicPeriod", "1");
@@ -1664,7 +1840,7 @@ else  if ("4".equalsIgnoreCase(type))
 				        		historicLogPeriod = MedtronicConstants.TIME_5_MIN_IN_MS;
 				        
 				        	if (settings.getLong("lastHistoricRead", 0) != 0 ){
-				        		log.info("PREVIOUS READ");
+				        		log.debug("PREVIOUS READ");
 								if ((System.currentTimeMillis() - settings.getLong("lastHistoricRead", 0)) >= historicLogPeriod ){
 									if (hGetter == null){
 										hGetter = new HistoricGetterThread(mClients, medtronicReader,
@@ -1672,7 +1848,7 @@ else  if ("4".equalsIgnoreCase(type))
 										
 									}else{
 										hGetter.init();
-										synchronized (medtronicReader.processingCommand) {
+										synchronized (medtronicReader.processingCommandLock) {
 											medtronicReader.processingCommand = true;
 										}
 										medtronicReader.historicPageIndex = -1;
@@ -1680,29 +1856,29 @@ else  if ("4".equalsIgnoreCase(type))
 										medtronicReader.datalog = new DataLog();
 									}
 									medtronicReader.hGetter = hGetter;
-									log.info("SEND GETTER!!!!!");
+									log.debug("SEND GETTER!!!!!");
 									mHandlerReadFromHistoric.post(hGetter);
 									SharedPreferences.Editor editor = settings.edit();
 									editor.putLong("lastHistoricRead", System.currentTimeMillis());
 									editor.commit();
 								}else{
-									log.info("Read after delay");
+									log.debug("Read after delay");
 									bAfterPeriod = true;
 									mHandlerReadFromHistoric.postDelayed(readDataFromHistoric,historicLogPeriod);
-									synchronized (medtronicReader.processingCommand) {
+									synchronized (medtronicReader.processingCommandLock) {
 										medtronicReader.processingCommand = false;
 									}
 									return;
 								}
 							}else{
-								log.info("OTHER ELSE");
+								log.debug("OTHER ELSE");
 								if (hGetter == null){
 									hGetter = new HistoricGetterThread(mClients, medtronicReader,
 											medtronicReader.idPump, mSerial, mHandlerReadFromHistoric);
 									
 								}else{
 									hGetter.init();
-									synchronized (medtronicReader.processingCommand) {
+									synchronized (medtronicReader.processingCommandLock) {
 										medtronicReader.processingCommand = true;
 									}
 									medtronicReader.historicPageIndex = -1;
@@ -1710,7 +1886,7 @@ else  if ("4".equalsIgnoreCase(type))
 									medtronicReader.datalog = new DataLog();
 								}
 								medtronicReader.hGetter = hGetter;
-								log.info("SEND GETTER!!!!!");
+								log.debug("SEND GETTER!!!!!");
 								mHandlerReadFromHistoric.post(hGetter);
 								SharedPreferences.Editor editor = settings.edit();
 								editor.putLong("lastHistoricRead", System.currentTimeMillis());
@@ -1726,7 +1902,7 @@ else  if ("4".equalsIgnoreCase(type))
 								
 							}else{
 								hGetter.init();
-								synchronized (medtronicReader.processingCommand) {
+								synchronized (medtronicReader.processingCommandLock) {
 									medtronicReader.processingCommand = true;
 								}
 								medtronicReader.historicPageIndex = -1;
@@ -1735,7 +1911,7 @@ else  if ("4".equalsIgnoreCase(type))
 							}
 							medtronicReader.hGetter = hGetter;
 							mHandlerReadFromHistoric.post(hGetter);
-							log.info("SEND GETTER!!!!!");
+							log.debug("SEND GETTER!!!!!");
 					        mHandlerCheckLastRead.postDelayed(checkLastRead, MedtronicConstants.TIME_30_MIN_IN_MS);
 						}
 						
@@ -1752,11 +1928,11 @@ else  if ("4".equalsIgnoreCase(type))
 					;
 				}
 				sendMessageToUI(sb1.toString(), false);
-				synchronized (medtronicReader.processingCommand) {
+				synchronized (medtronicReader.processingCommandLock) {
 					medtronicReader.processingCommand = false;
 				}
 			}finally{
-				log.info("Executing read_Historic finally");
+				log.debug("Executing read_Historic finally");
 				if (prefs.getString("glucSrcTypes","1").equals("2")){
 					
 		        	String type = prefs.getString("historicPeriod", "1");
@@ -1802,17 +1978,17 @@ else  if ("4".equalsIgnoreCase(type))
 	private Runnable getCalibrationFromSensor = new Runnable() {
 		public void run() {
 			try {
-				log.info("getting Calibration factor!!");
-				synchronized (mSerial) {
-					log.info("mSerial synchronized!");
+				log.debug("getting Calibration factor!!");
+				synchronized (mSerialLock) {
+					log.debug("mSerial synchronized!");
 					if (mSerial.isOpened()) {
-						log.info("mSerial open!!");
+						log.debug("mSerial open!!");
 						if (calibrationSelected == MedtronicConstants.CALIBRATION_SENSOR) {
-							synchronized (medtronicReader.processingCommand) {
+							synchronized (medtronicReader.processingCommandLock) {
 								if (medtronicReader.processingCommand){
 									while (medtronicReader.processingCommand) {
 										if (medtronicReader.processingCommand) {
-											log.info("is processing other commands wait 3 secs.");
+											log.debug("is processing other commands wait 3 secs.");
 											mHandlerSensorCalibration.postDelayed(getCalibrationFromSensor,
 													MedtronicConstants.TIMEOUT);
 											return;
@@ -1828,7 +2004,7 @@ public void run() {
 									MedtronicConstants.MEDTRONIC_GET_CALIBRATION_FACTOR,
 									MedtronicConstants.MEDTRONIC_GET_REMAINING_INSULIN,
 									MedtronicConstants.MEDTRONIC_GET_BATTERY_STATUS};
-							log.info("get Cal Factor and other info!!");
+							log.debug("get Cal Factor and other info!!");
 	
 							//mHandler2CheckDevice.removeCallbacks(cMThread);
 							cMThread = new CommandSenderThread(medtronicReader,
@@ -1854,7 +2030,7 @@ public void run() {
 					;
 				}
 				sendMessageToUI(sb1.toString(), false);
-				synchronized (medtronicReader.processingCommand) {
+				synchronized (medtronicReader.processingCommandLock) {
 					medtronicReader.processingCommand = false;
 				}
 			}finally{
diff --git a/src/com/nightscout/android/medtronic/MedtronicCalibration.java b/src/com/nightscout/android/medtronic/MedtronicCalibration.java
new file mode 100644
index 0000000..315e749
--- /dev/null
+++ b/src/com/nightscout/android/medtronic/MedtronicCalibration.java
@@ -0,0 +1,5 @@
+package com.nightscout.android.medtronic;
+
+public class MedtronicCalibration {
+
+}
diff --git a/src/com/nightscout/android/medtronic/MedtronicConstants.java b/src/com/nightscout/android/medtronic/MedtronicConstants.java
index a3aa109..4a3ed18 100644
--- a/src/com/nightscout/android/medtronic/MedtronicConstants.java
+++ b/src/com/nightscout/android/medtronic/MedtronicConstants.java
@@ -93,6 +93,9 @@ public class MedtronicConstants {
 	public static final int MSG_MEDTRONIC_SEND_INSTANT_CALIB_VALUE = 12;
 	public static final int MSG_MEDTRONIC_SEND_INSTANT_GLUC_VALUE = 13;
 	public static final int MSG_MEDTRONIC_CALIBRATION_DONE = 14;
+	public static final int MSG_MEDTRONIC_GLUCMEASURE_DETECTED = 15;
+	public static final int MSG_MEDTRONIC_GLUCMEASURE_APPROVED = 16;
+	public static final int MSG_REFRESH_DB_CONNECTION = 17;
 	
 	
 	public static String getCalibrationStrValue(int val){
diff --git a/src/com/nightscout/android/medtronic/MedtronicReader.java b/src/com/nightscout/android/medtronic/MedtronicReader.java
index a9fdc20..67a8dc8 100644
--- a/src/com/nightscout/android/medtronic/MedtronicReader.java
+++ b/src/com/nightscout/android/medtronic/MedtronicReader.java
@@ -12,11 +12,13 @@
 import java.util.Date;
 import java.util.List;
 import java.util.Locale;
-
+import java.util.concurrent.atomic.AtomicBoolean;
 
 import org.slf4j.LoggerFactory;
 
+import android.app.AlertDialog;
 import android.content.Context;
+import android.content.DialogInterface;
 import android.content.SharedPreferences;
 import android.os.Bundle;
 import android.os.Handler;
@@ -24,7 +26,10 @@
 import android.os.Messenger;
 import android.os.RemoteException;
 import android.preference.PreferenceManager;
+import android.text.InputType;
 import android.util.Log;
+import android.widget.EditText;
+import android.widget.TextView.BufferType;
 
 import ch.qos.logback.classic.Logger;
 
@@ -45,9 +50,10 @@
  * 
  */
 public class MedtronicReader {
-	private Logger log = (Logger) LoggerFactory.getLogger(MedtronicReader.class.getName());
+	private Logger log = (Logger) LoggerFactory.getLogger(MedtronicReader.class
+			.getName());
 	private static final String TAG = MedtronicReader.class.getSimpleName();
-	private Physicaloid mSerialDevice;
+	public Physicaloid mSerialDevice;
 
 	protected Context context = null;
 	protected byte[] idPump = null;
@@ -87,17 +93,21 @@ public class MedtronicReader {
 	public Byte lastCommandSend = null; // last command sent from this
 	// application to the pump.
 	public Boolean sendingCommand = false;// shared variable, It tells us that
+	public Object sendingCommandLock = new Object();
 	// the receptor is sending a command
 	// and we have no received the ACK
 	public Boolean processingCommand = false;// shared variable, It tells us
+	public Object processingCommandLock = new Object();
 	// that our service is launching
 	// a set of commands, and it has
 	// not ended yet.
 	public Boolean waitingCommand = false; // shared variable, It tells us that
+	public Object waitingCommandLock = new Object();
 	// the receptor has sent a message
 	// but we do not have the answer
 	// yet.
 	public CircleList<Record> lastRecordsInMemory = new CircleList<Record>(10);// array
+	private Object lastRecordsListLock = new Object();
 	// to
 	// store
 	// last
@@ -112,6 +122,7 @@ public class MedtronicReader {
 	SharedPreferences settings = null;
 	SharedPreferences prefs = null;
 	Integer calibrationSelected = MedtronicConstants.CALIBRATION_GLUCOMETER;
+	Object calibrationSelectedLock = new Object();
 	HistoricGetterThread hGetter = null;
 	int historicPageIndex = -1;
 	int historicPageShift = 0;
@@ -136,9 +147,8 @@ public MedtronicReader(Physicaloid device, Context context,
 		this.hGetter = hGetter;
 		knownDevices = new ArrayList<String>();
 		mSerialDevice = device;
-		prefs = PreferenceManager
-				.getDefaultSharedPreferences(context);
-		synchronized (calibrationSelected) {
+		prefs = PreferenceManager.getDefaultSharedPreferences(context);
+		synchronized (calibrationSelectedLock) {
 			if (prefs.contains("calibrationType")) {
 				String type = prefs.getString("calibrationType", "3");
 				if ("3".equalsIgnoreCase(type))
@@ -165,11 +175,14 @@ else if ("2".equalsIgnoreCase(type)) {
 		}
 		if (prefs.contains("sensor_cgm_id")) {
 			if (prefs.getString("sensor_cgm_id", "").length() > 0) {
-				String sensorID = HexDump.toHexString(Integer.parseInt(prefs.getString("sensor_cgm_id", "0")));
-				while (sensorID != null && sensorID.length() > 6){
-				   sensorID = sensorID.substring(1);
+				String sensorID = HexDump.toHexString(Integer.parseInt(prefs
+						.getString("sensor_cgm_id", "0")));
+				while (sensorID != null && sensorID.length() > 6) {
+					sensorID = sensorID.substring(1);
 				}
-				log.info("SensorID inserted "+prefs.getString("sensor_cgm_id", "0") +" transformed to "+ sensorID);
+				log.debug("SensorID inserted "
+						+ prefs.getString("sensor_cgm_id", "0")
+						+ " transformed to " + sensorID);
 				knownDevices.add(sensorID);
 				idSensor = HexDump.hexStringToByteArray(sensorID);
 			}
@@ -180,19 +193,20 @@ else if ("2".equalsIgnoreCase(type)) {
 			listPrevKnownDevices = settings.getString("knownDevices", "");
 			String[] splitted = listPrevKnownDevices.split(",");
 			for (int i = 0; i < splitted.length; i++) {
-				//log.info("splitted["+i+"]= "+splitted[i]);
-				if (splitted[i] != null && splitted[i].replaceAll(" ", "").length() > 0){
+				// log.debug("splitted["+i+"]= "+splitted[i]);
+				if (splitted[i] != null
+						&& splitted[i].replaceAll(" ", "").length() > 0) {
 					if (!knownDevices.contains(splitted[i]))
 						knownDevices.add(splitted[i]);
 				}
 			}
 		}
 		storeKnownDevices();
-		long currentTime = System.currentTimeMillis();
+		/*long currentTime = System.currentTimeMillis();
 		long diff = currentTime - settings.getLong("lastDestroy", 0);
-		if (diff == currentTime || diff > (2*MedtronicConstants.TIME_12_HOURS_IN_MS)) {
+		if (diff > (2 * MedtronicConstants.TIME_12_HOURS_IN_MS)) {
 			Log.i("Medtronic", "BORRA TODO");
-			log.info("REMOVE ALL PREFERENCES TOO MUCH TIME WITHOUT READING; DATA IS OBSOLETE");
+			log.debug("REMOVE ALL PREFERENCES TOO MUCH TIME WITHOUT READING; DATA IS OBSOLETE");
 			SharedPreferences.Editor editor = settings.edit();
 			editor.remove("lastGlucometerMessage");
 			editor.remove("previousValue");
@@ -217,8 +231,7 @@ else if ("2".equalsIgnoreCase(type)) {
 			editor.remove("last_read");
 			editor.commit();
 			return;
-		}
-
+		}*/
 
 		if (settings.contains("lastSensorValueDate"))
 			lastSensorValueDate = settings.getLong("lastSensorValueDate", 0);
@@ -240,7 +253,7 @@ else if ("2".equalsIgnoreCase(type)) {
 			previousValue = (float) settings.getFloat("previousValue",
 					(float) this.previousValue);
 		if (settings.contains("expectedSensorSortNumber")
-				&& settings.getString("expectedSensorSortNumber", "").length() > 0){
+				&& settings.getString("expectedSensorSortNumber", "").length() > 0) {
 			expectedSensorSortNumber = HexDump.hexStringToByteArray(settings
 					.getString("expectedSensorSortNumber", ""))[0];
 
@@ -271,11 +284,12 @@ else if ("2".equalsIgnoreCase(type)) {
 			}
 		}
 		checkCalibrationOutOfTime();
-		if (settings.contains("last_read")){
+		if (settings.contains("last_read")) {
 			String lastRead = settings.getString("lastRead", "");
-			if (lastRead.length() > 0){
+			if (lastRead.length() > 0) {
 				byte[] last_read = HexDump.hexStringToByteArray(lastRead);
-				ArrayList<byte[]> bufferedMessages = parseMessageData(last_read, last_read.length);
+				ArrayList<byte[]> bufferedMessages = parseMessageData(
+						last_read, last_read.length);
 				if (bufferedMessages != null && bufferedMessages.size() > 0)
 					processBufferedMessages(bufferedMessages);
 			}
@@ -291,24 +305,31 @@ else if ("2".equalsIgnoreCase(type)) {
 	 */
 	private boolean isMessageFromMyDevices(byte[] readData) {
 		int initByte = firstByteOfDeviceId(readData);
-		if (initByte < 0 || readData.length < initByte)
+		if (initByte < 0 || readData.length < initByte){
+			log.error("Error checking initByte and received length, I can't check If is from 'My devices'");
 			return false;
+		}
 		for (String knownDevice : knownDevices) {
 			int nBytes = knownDevice.length() / 2;
 			if (knownDevice.length() % 2 > 0 && knownDevice.length() > 2) {
 				nBytes++;
 			}
-			if (readData.length < (nBytes + initByte))
+			if (readData.length < (nBytes + initByte)){
+				log.error("Error checking received length, I can't check If is from 'My devices'");
 				return false;
+			}
 			String deviceCode = HexDump.toHexString(readData, initByte, nBytes);
+			
 			if (knownDevice.equals(deviceCode))
 				return true;
+			else
+				log.error("Current Known Device "+knownDevice+" Message Received From "+deviceCode);
 		}
 		return false;
 	}
 
 	/**
-	 * Sends a message to be printed in the display (DEBUG) or launches a pop-up
+	 * Sends a message glucMessage
 	 * message.
 	 * 
 	 * @param valuetosend
@@ -316,9 +337,37 @@ private boolean isMessageFromMyDevices(byte[] readData) {
 	 *            , if true, the display is cleared before printing
 	 *            "valuetosend"
 	 */
+	private void sendGlucMessageToUI(float valuetosend, boolean calibration, boolean isCalFactorFromPump) {
+		// log.debug("MedtronicReader Sends to UI "+valuetosend);
+		if (mClients != null && mClients.size() > 0) {
+			for (int i = mClients.size() - 1; i >= 0; i--) {
+				try {
+					Message mSend = null;
+					
+					mSend = Message
+							.obtain(null,
+									MedtronicConstants.MSG_MEDTRONIC_GLUCMEASURE_DETECTED);
+					Bundle b = new Bundle();
+					b.putFloat("data", valuetosend);
+					b.putBoolean("calibrating", calibration);
+					b.putBoolean("isCalFactorFromPump", isCalFactorFromPump);
+					mSend.setData(b);
+					mClients.get(i).send(mSend);
+
+				} catch (RemoteException e) {
+					// The client is dead. Remove it from the list; we are going
+					// through the list from back to front so this is safe to do
+					// inside the loop.
+					mClients.remove(i);
+				}
+			}
+		} /*
+		 * else { displayMessage(valuetosend); }
+		 */
+	}
 	private void sendMessageToUI(String valuetosend, boolean clear) {
 		Log.i("medtronicReader", valuetosend);
-		//log.info("MedtronicReader Sends to UI "+valuetosend);
+		// log.debug("MedtronicReader Sends to UI "+valuetosend);
 		if (mClients != null && mClients.size() > 0) {
 			for (int i = mClients.size() - 1; i >= 0; i--) {
 				try {
@@ -345,11 +394,10 @@ private void sendMessageToUI(String valuetosend, boolean clear) {
 					mClients.remove(i);
 				}
 			}
-		} /*else {
-			displayMessage(valuetosend);
-		}*/
+		} /*
+		 * else { displayMessage(valuetosend); }
+		 */
 	}
-
 	/**
 	 * 
 	 * @param readData
@@ -380,18 +428,19 @@ private int firstByteAfterDeviceId(byte[] readData) {
 		if (initByte < 0 || readData.length < initByte)
 			return -1;
 		for (String knownDevice : knownDevices) {
-			if (knownDevice == null || knownDevice.replaceAll(" ", "").length() == 0)
+			if (knownDevice == null
+					|| knownDevice.replaceAll(" ", "").length() == 0)
 				continue;
-			
+
 			int nBytes = knownDevice.length() / 2;
 			if (knownDevice.length() % 2 > 0 && knownDevice.length() > 2) {
 				nBytes++;
 			}
-	
+
 			if (readData.length < (nBytes + initByte))
 				return -1;
 			String deviceCode = HexDump.toHexString(readData, initByte, nBytes);
-			
+
 			if (knownDevice.equals(deviceCode))
 				return (nBytes + initByte);
 		}
@@ -459,8 +508,8 @@ public ArrayList<byte[]> readFromReceiver(Context context, int size) {
 		ArrayList<byte[]> bufferedMessages = null;
 		byte[] readFromDevice = new byte[1024];
 		int read = 0;
-		if (size >= 0){
-			log.info("readFromReceiver!! a leer "+size+" bytes!!");
+		if (size >= 0) {
+			log.debug("readFromReceiver!! a leer " + size + " bytes!!");
 			try {
 				read = mSerialDevice.read(readFromDevice);
 			} catch (Exception e) {
@@ -470,13 +519,11 @@ public ArrayList<byte[]> readFromReceiver(Context context, int size) {
 			}
 		}
 		if (read > 0) {
-			Log.d("medtronic",
-					"READ "
-							+ read);
+			Log.d("medtronic", "READ " + read);
 
-			log.info("Stream Received; bytes read: "+read);//+"  "+HexDump.toHexString(Arrays.copyOfRange(readFromDevice,0,read)));
-		}else
-			log.info("NOTHING TO READ");
+			log.debug("Stream Received; bytes read: " + read);// +"  "+HexDump.toHexString(Arrays.copyOfRange(readFromDevice,0,read)));
+		} else
+			log.debug("NOTHING TO READ");
 		if (read > 0) {
 			SharedPreferences.Editor editor = settings.edit();
 			editor.putLong("lastDestroy", System.currentTimeMillis());
@@ -510,8 +557,8 @@ public ArrayList<byte[]> readFromReceiver(Context context, int size) {
 	public String processBufferedMessages(ArrayList<byte[]> bufferedMessages) {
 		StringBuffer sResponse = new StringBuffer("");
 		int calibrationSelectedAux = 0;
-		log.info("processBufferedMessages");
-		synchronized (calibrationSelected) {
+		log.debug("processBufferedMessages");
+		synchronized (calibrationSelectedLock) {
 			calibrationSelectedAux = calibrationSelected;
 		}
 		try {
@@ -519,12 +566,12 @@ public String processBufferedMessages(ArrayList<byte[]> bufferedMessages) {
 				if (checkFirstByte(readData[0])) {
 					switch (getAnswerType(readData[0])) {
 					case MedtronicConstants.DATA_ANSWER:
-						log.info("IS DATA ANSWER");
+						log.debug("IS DATA ANSWER");
 						if (isMessageFromMyDevices(readData)) {
-							log.info("IS FROM MY DEVICES");
+							log.debug("IS FROM MY DEVICES");
 							switch (readData[2]) {
 							case MedtronicConstants.MEDTRONIC_PUMP:
-								log.info("IS A PUMP MESSAGE");
+								log.debug("IS A PUMP MESSAGE");
 								sResponse.append(
 										processPumpDataMessage(readData,
 												calibrationSelectedAux))
@@ -533,14 +580,15 @@ public String processBufferedMessages(ArrayList<byte[]> bufferedMessages) {
 									lastMedtronicPumpRecord = new MedtronicPumpRecord();
 									calculateDate(lastMedtronicPumpRecord,
 											new Date(), 0);
-									lastMedtronicPumpRecord.deviceId = prefs.getString("medtronic_cgm_id", "");
+									lastMedtronicPumpRecord.deviceId = prefs
+											.getString("medtronic_cgm_id", "");
 								}
-								lastMedtronicPumpRecord.isWarmingUp = prefs.getBoolean("isWarmingUp", false);
+								lastMedtronicPumpRecord.isWarmingUp = prefs
+										.getBoolean("isWarmingUp", false);
 								break;
 							case MedtronicConstants.MEDTRONIC_GL: {
-								
-								if (calibrationSelectedAux == MedtronicConstants.CALIBRATION_GLUCOMETER) {
-									log.info("GLUCOMETER DATA RECEIVED");
+								//if (calibrationSelectedAux == MedtronicConstants.CALIBRATION_GLUCOMETER) {
+									log.debug("GLUCOMETER DATA RECEIVED");
 									if (lastGlucometerMessage == null
 											|| lastGlucometerMessage.length == 0) {
 										lastGlucometerMessage = Arrays
@@ -567,29 +615,35 @@ public String processBufferedMessages(ArrayList<byte[]> bufferedMessages) {
 												.copyOfRange(readData, 0,
 														readData.length);
 									}
-									sResponse
-									.append(processGlucometerDataMessage(readData, true))
-									.append("\n");
+									sResponse.append(
+											processGlucometerDataMessage(
+													readData, false)).append(
+															"\n"); // Cambiado a false
 									if (lastGlucometerValue > 0) {
-										isCalibrating = true;
+											isCalibrating = calibrationSelectedAux == MedtronicConstants.CALIBRATION_GLUCOMETER;
 										if (previousRecord == null) {
 											MedtronicSensorRecord auxRecord = new MedtronicSensorRecord();
-											auxRecord.isCalibrating = true;
-											log.info("1");
+											 
+												auxRecord.isCalibrating = calibrationSelectedAux == MedtronicConstants.CALIBRATION_GLUCOMETER;
+											log.debug("1");
 											writeLocalCSV(auxRecord, context);
 										} else {
-											previousRecord.isCalibrating = true;
-											log.info("2");
+											previousRecord.isCalibrating = calibrationSelectedAux == MedtronicConstants.CALIBRATION_GLUCOMETER;
+											log.debug("2");
 											writeLocalCSV(previousRecord,
 													context);
 										}
 										SharedPreferences.Editor editor = settings
 												.edit();
-										editor.putBoolean("isCalibrating", true);
-										sendMessageToUI("isCalibrating", false);
+										
+											editor.putBoolean("isCalibrating", calibrationSelectedAux == MedtronicConstants.CALIBRATION_GLUCOMETER);
+											if (calibrationSelectedAux == MedtronicConstants.CALIBRATION_GLUCOMETER)
+												sendMessageToUI("isCalibrating", false);
+											sendMessageToUI("glucometer data received", false);
+										
 										editor.commit();
 									}
-								}else if (calibrationSelectedAux == MedtronicConstants.CALIBRATION_SENSOR){
+								/*} else if (calibrationSelectedAux == MedtronicConstants.CALIBRATION_SENSOR) {
 									if (lastGlucometerMessage == null
 											|| lastGlucometerMessage.length == 0) {
 										lastGlucometerMessage = Arrays
@@ -602,7 +656,7 @@ public String processBufferedMessages(ArrayList<byte[]> bufferedMessages) {
 										editor.putString(
 												"lastGlucometerMessage",
 												HexDump.toHexString(lastGlucometerMessage));
-										
+
 										editor.commit();
 									} else {
 										boolean isEqual = Arrays
@@ -619,15 +673,12 @@ public String processBufferedMessages(ArrayList<byte[]> bufferedMessages) {
 												.copyOfRange(readData, 0,
 														readData.length);
 									}
-									sResponse.append("Glucomenter Deteted!! \n").append(processGlucometerDataMessage(readData, false));
-									sendMessageToUI("Glucometer Detected!!..Waiting 15 min. to retrieve calibration factor...", false);
-									log.info("Glucometer Detected!!..Waiting 15 min. to retrieve calibration factor...");
-									if (mHandlerSensorCalibration != null && getCalibrationFromSensor != null){
-										mHandlerSensorCalibration.removeCallbacks(getCalibrationFromSensor);
-										mHandlerSensorCalibration.postDelayed(getCalibrationFromSensor, MedtronicConstants.TIME_15_MIN_IN_MS + 120000);
-									}else
-										log.info("glucometer handler or glucometer runnable is null");
-								}else{
+									sResponse
+									.append("Glucomenter Deteted!! \n")
+									.append(processGlucometerDataMessage(
+											readData, false));
+								} else {
+									isCalibrating = false;
 									if (lastGlucometerMessage == null
 											|| lastGlucometerMessage.length == 0) {
 										lastGlucometerMessage = Arrays
@@ -640,7 +691,7 @@ public String processBufferedMessages(ArrayList<byte[]> bufferedMessages) {
 										editor.putString(
 												"lastGlucometerMessage",
 												HexDump.toHexString(lastGlucometerMessage));
-										
+
 										editor.commit();
 									} else {
 										boolean isEqual = Arrays
@@ -657,25 +708,32 @@ public String processBufferedMessages(ArrayList<byte[]> bufferedMessages) {
 												.copyOfRange(readData, 0,
 														readData.length);
 									}
-									sResponse.append("Glucomenter Deteted!! \n").append(processGlucometerDataMessage(readData, false));
-								}
+									sResponse
+									.append("Glucomenter Deteted!! \n")
+									.append(processGlucometerDataMessage(
+											readData, false));
+								}*/
 								break;
 							}
-							case MedtronicConstants.MEDTRONIC_SENSOR1:{
-								if (prefs.getString("glucSrcTypes","1").equals("2")){
-									log.info("Sensor value received, but value is took only by pump logs");
+							case MedtronicConstants.MEDTRONIC_SENSOR1: {
+								if (prefs.getString("glucSrcTypes", "1")
+										.equals("2")) {
+									log.debug("Sensor value received, but value is took only by pump logs");
 									break;
 								}
-								log.info("WARMING_UP");
-								SharedPreferences.Editor editor = settings.edit();
+								log.debug("WARMING_UP");
+								SharedPreferences.Editor editor = settings
+										.edit();
 								editor.remove("lastGlucometerMessage");
 								editor.remove("previousValue");
 								editor.remove("expectedSensorSortNumber");
 								editor.remove("isCalibrating");
 								calibrationStatus = MedtronicConstants.WITHOUT_ANY_CALIBRATION;
-								editor.putInt("calibrationStatus", MedtronicConstants.WITHOUT_ANY_CALIBRATION);
+								editor.putInt(
+										"calibrationStatus",
+										MedtronicConstants.WITHOUT_ANY_CALIBRATION);
 								editor.remove("calibrationFactor");
-								log.info("remove lastCalibrationDate");
+								log.debug("remove lastCalibrationDate");
 								editor.remove("lastCalibrationDate");
 								editor.remove("lastGlucometerValue");
 								editor.remove("lastGlucometerDate");
@@ -683,60 +741,71 @@ public String processBufferedMessages(ArrayList<byte[]> bufferedMessages) {
 								editor.remove("expectedSensorSortNumberForCalibration0");
 								editor.remove("expectedSensorSortNumberForCalibration1");
 								editor.remove("isCheckedWUP");
-								if (!prefs.getBoolean("isWarmingUp", false)){
+								if (!prefs.getBoolean("isWarmingUp", false)) {
 									if (lastMedtronicPumpRecord == null) {
 										lastMedtronicPumpRecord = new MedtronicPumpRecord();
 										calculateDate(lastMedtronicPumpRecord,
 												new Date(), 0);
-										lastMedtronicPumpRecord.deviceId = prefs.getString("medtronic_cgm_id", "");
+										lastMedtronicPumpRecord.deviceId = prefs
+												.getString("medtronic_cgm_id",
+														"");
 									}
 
 									editor.putBoolean("isWarmingUp", true);
 
 									lastMedtronicPumpRecord.isWarmingUp = true;
 								}
-								
+
 								if (previousRecord == null) {
 									MedtronicSensorRecord auxRecord = new MedtronicSensorRecord();
 									calculateDate(auxRecord, new Date(), 0);
-									log.info("3");
+									log.debug("3");
 									writeLocalCSV(auxRecord, context);
-								}else{
+								} else {
 									calculateDate(previousRecord, new Date(), 0);
-									log.info("4");
+									log.debug("4");
 									writeLocalCSV(previousRecord, context);
 								}
 								sendMessageToUI("sensor data wUp.", false);
 								editor.commit();
 								break;
-							}case MedtronicConstants.MEDTRONIC_SENSOR2:
-								
+							}
+							case MedtronicConstants.MEDTRONIC_SENSOR2:
+
 								if (lastMedtronicPumpRecord != null)
 									lastMedtronicPumpRecord.isWarmingUp = false;
-								if (prefs.getString("glucSrcTypes","1").equals("2")){
-									if (prefs.getBoolean("isWarmingUp", false)){
+								if (prefs.getString("glucSrcTypes", "1")
+										.equals("2")) {
+									if (prefs.getBoolean("isWarmingUp", false)) {
 										if (lastMedtronicPumpRecord == null) {
 											lastMedtronicPumpRecord = new MedtronicPumpRecord();
-											calculateDate(lastMedtronicPumpRecord,
+											calculateDate(
+													lastMedtronicPumpRecord,
 													new Date(), 0);
-											lastMedtronicPumpRecord.deviceId = prefs.getString("medtronic_cgm_id", "");
+											lastMedtronicPumpRecord.deviceId = prefs
+													.getString(
+															"medtronic_cgm_id",
+															"");
 										}
 										lastMedtronicPumpRecord.isWarmingUp = false;
-										SharedPreferences.Editor editor1 = prefs.edit();
+										SharedPreferences.Editor editor1 = prefs
+												.edit();
 										editor1.putBoolean("isWarmingUp", false);
 										editor1.commit();
 									}
-									log.info("Sensor value received, but value is took only by pump logs");
+									log.debug("Sensor value received, but value is took only by pump logs");
 									break;
 								}
 								Log.i("MEdtronic", "process sensor2");
-								log.info("SENSOR DATA RECEIVED");
-								if (prefs.getBoolean("isWarmingUp", false)){
+								log.debug("SENSOR DATA RECEIVED");
+								if (prefs.getBoolean("isWarmingUp", false)) {
 									if (lastMedtronicPumpRecord == null) {
 										lastMedtronicPumpRecord = new MedtronicPumpRecord();
 										calculateDate(lastMedtronicPumpRecord,
 												new Date(), 0);
-										lastMedtronicPumpRecord.deviceId = prefs.getString("medtronic_cgm_id", "");
+										lastMedtronicPumpRecord.deviceId = prefs
+												.getString("medtronic_cgm_id",
+														"");
 									}
 									lastMedtronicPumpRecord.isWarmingUp = false;
 									SharedPreferences.Editor editor = prefs
@@ -757,27 +826,29 @@ public String processBufferedMessages(ArrayList<byte[]> bufferedMessages) {
 									editor.putBoolean("isCalibrating", false);
 									editor.commit();
 								}
-								sendMessageToUI("sensor data value received", false);
+								sendMessageToUI("sensor data value received",
+										false);
 								break;
 							default:
 								Log.i("MEdtronic", "No Match");
-								log.info("I can't understand this message");
+								log.debug("I can't understand this message");
 								sResponse
 								.append("I can't process this message, no device match.")
 								.append("\n");
 								break;
 							}
 						} else {
-							Log.i("Medtronic", "I dont have to listen to this. This message comes from another source.");
-							log.info("I don't have to listen to this message. This message comes from another source.");
-							sResponse.append(
-									"I don't have to listen to this. This message comes from another source.")
-											.append("\n");
+							Log.i("Medtronic",
+									"I dont have to listen to this. This message comes from another source.");
+							log.debug("I don't have to listen to this message. This message comes from another source.");
+							sResponse
+							.append("I don't have to listen to this. This message comes from another source.")
+							.append("\n");
 						}
 						break;
 					case MedtronicConstants.COMMAND_ANSWER:
-						log.info("ACK Received");
-						synchronized (sendingCommand) {
+						log.debug("ACK Received");
+						synchronized (sendingCommandLock) {
 							sendingCommand = false;
 						}
 						break;
@@ -787,18 +858,17 @@ public String processBufferedMessages(ArrayList<byte[]> bufferedMessages) {
 						else
 							sResponse.append("FILTER ACTIVATED").append("\n");
 						break;
-					default:{
-						log.info("I don't understand this message "+ HexDump.toHexString(readData));
+					default: {
+						log.debug("I don't understand this message "
+								+ HexDump.toHexString(readData));
 						sResponse.append(
 								"I don't understand the received message ")
-										.append("\n");
+								.append("\n");
 					}
 					}
-				} else{
-					sResponse.append(
-							"CRC Error ")
-							.append("\n");
-					log.info("CRC ERROR!!! " + HexDump.dumpHexString(readData));
+				} else {
+					sResponse.append("CRC Error ").append("\n");
+					log.debug("CRC ERROR!!! " + HexDump.dumpHexString(readData));
 				}
 			}
 		} catch (Exception ex2) {
@@ -828,7 +898,7 @@ public String processBufferedMessages(ArrayList<byte[]> bufferedMessages) {
 	 */
 	private ArrayList<byte[]> parseMessageData(byte[] readData, int read) {
 		byte[] readBuffer = null;
-		log.info("PARSE MESSAGE");
+		log.debug("PARSE MESSAGE");
 		ArrayList<byte[]> messageList = new ArrayList<byte[]>();
 		if (notFinishedRead == null || notFinishedRead.length <= 0) {
 			readBuffer = Arrays.copyOf(readData, read);
@@ -851,7 +921,7 @@ private ArrayList<byte[]> parseMessageData(byte[] readData, int read) {
 		while (i < readBuffer.length) {
 			int answer = getAnswerType(readBuffer[i]);
 			if (answer == MedtronicConstants.COMMAND_ANSWER) {
-				log.info("COMMAND");
+				log.debug("COMMAND");
 				if (readBuffer.length >= i + 3)
 					messageList.add(Arrays.copyOfRange(readBuffer, i, i + 3));
 				else {
@@ -861,33 +931,39 @@ private ArrayList<byte[]> parseMessageData(byte[] readData, int read) {
 				}
 				i += 3;
 			} else if (answer == MedtronicConstants.FILTER_COMMAND) {
-				log.info("FILTERCOMMAND");
+				log.debug("FILTERCOMMAND");
 				messageList.add(Arrays.copyOfRange(readBuffer, i, i + 1));
 				i++;
 			} else if (answer == MedtronicConstants.CRC_ERROR) {
-				log.info("CRC ERROR");
-				if (hGetter != null && hGetter.isWaitingNextLine){
-					if (hGetter.timeout >= 2){
+				log.debug("CRC ERROR");
+				if (hGetter != null && hGetter.isWaitingNextLine) {
+					if (hGetter.timeout >= 2) {
 						hGetter.timeout = 0;
-						log.info("too much retries");
-						sendMessageToUI("historic log read aborted! too much crc errors, waiting to retry.", false);
-					}else{
-						sendMessageToUI("CRC error reading historic log line, reinitializating read...", false);
+						log.debug("too much retries");
+						sendMessageToUI(
+								"historic log read aborted! too much crc errors, waiting to retry.",
+								false);
+					} else {
+						sendMessageToUI(
+								"CRC error reading historic log line, reinitializating read...",
+								false);
 						hGetter.timeout++;
-						hGetter.commandList = Arrays.copyOf(hGetter.commandList, hGetter.commandList.length+1);
-						hGetter.commandList[hGetter.commandList.length-1] = MedtronicConstants.MEDTRONIC_READ_PAGE_COMMAND;
+						hGetter.commandList = Arrays.copyOf(
+								hGetter.commandList,
+								hGetter.commandList.length + 1);
+						hGetter.commandList[hGetter.commandList.length - 1] = MedtronicConstants.MEDTRONIC_READ_PAGE_COMMAND;
 						hGetter.firstReadPage = true;
 						hGetter.isWaitingNextLine = true;
 						hGetter.withoutConfirmation = 0;
 						hGetter.currentLine = -1;
 						hGetter.historicPage.clear();
-						synchronized (waitingCommand) {
+						synchronized (waitingCommandLock) {
 							waitingCommand = false;
 							lastCommandSend = null;
 						}
 					}
 				}
-				if (readBuffer.length <= i + 1){
+				if (readBuffer.length <= i + 1) {
 					notFinishedRead = Arrays.copyOfRange(readBuffer, i,
 							readBuffer.length);
 					return messageList;
@@ -906,7 +982,7 @@ private ArrayList<byte[]> parseMessageData(byte[] readData, int read) {
 					return messageList;
 				}
 			} else if (answer == MedtronicConstants.DATA_ANSWER) {
-				log.info("DATA_ANSWER");
+				log.debug("DATA_ANSWER");
 				if (readBuffer.length <= i + 1) {
 					notFinishedRead = Arrays.copyOfRange(readBuffer, i,
 							readBuffer.length);
@@ -950,91 +1026,107 @@ public String processPumpDataMessage(byte[] readData,
 		if (lastCommandSend == null)
 			return "lastCommand == null";
 		switch (readData[commandByte]) {
-		case MedtronicConstants.MEDTRONIC_GET_LAST_PAGE:{
+		case MedtronicConstants.MEDTRONIC_GET_LAST_PAGE: {
 			if (lastCommandSend != null) {
-				synchronized (waitingCommand) {
+				synchronized (waitingCommandLock) {
 					waitingCommand = false;
 					lastCommandSend = null;
 				}
 				byte[] modelArray = Arrays.copyOfRange(readData,
-						commandByte + 2,
-						(commandByte + 6));
+						commandByte + 2, (commandByte + 6));
 				historicPageIndex = HexDump.byteArrayToInt(modelArray);
 				hGetter.historicPageIndex = historicPageIndex;
 				hGetter.lastHistoricPage = modelArray;
 				String sModel = new String(HexDump.toHexString(modelArray));
-				sResult = "Command "+commandByte+" Read Data "+HexDump.toHexString(readData)+" Pump last historic page......: " + sModel;
+				sResult = "Command " + commandByte + " Read Data "
+						+ HexDump.toHexString(readData)
+						+ " Pump last historic page......: " + sModel;
 			}
-			log.info(sResult);
+			log.debug(sResult);
 			return sResult;
 		}
-		case MedtronicConstants.MEDTRONIC_READ_PAGE_COMMAND:{
-			log.info("READ_PAGE");
-			
+		case MedtronicConstants.MEDTRONIC_READ_PAGE_COMMAND: {
+			log.debug("READ_PAGE");
+
 			if (lastCommandSend != null) {
-				try{
-					log.info("lcommand send != null");
-					if (!hGetter.firstReadPage){
+				try {
+					log.debug("lcommand send != null");
+					if (!hGetter.firstReadPage) {
 						hGetter.isWaitingNextLine = false;
-						int currentLineAux = HexDump.unsignedByte(readData[commandByte+1]);
-						log.info("!first page ");
-						if (!(currentLineAux == HexDump.unsignedByte((byte)0x90) || (currentLineAux == hGetter.currentLine+1) || hGetter.currentLine < 1 && currentLineAux == 1)){
-							log.info("Error");
-							hGetter.commandList = Arrays.copyOf(hGetter.commandList, hGetter.commandList.length+1);
-							hGetter.commandList[hGetter.commandList.length-1] = MedtronicConstants.MEDTRONIC_READ_PAGE_COMMAND;
+						int currentLineAux = HexDump
+								.unsignedByte(readData[commandByte + 1]);
+						log.debug("!first page ");
+						if (!(currentLineAux == HexDump
+								.unsignedByte((byte) 0x90)
+								|| (currentLineAux == hGetter.currentLine + 1) || hGetter.currentLine < 1
+								&& currentLineAux == 1)) {
+							log.debug("Error");
+							hGetter.commandList = Arrays.copyOf(
+									hGetter.commandList,
+									hGetter.commandList.length + 1);
+							hGetter.commandList[hGetter.commandList.length - 1] = MedtronicConstants.MEDTRONIC_READ_PAGE_COMMAND;
 							hGetter.wThread.isRequest = true;
 							hGetter.firstReadPage = false;
 							hGetter.withoutConfirmation = 0;
 							hGetter.isWaitingNextLine = true;
 							hGetter.currentLine = -1;
-							synchronized (waitingCommand) {
+							synchronized (waitingCommandLock) {
 								waitingCommand = false;
 								lastCommandSend = null;
-							} 
+							}
 							hGetter.historicPage.clear();
-							return "Error currentLine is "+hGetter.currentLine+" next line is "+currentLineAux+" is not the order expected";
+							return "Error currentLine is "
+							+ hGetter.currentLine + " next line is "
+							+ currentLineAux
+							+ " is not the order expected";
 						}
 						hGetter.currentLine = currentLineAux;
 						byte[] modelArray = Arrays.copyOfRange(readData,
-								commandByte + 2,
-								(commandByte + 2 + (4*16)));
+								commandByte + 2, (commandByte + 2 + (4 * 16)));
 						hGetter.historicPage.add(modelArray);
-						if (hGetter.currentLine !=  HexDump.unsignedByte((byte)0x90)){
-							log.info("is correct line");
-							hGetter.commandList = Arrays.copyOf(hGetter.commandList, hGetter.commandList.length+1);
-							hGetter.commandList[hGetter.commandList.length-1] = MedtronicConstants.MEDTRONIC_ACK;
+						if (hGetter.currentLine != HexDump
+								.unsignedByte((byte) 0x90)) {
+							log.debug("is correct line");
+							hGetter.commandList = Arrays.copyOf(
+									hGetter.commandList,
+									hGetter.commandList.length + 1);
+							hGetter.commandList[hGetter.commandList.length - 1] = MedtronicConstants.MEDTRONIC_ACK;
 							hGetter.withoutConfirmation = 0;
 							hGetter.wThread.isRequest = true;
 							hGetter.wThread.postCommandBytes = null;
-							//String sModel = new String(HexDump.toHexString(modelArray));
-							sResult = "Pump last historic page ("+hGetter.currentLine+")......: Ok.";//+ sModel;	
+							// String sModel = new
+							// String(HexDump.toHexString(modelArray));
+							sResult = "Pump last historic page ("
+									+ hGetter.currentLine + ")......: Ok.";// +
+							// sModel;
 							hGetter.isWaitingNextLine = true;
-						}else{
-							log.info("All lines read.");
+						} else {
+							log.debug("All lines read.");
 							processHistoricPage();
-						} 
+						}
 					}
-				}finally{
-					synchronized (waitingCommand) {
+				} finally {
+					synchronized (waitingCommandLock) {
 						waitingCommand = false;
 						lastCommandSend = null;
 					}
 				}
 			}
-			
-			log.info(sResult);
+
+			log.debug(sResult);
 			return sResult;
 		}
 		case MedtronicConstants.MEDTRONIC_GET_PUMP_MODEL:
-			log.info("Pump Model Received");
+			log.debug("Pump Model Received");
 			sendMessageToUI("Pump Model Received...", false);
 			if (lastMedtronicPumpRecord == null) {
 				lastMedtronicPumpRecord = new MedtronicPumpRecord();
 				calculateDate(lastMedtronicPumpRecord, new Date(), 0);
-				lastMedtronicPumpRecord.deviceId = prefs.getString("medtronic_cgm_id", "");
+				lastMedtronicPumpRecord.deviceId = prefs.getString(
+						"medtronic_cgm_id", "");
 			}
 			if (lastCommandSend != null) {
-				synchronized (waitingCommand) {
+				synchronized (waitingCommandLock) {
 					waitingCommand = false;
 					lastCommandSend = null;
 				}
@@ -1047,14 +1139,15 @@ public String processPumpDataMessage(byte[] readData,
 			}
 			return sResult;
 		case MedtronicConstants.MEDTRONIC_GET_ALARM_MODE:
-			log.info("Pump Alarm Mode Received");
+			log.debug("Pump Alarm Mode Received");
 			if (lastMedtronicPumpRecord == null) {
 				lastMedtronicPumpRecord = new MedtronicPumpRecord();
 				calculateDate(lastMedtronicPumpRecord, new Date(), 0);
-				lastMedtronicPumpRecord.deviceId = prefs.getString("medtronic_cgm_id", "");
+				lastMedtronicPumpRecord.deviceId = prefs.getString(
+						"medtronic_cgm_id", "");
 			}
 			if (lastCommandSend != null) {
-				synchronized (waitingCommand) {
+				synchronized (waitingCommandLock) {
 					waitingCommand = false;
 					lastCommandSend = null;
 				}
@@ -1067,15 +1160,16 @@ public String processPumpDataMessage(byte[] readData,
 			}
 			return sResult;
 		case MedtronicConstants.MEDTRONIC_GET_PUMP_STATE:
-			log.info("Pump Status Received");
+			log.debug("Pump Status Received");
 			sendMessageToUI("Pump Status Received...", false);
 			if (lastMedtronicPumpRecord == null) {
 				lastMedtronicPumpRecord = new MedtronicPumpRecord();
 				calculateDate(lastMedtronicPumpRecord, new Date(), 0);
-				lastMedtronicPumpRecord.deviceId = prefs.getString("medtronic_cgm_id", "");
+				lastMedtronicPumpRecord.deviceId = prefs.getString(
+						"medtronic_cgm_id", "");
 			}
 			if (lastCommandSend != null) {
-				synchronized (waitingCommand) {
+				synchronized (waitingCommandLock) {
 					waitingCommand = false;
 					lastCommandSend = null;
 				}
@@ -1087,14 +1181,15 @@ public String processPumpDataMessage(byte[] readData,
 
 			return sResult;
 		case MedtronicConstants.MEDTRONIC_GET_TEMPORARY_BASAL:
-			log.info("Pump Temporary Basal Received");
+			log.debug("Pump Temporary Basal Received");
 			if (lastMedtronicPumpRecord == null) {
 				lastMedtronicPumpRecord = new MedtronicPumpRecord();
 				calculateDate(lastMedtronicPumpRecord, new Date(), 0);
-				lastMedtronicPumpRecord.deviceId = prefs.getString("medtronic_cgm_id", "");
+				lastMedtronicPumpRecord.deviceId = prefs.getString(
+						"medtronic_cgm_id", "");
 			}
 			if (lastCommandSend != null) {
-				synchronized (waitingCommand) {
+				synchronized (waitingCommandLock) {
 					waitingCommand = false;
 					lastCommandSend = null;
 				}
@@ -1108,15 +1203,16 @@ public String processPumpDataMessage(byte[] readData,
 			}
 			return sResult;
 		case MedtronicConstants.MEDTRONIC_GET_BATTERY_STATUS:
-			log.info("Pump Battery Status Received");
+			log.debug("Pump Battery Status Received");
 			sendMessageToUI("Pump Battery Status Received...", false);
 			if (lastMedtronicPumpRecord == null) {
 				lastMedtronicPumpRecord = new MedtronicPumpRecord();
 				calculateDate(lastMedtronicPumpRecord, new Date(), 0);
-				lastMedtronicPumpRecord.deviceId = prefs.getString("medtronic_cgm_id", "");
+				lastMedtronicPumpRecord.deviceId = prefs.getString(
+						"medtronic_cgm_id", "");
 			}
 			if (lastCommandSend != null) {
-				synchronized (waitingCommand) {
+				synchronized (waitingCommandLock) {
 					waitingCommand = false;
 					lastCommandSend = null;
 				}
@@ -1137,15 +1233,16 @@ public String processPumpDataMessage(byte[] readData,
 			}
 			return sResult;
 		case MedtronicConstants.MEDTRONIC_GET_REMAINING_INSULIN:
-			log.info("Pump Remaining Insulin Received");
+			log.debug("Pump Remaining Insulin Received");
 			sendMessageToUI("Pump Remaining Insulin Received...", false);
 			if (lastMedtronicPumpRecord == null) {
 				lastMedtronicPumpRecord = new MedtronicPumpRecord();
 				calculateDate(lastMedtronicPumpRecord, new Date(), 0);
-				lastMedtronicPumpRecord.deviceId = prefs.getString("medtronic_cgm_id", "");
+				lastMedtronicPumpRecord.deviceId = prefs.getString(
+						"medtronic_cgm_id", "");
 			}
 			if (lastCommandSend != null) {
-				synchronized (waitingCommand) {
+				synchronized (waitingCommandLock) {
 					waitingCommand = false;
 					lastCommandSend = null;
 				}
@@ -1157,10 +1254,10 @@ public String processPumpDataMessage(byte[] readData,
 			}
 			return sResult;
 		case MedtronicConstants.MEDTRONIC_GET_REMOTE_CONTROL_IDS:
-			log.info("Pump Remote Control Ids Received");
+			log.debug("Pump Remote Control Ids Received");
 			sendMessageToUI("Pump Remote Control Ids Received...", false);
 			if (lastCommandSend != null) {
-				synchronized (waitingCommand) {
+				synchronized (waitingCommandLock) {
 					waitingCommand = false;
 					lastCommandSend = null;
 				}
@@ -1195,10 +1292,10 @@ public String processPumpDataMessage(byte[] readData,
 			}
 			return sResult;
 		case MedtronicConstants.MEDTRONIC_GET_PARADIGM_LINK_IDS:
-			log.info("Pump Paradigm Link Ids Received");
+			log.debug("Pump Paradigm Link Ids Received");
 			sendMessageToUI("Pump Paradigm Link Ids Received...", false);
 			if (lastCommandSend != null) {
-				synchronized (waitingCommand) {
+				synchronized (waitingCommandLock) {
 					waitingCommand = false;
 					lastCommandSend = null;
 				}
@@ -1232,14 +1329,15 @@ public String processPumpDataMessage(byte[] readData,
 			}
 			return sResult;
 		case MedtronicConstants.MEDTRONIC_GET_SENSORID:
-			log.info("Pump Sensor Id Received");
+			log.debug("Pump Sensor Id Received");
 			sendMessageToUI("Pump Sensor Id Received...", false);
 			if (lastCommandSend != null) {
-				synchronized (waitingCommand) {
+				synchronized (waitingCommandLock) {
 					waitingCommand = false;
 					lastCommandSend = null;
 				}
-				if (readData.length >= HexDump.unsignedByte(readData[1]) && HexDump.unsignedByte(readData[1]) > 0) {
+				if (readData.length >= HexDump.unsignedByte(readData[1])
+						&& HexDump.unsignedByte(readData[1]) > 0) {
 					byte[] sensorId = Arrays.copyOfRange(readData,
 							commandByte + 58, commandByte + 61);
 					String sSensorId = HexDump.toHexString(sensorId);
@@ -1252,10 +1350,10 @@ public String processPumpDataMessage(byte[] readData,
 			}
 			return sResult;
 		case MedtronicConstants.MEDTRONIC_GET_CALIBRATION_FACTOR:
-			log.info("Pump Calibration Factor Received");
+			log.debug("Pump Calibration Factor Received");
 			sendMessageToUI("Pump Cal. Factor Received...", false);
 			if (lastCommandSend != null) {
-				synchronized (waitingCommand) {
+				synchronized (waitingCommandLock) {
 					waitingCommand = false;
 					lastCommandSend = null;
 				}
@@ -1265,7 +1363,7 @@ public String processPumpDataMessage(byte[] readData,
 				if (calibrationSelected == MedtronicConstants.CALIBRATION_SENSOR) {
 					if (factor > 0) {
 						calibrationStatus = MedtronicConstants.CALIBRATED;
-						calibrationFactor = factor/1126;
+						calibrationFactor = factor / 1126;
 					} else {
 						if (calibrationStatus != MedtronicConstants.WITHOUT_ANY_CALIBRATION) {
 							calibrationStatus = MedtronicConstants.LAST_CALIBRATION_FAILED_USING_PREVIOUS;
@@ -1280,18 +1378,19 @@ public String processPumpDataMessage(byte[] readData,
 						MedtronicSensorRecord auxRecord = new MedtronicSensorRecord();
 						auxRecord.calibrationStatus = calibrationStatus;
 						auxRecord.calibrationFactor = calibrationFactor;
-						log.info("5");
+						log.debug("5");
 						writeLocalCSV(auxRecord, context);
 					} else {
 						previousRecord.calibrationStatus = calibrationStatus;
 						previousRecord.calibrationFactor = calibrationFactor;
-						log.info("6");
+						log.debug("6");
 						writeLocalCSV(previousRecord, context);
 					}
 					if (lastMedtronicPumpRecord == null) {
 						lastMedtronicPumpRecord = new MedtronicPumpRecord();
 						calculateDate(lastMedtronicPumpRecord, new Date(), 0);
-						lastMedtronicPumpRecord.deviceId = prefs.getString("medtronic_cgm_id", "");
+						lastMedtronicPumpRecord.deviceId = prefs.getString(
+								"medtronic_cgm_id", "");
 					}
 					// sendMessageToUI("Is In RANGE CALIBRATION SUCCESS "+currentMeasure+
 					// " Factor "+calibrationFactor, false);
@@ -1301,12 +1400,12 @@ public String processPumpDataMessage(byte[] readData,
 			}
 			return sResult;
 		case MedtronicConstants.MEDTRONIC_ACK:
-			log.info("Pump Ack Received");
+			log.debug("Pump Ack Received");
 			if (lastCommandSend != null) {
-				synchronized (sendingCommand){
+				synchronized (sendingCommandLock) {
 					sendingCommand = false;
 				}
-				synchronized (waitingCommand) {
+				synchronized (waitingCommandLock) {
 					waitingCommand = false;
 					lastCommandSend = null;
 				}
@@ -1318,64 +1417,74 @@ public String processPumpDataMessage(byte[] readData,
 			+ HexDump.toHexString(readData[commandByte]);
 		}
 	}
+
 	/**
 	 * method to check the Medtronic log page received.
 	 */
-	private void processHistoricPage(){
+	private void processHistoricPage() {
 		ArrayList<Byte> page = new ArrayList<Byte>();
 		ArrayList<Byte> crcPage = new ArrayList<Byte>();
 		int substract = 3;
-		for (int i = 0; i < hGetter.historicPage.size() ; i++){
+		for (int i = 0; i < hGetter.historicPage.size(); i++) {
 			byte[] hPage = hGetter.historicPage.get(i);
-			for (int j = 0; j < hPage.length; j++){
+			for (int j = 0; j < hPage.length; j++) {
 				crcPage.add(hPage[j]);
 			}
 		}
-		byte crc2 = crcPage.get(crcPage.size()-1);//remove crc
-		crcPage.remove(crcPage.size()-1);//remove crc
-		byte crc1 = crcPage.get(crcPage.size()-1);//remove crc
-		crcPage.remove(crcPage.size()-1);//remove crc
-		//CALCULA EL CRC
-		byte[] crcReceived = {crc1, crc2};
+		byte crc2 = crcPage.get(crcPage.size() - 1);// remove crc
+		crcPage.remove(crcPage.size() - 1);// remove crc
+		byte crc1 = crcPage.get(crcPage.size() - 1);// remove crc
+		crcPage.remove(crcPage.size() - 1);// remove crc
+		// CALCULA EL CRC
+		byte[] crcReceived = { crc1, crc2 };
 		short sCrcReceived = HexDump.byteArrayToShort(crcReceived);
 		Byte[] finalCrcPage = crcPage.toArray(new Byte[crcPage.size()]);
-		//crc16Init();
+		// crc16Init();
 		short sCrcCalculated = (short) crc16(finalCrcPage);
-		if (sCrcCalculated != sCrcReceived){
-			log.info("Error page crc --> crcReceived "+sCrcReceived+" crcCalculated "+sCrcCalculated);
-			if (hGetter.timeout >= 2){
+		if (sCrcCalculated != sCrcReceived) {
+			log.debug("Error page crc --> crcReceived " + sCrcReceived
+					+ " crcCalculated " + sCrcCalculated);
+			if (hGetter.timeout >= 2) {
 				hGetter.timeout = 0;
-				log.info("too much retries");
-				sendMessageToUI("historic log read aborted! too much crc errors, waiting to retry", false);
+				log.debug("too much retries");
+				sendMessageToUI(
+						"historic log read aborted! too much crc errors, waiting to retry",
+						false);
 				return;
 			}
-			sendMessageToUI("Crc error in page read, reinitializing page read...", false);
+			sendMessageToUI(
+					"Crc error in page read, reinitializing page read...",
+					false);
 			hGetter.timeout++;
-			hGetter.commandList = Arrays.copyOf(hGetter.commandList, hGetter.commandList.length+1);
-			hGetter.commandList[hGetter.commandList.length-1] = MedtronicConstants.MEDTRONIC_READ_PAGE_COMMAND;
+			hGetter.commandList = Arrays.copyOf(hGetter.commandList,
+					hGetter.commandList.length + 1);
+			hGetter.commandList[hGetter.commandList.length - 1] = MedtronicConstants.MEDTRONIC_READ_PAGE_COMMAND;
 			hGetter.wThread.isRequest = true;
 			hGetter.firstReadPage = false;
 			hGetter.withoutConfirmation = 0;
-			/*byte[] lastHistoricPage = HexDump.toByteArray(historicPageIndex - historicPageShift);
-			hGetter.wThread.postCommandBytes = new byte[64];
-			Arrays.fill(hGetter.wThread.postCommandBytes, (byte)0x00);
-			hGetter.wThread.postCommandBytes[0] = 0x04;
-			hGetter.wThread.postCommandBytes[1] = lastHistoricPage[0];
-			hGetter.wThread.postCommandBytes[2] = lastHistoricPage[1];
-			hGetter.wThread.postCommandBytes[3] = lastHistoricPage[2];
-			hGetter.wThread.postCommandBytes[4] = lastHistoricPage[3];*/
+			/*
+			 * byte[] lastHistoricPage = HexDump.toByteArray(historicPageIndex -
+			 * historicPageShift); hGetter.wThread.postCommandBytes = new
+			 * byte[64]; Arrays.fill(hGetter.wThread.postCommandBytes,
+			 * (byte)0x00); hGetter.wThread.postCommandBytes[0] = 0x04;
+			 * hGetter.wThread.postCommandBytes[1] = lastHistoricPage[0];
+			 * hGetter.wThread.postCommandBytes[2] = lastHistoricPage[1];
+			 * hGetter.wThread.postCommandBytes[3] = lastHistoricPage[2];
+			 * hGetter.wThread.postCommandBytes[4] = lastHistoricPage[3];
+			 */
 			hGetter.isWaitingNextLine = true;
 			hGetter.currentLine = -1;
 			hGetter.historicPage.clear();
 			return;
 		}
-		log.info("Success!! page crc --> crcReceived "+sCrcReceived+" crcCalculated "+sCrcCalculated);
-		//invertpage and remove 0
+		log.debug("Success!! page crc --> crcReceived " + sCrcReceived
+				+ " crcCalculated " + sCrcCalculated);
+		// invertpage and remove 0
 		StringBuffer buf = new StringBuffer();
-		for (int i = hGetter.historicPage.size()-1; i >= 0 ; i--){
+		for (int i = hGetter.historicPage.size() - 1; i >= 0; i--) {
 			byte[] hPage = hGetter.historicPage.get(i);
-			for (int j = hPage.length -substract; j >= 0; j--){
-				if (hPage[j] == (byte)0x00 && (substract == 3)){
+			for (int j = hPage.length - substract; j >= 0; j--) {
+				if (hPage[j] == (byte) 0x00 && (substract == 3)) {
 					continue;
 				}
 				substract = 1;
@@ -1385,154 +1494,175 @@ private void processHistoricPage(){
 			buf.append("\n");
 		}
 		Byte[] invertedPage = page.toArray(new Byte[page.size()]);
-		//log.info("InvertedPage   \n"+buf.toString());
+		// log.debug("InvertedPage   \n"+buf.toString());
 		readHistoricPage(invertedPage);
 	}
 
 	/**
 	 * Read and translate the Medtronic log page received.
+	 * 
 	 * @param invertedPage
 	 */
-	private void readHistoricPage(Byte[] invertedPage){
+	private void readHistoricPage(Byte[] invertedPage) {
 		boolean glucoseDataRead = false;
 		boolean sensorTimeStampRead = false;
 		int glucoseVal = 0;
 		StringBuffer sb = null;
-		for (int i=0; i<invertedPage.length; i++) {
+		for (int i = 0; i < invertedPage.length; i++) {
 			sb = new StringBuffer();
 			byte opCommand = HexDump.bUnsignedByte(invertedPage[i]);
 			if ((opCommand > 0) && (opCommand < 20)) {
 				// Other data
 				switch (opCommand) {
-				case 0x0001: 
-					log.info("    - Data End");
-					i +=  0; 
+				case 0x0001:
+					log.debug("    - Data End");
+					i += 0;
 					break;
-				case 0x0002: 
-					log.info("    - Sensor Weak Signal");
-					i +=  0; 
+				case 0x0002:
+					log.debug("    - Sensor Weak Signal");
+					i += 0;
 					break;
-				case 0x0003: 
+				case 0x0003:
 					sb.append("    - Sensor Calibration : ");
 					datalog.numEntries++;
-					if ((invertedPage[i+1]&0x00FF) == 0x00) {
+					if ((invertedPage[i + 1] & 0x00FF) == 0x00) {
 						sb.append(" Not Calibrated");
 						datalog.entryType[datalog.numEntries] = 0x03;
 					} else {
 						sb.append(" Calibrating");
 						datalog.entryType[datalog.numEntries] = 0x04;
 					}
-					log.info(sb.toString());
-					i +=  1; 
+					log.debug(sb.toString());
+					i += 1;
 					break;
-				case 0x0008: 
-					int year = 2000 + (invertedPage[i+4] & 0x00FF);
-					int day = (invertedPage[i+3] & 0x001F);
-					int minute = (invertedPage[i+2] & 0x003F);
-					int hour = (invertedPage[i+1] & 0x001F);
-					int month = (((invertedPage[i+1] >> 6)&0x0003)<<2) + ((invertedPage[i+2] >> 6)&0x0003) ;
-					log.info("    - Sensor Timestamp: "+day+"-"+month+"-"+year+" "+hour+":"+minute);
-					if (glucoseDataRead) sensorTimeStampRead = true;
-					i +=  4;
+				case 0x0008:
+					int year = 2000 + (invertedPage[i + 4] & 0x00FF);
+					int day = (invertedPage[i + 3] & 0x001F);
+					int minute = (invertedPage[i + 2] & 0x003F);
+					int hour = (invertedPage[i + 1] & 0x001F);
+					int month = (((invertedPage[i + 1] >> 6) & 0x0003) << 2)
+							+ ((invertedPage[i + 2] >> 6) & 0x0003);
+					log.debug("    - Sensor Timestamp: " + day + "-" + month
+							+ "-" + year + " " + hour + ":" + minute);
+					if (glucoseDataRead)
+						sensorTimeStampRead = true;
+					i += 4;
 
 					datalog.numEntries++;
-					datalog.entryType[datalog.numEntries]         = 0x08  ;
+					datalog.entryType[datalog.numEntries] = 0x08;
 					Calendar cal = Calendar.getInstance();
 					cal.set(year, month, day, hour, minute);
 					datalog.dateField[datalog.numEntries] = cal.getTime();
 					break;
-				case 0x000B: 
+				case 0x000B:
 					sb.append("    - Sensor Status : ");
-					year = 2000 + (invertedPage[i+4] & 0x000F);
-					day = (invertedPage[i+3] & 0x001F);
-					minute = (invertedPage[i+2] & 0x003F);
-					hour = (invertedPage[i+1] & 0x001F);
-					month = (((invertedPage[i+1] >> 6)&0x0003)<<2) + ((invertedPage[i+2] >> 6)&0x0003) ;
-					sb.append(day+"-"+month+"-"+year+" "+hour+":"+minute);
-					log.info(sb.toString());
-					i +=  4; 
+					year = 2000 + (invertedPage[i + 4] & 0x000F);
+					day = (invertedPage[i + 3] & 0x001F);
+					minute = (invertedPage[i + 2] & 0x003F);
+					hour = (invertedPage[i + 1] & 0x001F);
+					month = (((invertedPage[i + 1] >> 6) & 0x0003) << 2)
+							+ ((invertedPage[i + 2] >> 6) & 0x0003);
+					sb.append(day + "-" + month + "-" + year + " " + hour + ":"
+							+ minute);
+					log.debug(sb.toString());
+					i += 4;
 					break;
-				case 0x000C: 
+				case 0x000C:
 					sb.append("    - Date Time Change : ");
-					for (int j=14;j>0;j--) sb.append(HexDump.toHexString(invertedPage[i+j]&0x00FF));
-					log.info(sb.toString());
-					i += 14; 
+					for (int j = 14; j > 0; j--)
+						sb.append(HexDump
+								.toHexString(invertedPage[i + j] & 0x00FF));
+					log.debug(sb.toString());
+					i += 14;
 					break;
-				case 0x000D: 
+				case 0x000D:
 					sb.append("    - Sensor Sync : ");
-					year = 2000 + (invertedPage[i+4] & 0x000F);
-					day = (invertedPage[i+3] & 0x001F);
-					minute = (invertedPage[i+2] & 0x003F);
-					hour = (invertedPage[i+1] & 0x001F);
-					month = (((invertedPage[i+1] >> 6)&0x0003)<<2) + ((invertedPage[i+2] >> 6)&0x0003) ;
-					sb.append(day+"-"+month+"-"+year+" "+hour+":"+minute);
-					log.info(sb.toString());
-					i +=  4; 
+					year = 2000 + (invertedPage[i + 4] & 0x000F);
+					day = (invertedPage[i + 3] & 0x001F);
+					minute = (invertedPage[i + 2] & 0x003F);
+					hour = (invertedPage[i + 1] & 0x001F);
+					month = (((invertedPage[i + 1] >> 6) & 0x0003) << 2)
+							+ ((invertedPage[i + 2] >> 6) & 0x0003);
+					sb.append(day + "-" + month + "-" + year + " " + hour + ":"
+							+ minute);
+					log.debug(sb.toString());
+					i += 4;
 					break;
-				case 0x000E: 
-					glucoseVal = HexDump.unsignedByte(invertedPage[i+5]);
-					year = 2000 + (invertedPage[i+4] & 0x000F);
-					day = (invertedPage[i+3] & 0x001F);
-					minute = (invertedPage[i+2] & 0x003F);
-					hour = (invertedPage[i+1] & 0x001F);
-					month = (((invertedPage[i+1] >> 6)&0x0003)<<2) + ((invertedPage[i+2] >> 6)&0x0003) ;
-					sb.append("    - Calibration BG:  "+glucoseVal+" mg/dl - ");
-					sb.append(day+"-"+month+"-"+year+" "+hour+":"+minute);
-					log.info(sb.toString());
-					i +=  5; 
+				case 0x000E:
+					glucoseVal = HexDump.unsignedByte(invertedPage[i + 5]);
+					year = 2000 + (invertedPage[i + 4] & 0x000F);
+					day = (invertedPage[i + 3] & 0x001F);
+					minute = (invertedPage[i + 2] & 0x003F);
+					hour = (invertedPage[i + 1] & 0x001F);
+					month = (((invertedPage[i + 1] >> 6) & 0x0003) << 2)
+							+ ((invertedPage[i + 2] >> 6) & 0x0003);
+					sb.append("    - Calibration BG:  " + glucoseVal
+							+ " mg/dl - ");
+					sb.append(day + "-" + month + "-" + year + " " + hour + ":"
+							+ minute);
+					log.debug(sb.toString());
+					i += 5;
 					break;
-				case 0x000F: 
+				case 0x000F:
 					sb.append("    - Sensor Calibration Factor : ");
 					byte[] value = new byte[2];
 					value[0] = 0x00;
 					value[1] = 0x00;
 					int index = 1;
-					for (int j=6;j>4;j--){
-						value[index] = invertedPage[i+j];
+					for (int j = 6; j > 4; j--) {
+						value[index] = invertedPage[i + j];
 						index--;
 					}
-					sb.append(""+HexDump.byteArrayToShort(value));
-					year = 2000 + (invertedPage[i+4] & 0x000F);
-					day = (invertedPage[i+3] & 0x001F);
-					minute = (invertedPage[i+2] & 0x003F);
-					hour = (invertedPage[i+1] & 0x001F);
-					month = (((invertedPage[i+1] >> 6)&0x0003)<<2) + ((invertedPage[i+2] >> 6)&0x0003) ;
-					sb.append("\n"+day+"-"+month+"-"+year+" "+hour+":"+minute);
+					sb.append("" + HexDump.byteArrayToShort(value));
+					year = 2000 + (invertedPage[i + 4] & 0x000F);
+					day = (invertedPage[i + 3] & 0x001F);
+					minute = (invertedPage[i + 2] & 0x003F);
+					hour = (invertedPage[i + 1] & 0x001F);
+					month = (((invertedPage[i + 1] >> 6) & 0x0003) << 2)
+							+ ((invertedPage[i + 2] >> 6) & 0x0003);
+					sb.append("\n" + day + "-" + month + "-" + year + " "
+							+ hour + ":" + minute);
 					datalog.numEntries++;
-					datalog.entryType[datalog.numEntries]         = 0x0F  ;
+					datalog.entryType[datalog.numEntries] = 0x0F;
 					cal = Calendar.getInstance();
 					cal.set(year, month, day, hour, minute);
 					datalog.dateField[datalog.numEntries] = cal.getTime();
-					datalog.calFactor[datalog.numEntries] = HexDump.byteArrayToShort(value);
-					log.info(sb.toString());
-					i +=  6; 
+					datalog.calFactor[datalog.numEntries] = HexDump
+							.byteArrayToShort(value);
+					log.debug(sb.toString());
+					i += 6;
 					break;
-				case 0x0010: 
+				case 0x0010:
 					sb.append("    - Bolus : ");
-					//for (j=7;j>4;j--) log.info("%.2X",(invertedPage[i+j]&0x00FF));
-					year = 2000 + (invertedPage[i+4] & 0x00FF);
-					day = (invertedPage[i+3] & 0x001F);
-					minute = (invertedPage[i+2] & 0x003F);
-					hour = (invertedPage[i+1] & 0x001F);
-					month = (((invertedPage[i+1] >> 6)&0x0003)<<2) + ((invertedPage[i+2] >> 6)&0x0003) ;
-					sb.append(day+"-"+month+"-"+year+" "+hour+":"+minute);
-					log.info(sb.toString());
-					i +=  7; 
+					// for (j=7;j>4;j--)
+					// log.debug("%.2X",(invertedPage[i+j]&0x00FF));
+					year = 2000 + (invertedPage[i + 4] & 0x00FF);
+					day = (invertedPage[i + 3] & 0x001F);
+					minute = (invertedPage[i + 2] & 0x003F);
+					hour = (invertedPage[i + 1] & 0x001F);
+					month = (((invertedPage[i + 1] >> 6) & 0x0003) << 2)
+							+ ((invertedPage[i + 2] >> 6) & 0x0003);
+					sb.append(day + "-" + month + "-" + year + " " + hour + ":"
+							+ minute);
+					log.debug(sb.toString());
+					i += 7;
 					break;
-				case 0x0013: 
-					log.info("    - Basal Profile Start\n");
-					i +=  0; 
+				case 0x0013:
+					log.debug("    - Basal Profile Start\n");
+					i += 0;
 					break;
-				default:   
-					log.info("    - Unknown ("+HexDump.toHexString(opCommand)+")");
-					i +=  0; 
+				default:
+					log.debug("    - Unknown (" + HexDump.toHexString(opCommand)
+							+ ")");
+					i += 0;
 					break;
 				}
 			} else {
 				// Glucose data
-				
+
 				glucoseVal = (HexDump.unsignedByte(invertedPage[i])) * 2;
-				log.info("    - Glucose:"+glucoseVal+" mg/dl ("+HexDump.toHexString(invertedPage[i])+")");
+				log.debug("    - Glucose:" + glucoseVal + " mg/dl ("
+						+ HexDump.toHexString(invertedPage[i]) + ")");
 				glucoseDataRead = true;
 				datalog.numEntries++;
 				datalog.entryType[datalog.numEntries] = 0x00;
@@ -1542,125 +1672,137 @@ private void readHistoricPage(Byte[] invertedPage){
 		historicPageShift++;
 		hGetter.shift = historicPageShift;
 		Date d = new Date();
-		
+
 		long lastRecordTime = 0;
-		if (previousRecord != null){
-			
+		if (previousRecord != null) {
+
 			lastRecordTime = previousRecord.displayDateTime;
-		}
-		else if (settings.contains("lastSensorValueDate")){
+		} else if (settings.contains("lastSensorValueDate")) {
 			lastRecordTime = settings.getLong("lastSensorValueDate", 0);
 		}
-	
-		log.info("EVAL sensorTimeStampRead "+sensorTimeStampRead +" timeSinceLastRecord "+ lastRecordTime+" historicshift "+ historicPageShift);
-		if ((sensorTimeStampRead && lastRecordTime > 0) || historicPageShift > 1){
-			  log.info("shift: "+historicPageShift);
-			  int i;
-			  long actualTime = 0;
-
-			  // First drop everything before the first timestamp
-			  for (i=datalog.numEntries;i>0 && datalog.entryType[i] != 0x08;i--);
-			  datalog.numEntries = i;
-			  log.info("\n * Number of traceable entries: "+datalog.numEntries);
-			  MedtronicSensorRecord record = null;	
-			  // Fill missing timestamps
-			  boolean otherPage = false;
-			  boolean first = true;
-			 
-			  for (i=datalog.numEntries;i>0;i--) {
-			    switch (datalog.entryType[i]) {
-			    case 0x00:
-			    case 0x03:
-			    case 0x04:{
-			      actualTime += 5*60000;
-			      datalog.dateField[i] = new Date(actualTime);
-			      //Check times to kow if This record must be uploaded.
-			      if (lastRecordTime == 0 || ((actualTime > lastRecordTime) && (actualTime - lastRecordTime > 150000))){
-			    	log.info("OK! Upload this record");
-			    	
-			    	if (first && historicPageShift <= 1){
-			    		otherPage = true;
-			    	}
-			    	
-			    	record = new MedtronicSensorRecord();			  		
-					record.setBGValue(datalog.glucose[i]+"");
-					calculateDate(record, datalog.dateField[i], 0);
-					record.isCalibrating = false;
-					record.calibrationStatus = MedtronicConstants.CALIBRATED;
-			  		lastRecordsInMemory.add(record);
-			  		calculateTrendAndArrow(record, lastRecordsInMemory);
-			      }else{
-			    	  log.info("KO!, this record must not be uploaded");
-			    	  first = false;
-			      }
-			      break;
-			    }
-			    case 0x08:
-			      actualTime = datalog.dateField[i].getTime();
-			      break;
-			    default:
-			      break;
-			    }
-			  }
-		   
+
+		log.debug("EVAL sensorTimeStampRead " + sensorTimeStampRead
+				+ " timeSinceLastRecord " + lastRecordTime + " historicshift "
+				+ historicPageShift);
+		if ((sensorTimeStampRead && lastRecordTime > 0)
+				|| historicPageShift > 1) {
+			log.debug("shift: " + historicPageShift);
+			int i;
+			long actualTime = 0;
+
+			// First drop everything before the first timestamp
+			for (i = datalog.numEntries; i > 0 && datalog.entryType[i] != 0x08; i--)
+				;
+			datalog.numEntries = i;
+			log.debug("\n * Number of traceable entries: " + datalog.numEntries);
+			MedtronicSensorRecord record = null;
+			// Fill missing timestamps
+			boolean otherPage = false;
+			boolean first = true;
+
+			for (i = datalog.numEntries; i > 0; i--) {
+				switch (datalog.entryType[i]) {
+				case 0x00:
+				case 0x03:
+				case 0x04: {
+					actualTime += 5 * 60000;
+					datalog.dateField[i] = new Date(actualTime);
+					// Check times to kow if This record must be uploaded.
+					if (lastRecordTime == 0
+							|| ((actualTime > lastRecordTime) && (actualTime
+									- lastRecordTime > 150000))) {
+						log.debug("OK! Upload this record");
+
+						if (first && historicPageShift <= 1) {
+							otherPage = true;
+						}
+
+						record = new MedtronicSensorRecord();
+						record.setBGValue(datalog.glucose[i] + "");
+						calculateDate(record, datalog.dateField[i], 0);
+						record.isCalibrating = false;
+						record.calibrationStatus = MedtronicConstants.CALIBRATED;
+						lastRecordsInMemory.add(record);
+						calculateTrendAndArrow(record, lastRecordsInMemory);
+					} else {
+						log.debug("KO!, this record must not be uploaded");
+						first = false;
+					}
+					break;
+				}
+				case 0x08:
+					actualTime = datalog.dateField[i].getTime();
+					break;
+				default:
+					break;
+				}
+			}
+
 			SharedPreferences.Editor editor = settings.edit();
-	  		editor.putFloat("previousValue", (float) previousValue);
-	  		editor.putInt("calibrationStatus", calibrationStatus);
-	  		lastSensorValueDate = d.getTime();
-	  		editor.putLong("lastSensorValueDate", lastSensorValueDate);
-	  		editor.commit();
-	  		if (record != null){
-				  previousRecord = record;
-				  log.info("7");
-				  writeLocalCSV(previousRecord, context);
-	  		}
-	  		if (otherPage){
-	  			sendMessageToUI("The next page must be read", false);
-	  			log.info("The next page must be read");
-				hGetter.commandList = Arrays.copyOf(hGetter.commandList, hGetter.commandList.length+2);
-				hGetter.commandList[hGetter.commandList.length-2] = MedtronicConstants.MEDTRONIC_ACK;
-				hGetter.commandList[hGetter.commandList.length-1] = MedtronicConstants.MEDTRONIC_READ_PAGE_COMMAND;
+			editor.putFloat("previousValue", (float) previousValue);
+			editor.putInt("calibrationStatus", calibrationStatus);
+			lastSensorValueDate = d.getTime();
+			editor.putLong("lastSensorValueDate", lastSensorValueDate);
+			editor.commit();
+			if (record != null) {
+				previousRecord = record;
+				log.debug("7");
+				writeLocalCSV(previousRecord, context);
+			}
+			if (otherPage) {
+				sendMessageToUI("The next page must be read", false);
+				log.debug("The next page must be read");
+				hGetter.commandList = Arrays.copyOf(hGetter.commandList,
+						hGetter.commandList.length + 2);
+				hGetter.commandList[hGetter.commandList.length - 2] = MedtronicConstants.MEDTRONIC_ACK;
+				hGetter.commandList[hGetter.commandList.length - 1] = MedtronicConstants.MEDTRONIC_READ_PAGE_COMMAND;
 				hGetter.wThread.isRequest = true;
 				hGetter.firstReadPage = true;
 				hGetter.withoutConfirmation = 1;
-				/*byte[] lastHistoricPage = HexDump.toByteArray(historicPageIndex - historicPageShift);
-				hGetter.wThread.postCommandBytes = new byte[64];
-				Arrays.fill(hGetter.wThread.postCommandBytes, (byte)0x00);
-				hGetter.wThread.postCommandBytes[0] = 0x04;
-				hGetter.wThread.postCommandBytes[1] = lastHistoricPage[0];
-				hGetter.wThread.postCommandBytes[2] = lastHistoricPage[1];
-				hGetter.wThread.postCommandBytes[3] = lastHistoricPage[2];
-				hGetter.wThread.postCommandBytes[4] = lastHistoricPage[3];*/
+				/*
+				 * byte[] lastHistoricPage =
+				 * HexDump.toByteArray(historicPageIndex - historicPageShift);
+				 * hGetter.wThread.postCommandBytes = new byte[64];
+				 * Arrays.fill(hGetter.wThread.postCommandBytes, (byte)0x00);
+				 * hGetter.wThread.postCommandBytes[0] = 0x04;
+				 * hGetter.wThread.postCommandBytes[1] = lastHistoricPage[0];
+				 * hGetter.wThread.postCommandBytes[2] = lastHistoricPage[1];
+				 * hGetter.wThread.postCommandBytes[3] = lastHistoricPage[2];
+				 * hGetter.wThread.postCommandBytes[4] = lastHistoricPage[3];
+				 */
 				hGetter.isWaitingNextLine = true;
 				hGetter.currentLine = -1;
 				hGetter.historicPage.clear();
 				return;
-	  		}
-	  		hGetter.commandList = Arrays.copyOf(hGetter.commandList, hGetter.commandList.length+2);
-			hGetter.commandList[hGetter.commandList.length-2] = MedtronicConstants.MEDTRONIC_ACK;
-			hGetter.commandList[hGetter.commandList.length-1] = MedtronicConstants.MEDTRONIC_INIT;
+			}
+			hGetter.commandList = Arrays.copyOf(hGetter.commandList,
+					hGetter.commandList.length + 2);
+			hGetter.commandList[hGetter.commandList.length - 2] = MedtronicConstants.MEDTRONIC_ACK;
+			hGetter.commandList[hGetter.commandList.length - 1] = MedtronicConstants.MEDTRONIC_INIT;
 			hGetter.withoutConfirmation = 1;
 			hGetter.wThread.isRequest = true;
 			hGetter.wThread.postCommandBytes = null;
-			
-		    // clear vars and EXIT!!!
-	  		sendMessageToUI("historic log has been read", false);
-	  		//hGetter.init();
-	  		historicPageIndex = -1;
-	  		historicPageShift = 0;
-	  		datalog = new DataLog();
-	  		SharedPreferences.Editor editor2 = prefs.edit();
+
+			// clear vars and EXIT!!!
+			sendMessageToUI("historic log has been read", false);
+			// hGetter.init();
+			historicPageIndex = -1;
+			historicPageShift = 0;
+			datalog = new DataLog();
+			SharedPreferences.Editor editor2 = prefs.edit();
 			editor2.putLong("lastHistoricRead", System.currentTimeMillis());
 			editor2.commit();
-	  		if (mHandlerCheckLastRead != null && checkLastRead != null)
-	  			mHandlerCheckLastRead.postDelayed(checkLastRead, MedtronicConstants.TIME_10_MIN_IN_MS);
-	  		
+			if (mHandlerCheckLastRead != null && checkLastRead != null)
+				mHandlerCheckLastRead.postDelayed(checkLastRead,
+						MedtronicConstants.TIME_10_MIN_IN_MS);
+
 		} else {
 			sendMessageToUI("The next page must be read", false);
-			log.info("The next page must be read");
-			hGetter.commandList = Arrays.copyOf(hGetter.commandList, hGetter.commandList.length+2);
-			hGetter.commandList[hGetter.commandList.length-2] = MedtronicConstants.MEDTRONIC_ACK;
-			hGetter.commandList[hGetter.commandList.length-1] = MedtronicConstants.MEDTRONIC_READ_PAGE_COMMAND;
+			log.debug("The next page must be read");
+			hGetter.commandList = Arrays.copyOf(hGetter.commandList,
+					hGetter.commandList.length + 2);
+			hGetter.commandList[hGetter.commandList.length - 2] = MedtronicConstants.MEDTRONIC_ACK;
+			hGetter.commandList[hGetter.commandList.length - 1] = MedtronicConstants.MEDTRONIC_READ_PAGE_COMMAND;
 			hGetter.wThread.isRequest = true;
 			hGetter.firstReadPage = true;
 			hGetter.withoutConfirmation = 1;
@@ -1669,13 +1811,15 @@ record = new MedtronicSensorRecord();
 			hGetter.historicPage.clear();
 		}
 	}
+
 	/**
 	 * This method process the glucometer messages
 	 * 
 	 * @param readData
 	 * @return String, for debug or notification purposes
 	 */
-	public String processGlucometerDataMessage(byte[] readData, boolean calibrate) {
+	public String processGlucometerDataMessage(byte[] readData,
+			boolean calibrate) {
 		int firstMeasureByte = firstByteAfterDeviceId(readData);
 		if (firstMeasureByte < 0)
 			return "Error, I can not identify the initial byte of the glucometer measure";
@@ -1699,53 +1843,60 @@ public String processGlucometerDataMessage(byte[] readData, boolean calibrate) {
 		int num = wrapped.getInt(); // 1
 		if (num < 0 || num > 1535)
 			return "Glucometer value under 0 or over 0x5ff. Possible ACK or malfunction.";
-		lastGlucometerRecord = new GlucometerRecord();
-		lastGlucometerRecord.numGlucometerValue = num;
-		lastGlucometerValue = num;
-		Date d = new Date();
-		lastGlucometerRecord.lastDate = d.getTime();
-		lastGlucometerDate = d.getTime();
-		calculateDate(lastGlucometerRecord, d, 0);
-		if (calibrate){
-			if (HexDump.unsignedByte(expectedSensorSortNumber) == HexDump
-					.unsignedByte((byte) 0xff)) {
-				expectedSensorSortNumberForCalibration[0] = (byte) 0x00;
-				expectedSensorSortNumberForCalibration[1] = (byte) 0x71;
-			} else {
-				synchronized (expectedSensorSortNumberLock) {
-					byte expectedAux = expectedSensorSortNumber;
-					if (HexDump
-							.unsignedByte((byte) (expectedSensorSortNumber & (byte) 0x01)) > 0)
-						expectedAux = (byte) (expectedSensorSortNumber & (byte) 0xFE);
-					expectedSensorSortNumberForCalibration[0] = calculateNextSensorSortNameFrom(
-							6, expectedAux);
-					expectedSensorSortNumberForCalibration[1] = calculateNextSensorSortNameFrom(
-							10, expectedAux);
-				}
-			}
-			
+		
+		processManualCalibrationDataMessage(num, true, calibrate);
+		//int calibrationSelectedAux = 0;
+		//synchronized (calibrationSelectedLock) {
+			//calibrationSelectedAux = calibrationSelected;
+		//}
+		//sendGlucMessageToUI(num, calibrate, calibrationSelectedAux == MedtronicConstants.CALIBRATION_SENSOR);
+		return "Measure received " + num + " mg/dl";
+	}
+
+	
+	
+	public void approveGlucValueForCalibration(float num, boolean calibrate, boolean isSensorFactorFromPump){
+		if (!isSensorFactorFromPump)
+			processManualCalibrationDataMessage(num, false, calibrate);
+		else{
+			sendMessageToUI(
+					"Glucometer Detected!!..Waiting 15 min. to retrieve calibration factor...",
+					false);
+			log.debug("Glucometer Detected!!..Waiting 15 min. to retrieve calibration factor...");
+			if (mHandlerSensorCalibration != null
+					&& getCalibrationFromSensor != null) {
+				mHandlerSensorCalibration
+				.removeCallbacks(getCalibrationFromSensor);
+				mHandlerSensorCalibration
+				.postDelayed(
+						getCalibrationFromSensor,
+						MedtronicConstants.TIME_15_MIN_IN_MS + 120000);
+			} else
+				log.debug("glucometer handler or glucometer runnable is null");
+			lastGlucometerRecord = new GlucometerRecord();
+			lastGlucometerRecord.numGlucometerValue = num;
+			lastGlucometerValue = num;
+			Date d = new Date();
+			lastGlucometerRecord.lastDate = d.getTime();
+			lastGlucometerDate = d.getTime();
+			calculateDate(lastGlucometerRecord, d, 0);
 			SharedPreferences.Editor editor = settings.edit();
-			editor.putFloat("lastGlucometerValue", (float) num);
+			editor.putFloat("lastGlucometerValue", (float) lastGlucometerValue);
 			editor.putLong("glucometerLastDate", d.getTime());
-			editor.putString("expectedSensorSortNumberForCalibration0",
-					HexDump.toHexString(expectedSensorSortNumberForCalibration[0]));
-			editor.putString("expectedSensorSortNumberForCalibration1",
-					HexDump.toHexString(expectedSensorSortNumberForCalibration[1]));
 			editor.commit();
 		}
-		return "Measure received " + num + " mg/dl";
 	}
-
 	/**
 	 * This method process the Manual Calibration message
 	 * 
 	 * @param readData
 	 * @return String, for debug or notification purposes
 	 */
-	public String processManualCalibrationDataMessage(float value, boolean instant) {
+	public String processManualCalibrationDataMessage(float value,
+			boolean instant, boolean doCalibration) {
 		float mult = 1f;
-		if (prefs.getBoolean("mmolxl", false))
-			mult = 18f;
+		//if (prefs.getBoolean("mmolxl", false))
+			//mult = 1f/18f;
 		float num = value * mult;
 		lastGlucometerRecord = new GlucometerRecord();
 		lastGlucometerRecord.numGlucometerValue = num;
@@ -1754,7 +1905,7 @@ public String processManualCalibrationDataMessage(float value, boolean instant)
 		lastGlucometerRecord.lastDate = d.getTime();
 		lastGlucometerDate = d.getTime();
 		calculateDate(lastGlucometerRecord, d, 0);
-		if (!instant){
+		if (!instant && doCalibration) {
 			if (HexDump.unsignedByte(expectedSensorSortNumber) == HexDump
 					.unsignedByte((byte) 0xff)) {
 				expectedSensorSortNumberForCalibration[0] = (byte) 0x00;
@@ -1775,25 +1926,25 @@ public String processManualCalibrationDataMessage(float value, boolean instant)
 		SharedPreferences.Editor editor = settings.edit();
 		editor.putFloat("lastGlucometerValue", (float) num);
 		editor.putLong("glucometerLastDate", d.getTime());
-		if (!instant){
-			editor.putString("expectedSensorSortNumberForCalibration0",
-					HexDump.toHexString(expectedSensorSortNumberForCalibration[0]));
-			editor.putString("expectedSensorSortNumberForCalibration1",
-					HexDump.toHexString(expectedSensorSortNumberForCalibration[1]));
-		}else{
+		if (!instant && doCalibration) {
+			editor.putString("expectedSensorSortNumberForCalibration0", HexDump
+					.toHexString(expectedSensorSortNumberForCalibration[0]));
+			editor.putString("expectedSensorSortNumberForCalibration1", HexDump
+					.toHexString(expectedSensorSortNumberForCalibration[1]));
+		} else {
 			editor.remove("expectedSensorSortNumberForCalibration0");
 			editor.remove("expectedSensorSortNumberForCalibration1");
 		}
 		if (lastGlucometerValue > 0) {
-			isCalibrating = true;
+			isCalibrating = !instant && doCalibration;
 			if (previousRecord == null) {
 				MedtronicSensorRecord auxRecord = new MedtronicSensorRecord();
 				auxRecord.isCalibrating = !instant;
-				log.info("8");
+				log.debug("8");
 				writeLocalCSV(auxRecord, context);
 			} else {
 				previousRecord.isCalibrating = !instant;
-				log.info("9");
+				log.debug("9");
 				writeLocalCSV(previousRecord, context);
 			}
 			editor.putBoolean("isCalibrating", !instant);
@@ -1818,7 +1969,7 @@ private void calibratingBackwards(float previousCalibrationFactor,
 			int previousCalibrationStatus, float isig,
 			MedtronicSensorRecord record, int added, Date currentTime) {
 		List<Record> auxList = null;
-		synchronized (lastRecordsInMemory) {
+		synchronized (lastRecordsListLock) {
 			auxList = lastRecordsInMemory.getListFromTail(2);
 		}
 		if (previousCalibrationFactor > 0) {
@@ -1870,7 +2021,7 @@ private void calibratingCurrentElement(long difference, float isig,
 							record.calibrationStatus = calibrationStatus;
 							lastCalibrationDate = currentTime.getTime();
 							SharedPreferences.Editor editor = settings.edit();
-							log.info("change lastCalibrationDate");
+							log.debug("change lastCalibrationDate");
 							editor.putLong("lastCalibrationDate",
 									lastCalibrationDate);
 							editor.commit();
@@ -1882,7 +2033,7 @@ private void calibratingCurrentElement(long difference, float isig,
 		}
 		if (calibrationFactor > 0 && !calibrated) {
 			List<Record> auxList = null;
-			synchronized (lastRecordsInMemory) {
+			synchronized (lastRecordsListLock) {
 				auxList = lastRecordsInMemory.getListFromTail(2);
 			}
 			if (calibrationStatus != MedtronicConstants.WITHOUT_ANY_CALIBRATION) {
@@ -1903,39 +2054,50 @@ private void calibratingCurrentElement(long difference, float isig,
 		previousRecord = record;
 	}
 
-	public void calculateInstantCalibration(float currentMeasure){
-		log.info("Instant Calibration");
-		if (previousRecord != null && previousRecord.isig != 0){
-			log.info("I  have isig "+previousRecord.isig);
+	public void calculateInstantCalibration(float currentMeasure) {
+		log.debug("Instant Calibration");
+		if (previousRecord != null && previousRecord.isig != 0) {
+			log.debug("I  have isig " + previousRecord.isig);
 			calibrationFactor = currentMeasure / previousRecord.isig;
-			log.info("Instant Calibration result "+ calibrationFactor);
+			log.debug("Instant Calibration result " + calibrationFactor);
 			if (calibrationFactor > 0) {
-				previousRecord.bGValue = ""+ ((int)currentMeasure);
-				log.info("Instant Calibration Success!! ");
+				previousRecord.bGValue = "" + ((int) currentMeasure);
+				log.debug("Instant Calibration Success!! ");
 				calibrationStatus = MedtronicConstants.CALIBRATED;
 				lastCalibrationDate = System.currentTimeMillis();
+				isCalibrating = false;
+				previousRecord.isCalibrating = false;
 				previousRecord.calibrationStatus = calibrationStatus;
-				log.info("10");
+				log.debug("10");
 				writeLocalCSV(previousRecord, context);
 				SharedPreferences.Editor editor = settings.edit();
-				log.info("change instant lastCalibrationDate");
-				editor.putLong("lastCalibrationDate",
-						lastCalibrationDate);
+				log.debug("change instant lastCalibrationDate");
+				editor.putLong("lastCalibrationDate", lastCalibrationDate);
+				editor.putBoolean("isCalibrating", false);
+				editor.putFloat("calibrationFactor", (float) calibrationFactor);
+				editor.putInt("calibrationStatus",
+							calibrationStatus);
 				editor.commit();
 			}
 			return;
-		}else
-			log.info("I dont have isig");
+		} else{
+			sendErrorMessageToUI("I can't calibrate, I don't have any ISIG stored yet.");
+			log.debug("I dont have isig");
+		}
 		if (previousRecord == null)
 			previousRecord = new MedtronicSensorRecord();
-		if (calibrationStatus != MedtronicConstants.WITHOUT_ANY_CALIBRATION){
+		if (calibrationStatus != MedtronicConstants.WITHOUT_ANY_CALIBRATION
+				&& calibrationFactor != -1f) {
 			calibrationStatus = MedtronicConstants.LAST_CALIBRATION_FAILED_USING_PREVIOUS;
+		} else {
+			calibrationStatus = MedtronicConstants.WITHOUT_ANY_CALIBRATION;
 		}
 		previousRecord.calibrationStatus = calibrationStatus;
-		log.info("11");
+		log.debug("11");
 		writeLocalCSV(previousRecord, context);
-		log.info("Instant Calibration Failure!! ");
+		log.debug("Instant Calibration Failure!! ");
 	}
+
 	/**
 	 * This method process the sensor answers
 	 * 
@@ -1951,26 +2113,26 @@ public String processSensorDataMessage(byte[] readData) {
 
 		int added = 8;
 		int firstMeasureByte = firstByteAfterDeviceId(readData);
-		// /sendMessageToUI("processSensorDataMessage isCalibrating "+isCalibrating+" Expected "+HexDump.toHexString(expectedSensorSortNumber)
-		// + " He recibido "+HexDump.toHexString(readData[firstMeasureByte+3]),
-		// false);
-		//log.info("processSensor  calibfactor "+ calibrationFactor+" firstMeasureByte "+firstMeasureByte);
 		int currentMeasure = -1;
 		float isig = 0;
 		StringBuffer sResult = new StringBuffer("");
 		if (firstMeasureByte < 0)
 			return "Error, I can not identify the initial byte of the sensor measure";
 		int numBytes = HexDump.unsignedByte(readData[1]);
-		if (firstMeasureByte > readData.length || numBytes > readData.length || numBytes <= 0)
+		if (firstMeasureByte > readData.length || numBytes > readData.length
+				|| numBytes <= 0)
 			return "Error, I have detected an error in sensor message size";
 		int previousCalibrationStatus = calibrationStatus;
 		float previousCalibrationFactor = calibrationFactor;
 		short adjustement = (short) readData[firstMeasureByte + 2];
-		long firstTimeOut = d.getTime() -lastSensorValueDate;
+		long firstTimeOut = d.getTime() - lastSensorValueDate;
 		if (HexDump.unsignedByte(expectedSensorSortNumber) == HexDump
-				.unsignedByte((byte) 0xff) || firstTimeOut == d.getTime() || (firstTimeOut > MedtronicConstants.TIME_10_MIN_IN_MS+MedtronicConstants.TIME_30_MIN_IN_MS)) {
+				.unsignedByte((byte) 0xff)
+				|| firstTimeOut == d.getTime()
+				|| (firstTimeOut > MedtronicConstants.TIME_10_MIN_IN_MS
+						+ MedtronicConstants.TIME_30_MIN_IN_MS)) {
 			Log.i("Medtronic", "First");
-			log.info("SENSOR MEASURE, First Time, retrieving all previous measures");
+			log.debug("SENSOR MEASURE, First Time, retrieving all previous measures");
 			lastElementsAdded = 0;
 			// I must read ALL THE MEASURES
 			synchronized (expectedSensorSortNumberLock) {
@@ -2015,15 +2177,17 @@ public String processSensorDataMessage(byte[] readData) {
 			}
 
 		} else {
-			log.info("Estoy Esperando "+HexDump.toHexString(expectedSensorSortNumber)+" He recibido "+HexDump.toHexString(readData[firstMeasureByte+3]));
+			log.debug("Estoy Esperando "
+					+ HexDump.toHexString(expectedSensorSortNumber)
+					+ " He recibido "
+					+ HexDump.toHexString(readData[firstMeasureByte + 3]));
 			if (HexDump.unsignedByte(expectedSensorSortNumber) == HexDump
 					.unsignedByte(readData[firstMeasureByte + 3])
 					|| HexDump.unsignedByte(calculateNextSensorSortNameFrom(1,
 							expectedSensorSortNumber)) == HexDump
 							.unsignedByte(readData[firstMeasureByte + 3])) {
-				// sendMessageToUI("Está dentro de lo esperado ", false);
 				Log.i("Medtronic", "Expected sensor number received!!");
-				log.info("SENSOR MEASURE, Expected sensor measure received!!");
+				log.debug("SENSOR MEASURE, Expected sensor measure received!!");
 				lastElementsAdded = 0;
 				// I must read only the first value except if byte ends in "1"
 				// then I skip this value
@@ -2032,8 +2196,6 @@ public String processSensorDataMessage(byte[] readData) {
 						.unsignedByte((byte) ((byte) expectedSensorSortNumber & (byte) 0x01)) < 1
 						&& HexDump
 						.unsignedByte((byte) ((byte) readData[firstMeasureByte + 3] & (byte) 0x01)) == 1) {
-					// sendMessageToUI("NO ES REPETIDO O NO RECIBI EL ANTERIOR LO EVALUO ",
-					// false);
 					byte[] arr = Arrays.copyOfRange(readData,
 							firstMeasureByte + 4, firstMeasureByte + 6);
 					byte[] res = new byte[4];
@@ -2068,46 +2230,49 @@ public String processSensorDataMessage(byte[] readData) {
 				}
 			} else {
 				Log.i("Medtronic", "NOT Expected sensor number received!!");
-				log.info("SENSOR MEASURE, NOT Expected sensor measure received!!");
+				log.debug("SENSOR MEASURE, NOT Expected sensor measure received!!");
 				int dataLost = -1;
-				if (previousRecord != null || lastSensorValueDate > 0){
+				if (previousRecord != null || lastSensorValueDate > 0) {
 					long timeDiff = 0;
 					if (previousRecord != null)
-						timeDiff = d.getTime() - previousRecord.displayDateTime ;
+						timeDiff = d.getTime() - previousRecord.displayDateTime;
 					else
 						timeDiff = d.getTime() - lastSensorValueDate;
-					if (timeDiff > (MedtronicConstants.TIME_30_MIN_IN_MS + MedtronicConstants.TIME_10_MIN_IN_MS)){
+					if (timeDiff > (MedtronicConstants.TIME_30_MIN_IN_MS + MedtronicConstants.TIME_10_MIN_IN_MS)) {
 						dataLost = 10;
-						added = 8;					
-					}else{
+						added = 8;
+					} else {
 						int valPrev = transformSequenceToIndex(expectedSensorSortNumber);
 						int currentVal = transformSequenceToIndex(readData[firstMeasureByte + 3]);
 						if (valPrev > currentVal)
-							currentVal = 8+currentVal;
+							currentVal = 8 + currentVal;
 						dataLost = (currentVal - (valPrev)) % 9;
 						if (dataLost < 0)
 							dataLost *= -1;
 						dataLost--;
 						added = dataLost;
-						Log.i("medtronic", " valPrev "+valPrev +" currentVal "+ currentVal+" dataLost "+ dataLost + " added "+added);
+						Log.i("medtronic", " valPrev " + valPrev
+								+ " currentVal " + currentVal + " dataLost "
+								+ dataLost + " added " + added);
 					}
-				}else{
+				} else {
 					dataLost = 10;
 					added = 8;
 				}
-				Log.i("Medtronic", "Data Lost "+dataLost);
-				if (dataLost >= 0){
+				Log.i("Medtronic", "Data Lost " + dataLost);
+				if (dataLost >= 0) {
 					if (dataLost >= 2)
-						dataLost+=2;
-					if (dataLost > 10){
+						dataLost += 2;
+					if (dataLost > 10) {
 						dataLost = 10;
 						added = 8;
 					}
-					log.info("SENSOR MEASURE, I am going to retrieve "+(dataLost)+" previous values");
-					dataLost*=2;
+					log.debug("SENSOR MEASURE, I am going to retrieve "
+							+ (dataLost) + " previous values");
+					dataLost *= 2;
 					lastElementsAdded = 0;
 					// I must read ALL THE MEASURES
-					if (dataLost == 20 || dataLost == 0){
+					if (dataLost == 20 || dataLost == 0) {
 						synchronized (expectedSensorSortNumberLock) {
 							expectedSensorSortNumber = readData[firstMeasureByte + 3];
 						}
@@ -2118,8 +2283,9 @@ public String processSensorDataMessage(byte[] readData) {
 							continue;
 						}
 						lastElementsAdded++;
-						byte[] arr = Arrays.copyOfRange(readData, firstMeasureByte + 4
-								+ i, firstMeasureByte + 6 + i);
+						byte[] arr = Arrays.copyOfRange(readData,
+								firstMeasureByte + 4 + i, firstMeasureByte + 6
+								+ i);
 						byte[] res = new byte[4];
 						if (arr.length < 4) {
 							for (int j = 0; j < 4; j++) {
@@ -2137,20 +2303,21 @@ public String processSensorDataMessage(byte[] readData) {
 						record.setIsig(isig);
 						if (i == 0) {
 							currentMeasure = num;
-							calibratingCurrentElement(difference, isig, readData,
-									firstMeasureByte + 3, record, num, d);
+							calibratingCurrentElement(difference, isig,
+									readData, firstMeasureByte + 3, record,
+									num, d);
 						} else {
 							calibratingBackwards(previousCalibrationFactor,
-									previousCalibrationStatus, isig, record, added, d);
+									previousCalibrationStatus, isig, record,
+									added, d);
 						}
 						added--;
 						lastRecordsInMemory.add(record);
 						calculateTrendAndArrow(record, lastRecordsInMemory);
-						sResult.append("Measure(").append(((i + 2) / 2)).append("): ")
-						.append(num);
+						sResult.append("Measure(").append(((i + 2) / 2))
+						.append("): ").append(num);
 					}
-				}else
-				{
+				} else {
 					byte[] arr = Arrays.copyOfRange(readData,
 							firstMeasureByte + 4, firstMeasureByte + 6);
 					byte[] res = new byte[4];
@@ -2195,10 +2362,11 @@ public String processSensorDataMessage(byte[] readData) {
 		lastSensorValueDate = d.getTime();
 		editor.putLong("lastSensorValueDate", lastSensorValueDate);
 		editor.commit();
-		log.info("12");
+		log.debug("12");
 		writeLocalCSV(previousRecord, context);
 		Log.i("Medtronic", "BYE!!!!");
-		log.info("sensorprocessed end expected "+HexDump.toHexString(expectedSensorSortNumber));
+		log.debug("sensorprocessed end expected "
+				+ HexDump.toHexString(expectedSensorSortNumber));
 		return sResult.toString();
 	}
 
@@ -2216,9 +2384,9 @@ private void writeLocalCSV(MedtronicSensorRecord mostRecentData,
 		// Write EGV Binary of last (most recent) data
 		try {
 			if (mostRecentData == null || mostRecentData.bGValue == null)
-				log.info("writeLocalCSV SAVING  EMPTY!!");
+				log.debug("writeLocalCSV SAVING  EMPTY!!");
 			else
-				log.info("writeLocalCSV SAVING --> "+mostRecentData.bGValue);
+				log.debug("writeLocalCSV SAVING --> " + mostRecentData.bGValue);
 			ObjectOutputStream oos = new ObjectOutputStream(
 					new FileOutputStream(new File(context.getFilesDir(),
 							"save.bin"))); // Select where you wish to save the
@@ -2325,14 +2493,15 @@ private byte calculateNextSensorSortNameFrom(int shift,
 			return (byte) 0xff;
 	}
 
-	private int transformSequenceToIndex(byte aux){
+	private int transformSequenceToIndex(byte aux) {
 		String sExpected = HexDump.toHexString(aux);
 		char sort1 = sExpected.charAt(0);
-		int result = Integer.parseInt(""+sort1);
+		int result = Integer.parseInt("" + sort1);
 		if (result == 0)
 			result = 8;
-		return result;		
+		return result;
 	}
+
 	/**
 	 * This function checks if the measure index is between a range of indexes
 	 * previously stored.
@@ -2368,11 +2537,11 @@ private boolean isSensorMeasureInRange(byte measureIndex, byte[] range) {
 	 * method to store the current status of my known devices. this info will be
 	 * used to restore status.
 	 */
-	private void storeKnownDevices() {
+	public void storeKnownDevices() {
 		StringBuffer listKnownDevices = new StringBuffer();
 		boolean first = true;
 		for (String id : knownDevices) {
-			if (id.length() > 0){
+			if (id.length() > 0) {
 				if (!first)
 					listKnownDevices = listKnownDevices.append(",");
 				else
@@ -2396,13 +2565,18 @@ private void storeKnownDevices() {
 	 *            , index of this reading respectively the initTime reading.
 	 *            Each increment subtracts 5 minutes to "initTime"
 	 */
-	private void calculateDate(Record record, Date initTime, int subtract) {
+	public void calculateDate(Record record, Date initTime, int subtract) {
 		Date d = initTime;
 
 		long milliseconds = d.getTime();
 
 		if (subtract > 0) {
-			milliseconds -= subtract * MedtronicConstants.TIME_5_MIN_IN_MS;// record was read (subtract * 5
+			milliseconds -= subtract * MedtronicConstants.TIME_5_MIN_IN_MS;// record
+			// was
+			// read
+			// (subtract
+			// *
+			// 5
 			// minutes) before the initTime
 		}
 
@@ -2417,8 +2591,9 @@ private void calculateDate(Record record, Date initTime, int subtract) {
 		String displayTime = new SimpleDateFormat("MM/dd/yyy hh:mm:ss aa",
 				Locale.getDefault()).format(display);
 		record.displayTime = displayTime;
-		if (record instanceof MedtronicSensorRecord){
-			((MedtronicSensorRecord)record).displayDateTime = display.getTime();
+		if (record instanceof MedtronicSensorRecord) {
+			((MedtronicSensorRecord) record).displayDateTime = display
+					.getTime();
 		}
 	}
 
@@ -2431,11 +2606,8 @@ private void calculateDate(Record record, Date initTime, int subtract) {
 	 */
 	private void calculateCalibration(long difference, float currentMeasure,
 			byte currentIndex) {
-		// sendMessageToUI("calculateCalibration difference "+difference+" currentMeasure "+currentMeasure+
-		// " currentIndex "+HexDump.toHexString(currentIndex), false);
 		if (difference >= MedtronicConstants.TIME_15_MIN_IN_MS
 				&& difference < MedtronicConstants.TIME_20_MIN_IN_MS) {
-			// sendMessageToUI("firstIF", false);
 			if (isSensorMeasureInRange(currentIndex,
 					expectedSensorSortNumberForCalibration)) {
 				isCalibrating = false;
@@ -2443,14 +2615,13 @@ private void calculateCalibration(long difference, float currentMeasure,
 				calibrationIsigValue = currentMeasure;
 				SharedPreferences.Editor editor = settings.edit();
 				calibrationFactor = lastGlucometerValue / calibrationIsigValue;
-				// sendMessageToUI("Is In RANGE CALIBRATION SUCCESS "+currentMeasure+
-				// " Factor "+calibrationFactor, false);
 				editor.remove("expectedSensorSortNumberForCalibration0");
 				editor.remove("expectedSensorSortNumberForCalibration1");
 				editor.putFloat("calibrationFactor", (float) calibrationFactor);
+				editor.putInt("calibrationStatus",
+						calibrationStatus);
 				editor.commit();
 			} else {
-				// sendMessageToUI("Is NOT In RANGE CALIBRATION", false);
 				if (calibrationStatus != MedtronicConstants.WITHOUT_ANY_CALIBRATION
 						&& currentIndex != expectedSensorSortNumber) {
 					calibrationStatus = MedtronicConstants.LAST_CALIBRATION_FAILED_USING_PREVIOUS;
@@ -2458,13 +2629,14 @@ private void calculateCalibration(long difference, float currentMeasure,
 				} else {
 					calibrationStatus = MedtronicConstants.WITHOUT_ANY_CALIBRATION;
 				}
+				SharedPreferences.Editor editor = settings.edit();
+				editor.remove("expectedSensorSortNumberForCalibration0");
+				editor.remove("expectedSensorSortNumberForCalibration1");
+				editor.commit();
 			}
 		} else if (difference >= MedtronicConstants.TIME_20_MIN_IN_MS) {
-			// sendMessageToUI("AFTER 15 MIN", false);
 			if (isSensorMeasureInRange(currentIndex,
 					expectedSensorSortNumberForCalibration)) {
-				// sendMessageToUI("Is In RANGE CALIBRATION SUCCESS "+currentMeasure,
-				// false);
 				calibrationStatus = MedtronicConstants.CALIBRATED_IN_15MIN;
 				calibrationIsigValue = currentMeasure;
 				SharedPreferences.Editor editor = settings.edit();
@@ -2472,50 +2644,71 @@ private void calculateCalibration(long difference, float currentMeasure,
 				editor.remove("expectedSensorSortNumberForCalibration0");
 				editor.remove("expectedSensorSortNumberForCalibration1");
 				editor.putFloat("calibrationFactor", (float) calibrationFactor);
+				editor.putInt("calibrationStatus",
+						calibrationStatus);
 				editor.commit();
 			} else {
-				// sendMessageToUI("Is NOT In RANGE CALIBRATION2", false);
 				if (calibrationStatus != MedtronicConstants.WITHOUT_ANY_CALIBRATION)
 					calibrationStatus = MedtronicConstants.LAST_CALIBRATION_FAILED_USING_PREVIOUS;
 				else {
 					calibrationStatus = MedtronicConstants.WITHOUT_ANY_CALIBRATION;
 				}
+				SharedPreferences.Editor editor = settings.edit();
+				editor.remove("expectedSensorSortNumberForCalibration0");
+				editor.remove("expectedSensorSortNumberForCalibration1");
+				editor.commit();
 			}
 			isCalibrating = false;
 		} else {
-			if (calibrationStatus != MedtronicConstants.WITHOUT_ANY_CALIBRATION)
-				calibrationStatus = MedtronicConstants.LAST_CALIBRATION_FAILED_USING_PREVIOUS;
-			else{
-				if (isCalibrating && difference < MedtronicConstants.TIME_5_MIN_IN_MS){
+			if (isCalibrating){
+				if (difference < MedtronicConstants.TIME_5_MIN_IN_MS) {
 					calibrationStatus = MedtronicConstants.CALIBRATING;
-				}else if (isCalibrating && difference >= MedtronicConstants.TIME_5_MIN_IN_MS && difference <= MedtronicConstants.TIME_15_MIN_IN_MS)
+				} else if (difference >= MedtronicConstants.TIME_5_MIN_IN_MS
+						&& difference <= MedtronicConstants.TIME_15_MIN_IN_MS)
 					calibrationStatus = MedtronicConstants.CALIBRATING2;
 				else
+					calibrationStatus = MedtronicConstants.CALIBRATING;
+			}else{
+				if (calibrationStatus != MedtronicConstants.WITHOUT_ANY_CALIBRATION)
+					calibrationStatus = MedtronicConstants.LAST_CALIBRATION_FAILED_USING_PREVIOUS;
+				else {
 					calibrationStatus = MedtronicConstants.WITHOUT_ANY_CALIBRATION;
+				}
+				SharedPreferences.Editor editor = settings.edit();
+				editor.remove("expectedSensorSortNumberForCalibration0");
+				editor.remove("expectedSensorSortNumberForCalibration1");
+				editor.putInt("calibrationStatus",
+						calibrationStatus);
+				editor.commit();
 			}
 		}
 	}
+
 	/**
 	 * Function which helps to calculate the difference of Glucose.
-	 * @param size, amount of records to use (aprox. 5 min between records)
-	 * @param list, list of records.
+	 * 
+	 * @param size
+	 *            , amount of records to use (aprox. 5 min between records)
+	 * @param list
+	 *            , list of records.
 	 * @return, Total Glucose variation.
 	 */
 	public Float getGlucoseDifferentialIn(int size, CircleList<Record> list) {
 		List<Record> auxList = list.getListFromTail(size);
-		SimpleDateFormat formatter = new SimpleDateFormat("MM/dd/yyyy hh:mm:ss a", Locale.getDefault());
+		SimpleDateFormat formatter = new SimpleDateFormat(
+				"MM/dd/yyyy hh:mm:ss a", Locale.getDefault());
 		if (auxList.size() == size) {
-			log.info("I Have the correct size");
+			log.debug("I Have the correct size");
 			for (int i = 1; i < size; i++) {
-				if (!(auxList.get(i) instanceof MedtronicSensorRecord)){
-					log.info("but not the correct records");
+				if (!(auxList.get(i) instanceof MedtronicSensorRecord)) {
+					log.debug("but not the correct records");
 					return null;
 				}
 			}
 			float diff = 0;
 			long dateDif = 0;
 			for (int i = 1; i < size; i++) {
-				log.info("Start calculate diff");
+				log.debug("Start calculate diff");
 				MedtronicSensorRecord prevRecord = (MedtronicSensorRecord) auxList
 						.get(i - 1);
 				MedtronicSensorRecord record = (MedtronicSensorRecord) auxList
@@ -2526,12 +2719,11 @@ public Float getGlucoseDifferentialIn(int size, CircleList<Record> list) {
 					prevDate = formatter.parse(prevRecord.displayTime);
 					date = formatter.parse(record.displayTime);
 					dateDif += (prevDate.getTime() - date.getTime());
-					log.info("DATE_diff "+dateDif);
+					log.debug("DATE_diff " + dateDif);
 				} catch (ParseException e1) {
 					e1.printStackTrace();
 				}
 
-
 				float prevRecordValue = 0;
 				float recordValue = 0;
 				try {
@@ -2545,22 +2737,23 @@ public Float getGlucoseDifferentialIn(int size, CircleList<Record> list) {
 
 				}
 
-				if (prevRecordValue > 0 && recordValue <= 0){
-					log.info("AdjustRecordValue prev "+prevRecordValue+" record "+recordValue);
+				if (prevRecordValue > 0 && recordValue <= 0) {
+					log.debug("AdjustRecordValue prev " + prevRecordValue
+							+ " record " + recordValue);
 					recordValue = prevRecordValue;
 				}
 				diff += prevRecordValue - recordValue;
-				log.info("VALUEDIFF "+diff);
+				log.debug("VALUEDIFF " + diff);
 			}
-			if ( dateDif > MedtronicConstants.TIME_20_MIN_IN_MS){
-				log.info("EXIT BY TIME ");
+			if (dateDif > MedtronicConstants.TIME_20_MIN_IN_MS) {
+				log.debug("EXIT BY TIME ");
 				return null;
-			}else{
-				log.info("CORRECT EXIT ");
+			} else {
+				log.debug("CORRECT EXIT ");
 				return diff;
 			}
-		} else{
-			log.info("I DO NOT Have the correct size "+auxList.size());
+		} else {
+			log.debug("I DO NOT Have the correct size " + auxList.size());
 			return null;
 		}
 	}
@@ -2592,27 +2785,31 @@ public float calculateISIG(int value, short adjustment) {
 	 */
 	public int applyFilterToRecord(MedtronicSensorRecord currentRecord,
 			List<Record> auxList) {
-		/*if (auxList.size() >= 2) {
-
-			if (!(auxList.get(0) instanceof MedtronicSensorRecord))
-				return -1;
-			MedtronicSensorRecord record = (MedtronicSensorRecord) auxList
-					.get(0);
-			MedtronicSensorRecord record2 = (MedtronicSensorRecord) auxList
-					.get(1);
-			return (int) ((currentRecord.unfilteredGlucose * glucoseFilter[0]) + (record.unfilteredGlucose * glucoseFilter[1]) + (record2.unfilteredGlucose * glucoseFilter[2]));
-		} else if (auxList.size() == 1) {
-			MedtronicSensorRecord record = (MedtronicSensorRecord) auxList
-					.get(0);
-			return (int) ((currentRecord.unfilteredGlucose * glucoseFilter[0]) + (currentRecord.unfilteredGlucose * glucoseFilter[1]) + (record.unfilteredGlucose * glucoseFilter[2]));
-		}else{
-			return (int) ((currentRecord.unfilteredGlucose * glucoseFilter[0]) + (currentRecord.unfilteredGlucose * glucoseFilter[1])+ (currentRecord.unfilteredGlucose * glucoseFilter[2]));
-		}*/
-		return (int)currentRecord.unfilteredGlucose;
+		/*
+		 * if (auxList.size() >= 2) {
+		 * 
+		 * if (!(auxList.get(0) instanceof MedtronicSensorRecord)) return -1;
+		 * MedtronicSensorRecord record = (MedtronicSensorRecord) auxList
+		 * .get(0); MedtronicSensorRecord record2 = (MedtronicSensorRecord)
+		 * auxList .get(1); return (int) ((currentRecord.unfilteredGlucose *
+		 * glucoseFilter[0]) + (record.unfilteredGlucose * glucoseFilter[1]) +
+		 * (record2.unfilteredGlucose * glucoseFilter[2])); } else if
+		 * (auxList.size() == 1) { MedtronicSensorRecord record =
+		 * (MedtronicSensorRecord) auxList .get(0); return (int)
+		 * ((currentRecord.unfilteredGlucose * glucoseFilter[0]) +
+		 * (currentRecord.unfilteredGlucose * glucoseFilter[1]) +
+		 * (record.unfilteredGlucose * glucoseFilter[2])); }else{ return (int)
+		 * ((currentRecord.unfilteredGlucose * glucoseFilter[0]) +
+		 * (currentRecord.unfilteredGlucose * glucoseFilter[1])+
+		 * (currentRecord.unfilteredGlucose * glucoseFilter[2])); }
+		 */
+		return (int) currentRecord.unfilteredGlucose;
 
 	}
+
 	/**
 	 * calculates crc16
+	 * 
 	 * @param bytes
 	 * @return crc
 	 */
@@ -2644,11 +2841,9 @@ public void calculateTrendAndArrow(MedtronicSensorRecord record,
 		String trend = "Not Calculated";
 		String trendA = "--X";
 		Float diff = getGlucoseDifferentialIn(3, list);// most Recent first
-		Log.i("calculateTrendAndArrow", "diffAverage "+diff);
 		if (diff != null) {
 			diff /= 5f;
 			diff *= 0.0555f;// convierto a mmol/l
-			Log.i("calculateTrendAndArrow", "mmol/l "+diff);
 			int trendArrow = 0;
 			if (diff >= -0.06f && diff <= 0.06f)
 				trendArrow = 4;
@@ -2719,6 +2914,37 @@ else if ((diff > 0.06f) && (diff <= 0.11f)) {
 		record.trendArrow = trendA;
 	}
 
+	/**
+     * Sends an error message to be printed in the display (DEBUG) if it is repeated, It is not printed again. If UI is not visible, It will launch a pop-up message.
+     * @param valuetosend
+     * @param clear, if true, the display is cleared before printing "valuetosend"
+     */
+	private void sendErrorMessageToUI(String valuetosend) {
+		Log.e("medtronicCGMService", valuetosend);
+		log.error("Send Error Message to UI "+ valuetosend);
+		if (mClients != null && mClients.size() > 0) {
+			for (int i = mClients.size() - 1; i >= 0; i--) {
+				try {
+					Message mSend = null;
+					mSend = Message
+							.obtain(null,
+									MedtronicConstants.MSG_MEDTRONIC_CGM_ERROR_RECEIVED);
+					Bundle b = new Bundle();
+					b.putString("data", valuetosend);
+					mSend.setData(b);
+					mClients.get(i).send(mSend);
+
+				} catch (RemoteException e) {
+					// The client is dead. Remove it from the list; we are going
+					// through the list from back to front so this is safe to do
+					// inside the loop.
+					mClients.remove(i);
+				}
+			}
+		} 
+	}
+	
+	
 	/**
 	 * Class to manage the circular aspect of the sensor readings
 	 * 
@@ -2732,6 +2958,7 @@ class CircleList<E> {
 		private int endOffset;
 		private int startOffset;
 		ArrayList<E> list = new ArrayList<E>();
+		private Object listLock = new Object();
 
 		/**
 		 * Constructor
@@ -2739,7 +2966,6 @@ class CircleList<E> {
 		 * @param capacity
 		 */
 		public CircleList(int capacity) {
-			Log.i("DIFF CIRCLE", "DIFF CREATE CIRCLE "+capacity);
 			size = 0;
 			this.capacity = capacity;
 			endOffset = 0;
@@ -2753,8 +2979,7 @@ public CircleList(int capacity) {
 		 * @param item
 		 */
 		public void add(E item) {
-			log.info("DIFF ADDITEMCIRCLE "+endOffset +" startofset "+ startOffset + " size "+ list.size());
-			synchronized (list) {
+			synchronized (listLock) {
 				if (endOffset == capacity) {
 					endOffset = 0;
 					startOffset = 1;
@@ -2770,16 +2995,13 @@ public void add(E item) {
 					startOffset = 0;
 				size = list.size();
 			}
-			log.info("DIFF ADDITEMCIRCLE END"+endOffset +" startofset "+ startOffset + " size "+ list.size());
-
 		}
 
 		/**
 		 * clear
 		 */
 		public void clear() {
-			log.info("CLEAR");
-			synchronized (list) {
+			synchronized (listLock) {
 				size = 0;
 				endOffset = 0;
 				startOffset = 0;
@@ -2797,7 +3019,7 @@ public List<E> getList(int size) {
 			List<E> aux = null;
 			int auxEndOffset = 0;
 			int auxStartOffset = 0;
-			synchronized (list) {
+			synchronized (listLock) {
 				auxEndOffset = endOffset;
 				auxStartOffset = startOffset;
 				aux = new ArrayList<E>();
@@ -2831,12 +3053,11 @@ public List<E> getList(int size) {
 		 * @return a list sorted from the "endOffset" to the "startOffset".
 		 */
 		public List<E> getListFromTail(int size) {
-			log.info("DIFF TAIL size "+ size);
 			List<E> result = new ArrayList<E>();
 			List<E> aux = null;
 			int auxEndOffset = 0;
 			int auxStartOffset = 0;
-			synchronized (list) {
+			synchronized (listLock) {
 				auxEndOffset = endOffset;
 				auxStartOffset = startOffset;
 				aux = new ArrayList<E>();
@@ -2846,11 +3067,10 @@ public List<E> getListFromTail(int size) {
 			int auxSize = size;
 			if (auxSize > aux.size())
 				auxSize = aux.size();
-			log.info("DIFF TAIL AUXsize "+ aux.size());
 
-			log.info("DIFF TAIL auxEndOffset "+ auxEndOffset + "auxStartOffset "+ auxStartOffset);
 			if (auxEndOffset > auxStartOffset) {
-				for (int i = auxEndOffset - 1; i >= auxStartOffset && auxSize > 0; i--) {
+				for (int i = auxEndOffset - 1; i >= auxStartOffset
+						&& auxSize > 0; i--) {
 					result.add(aux.get(i));
 					auxSize--;
 				}
@@ -2860,7 +3080,8 @@ public List<E> getListFromTail(int size) {
 					auxSize--;
 				}
 				if (auxSize > 0) {
-					for (int i = capacity-1; i >= auxStartOffset && auxSize > 0; i--) {
+					for (int i = capacity - 1; i >= auxStartOffset
+							&& auxSize > 0; i--) {
 						result.add(aux.get(i));
 						auxSize--;
 					}
@@ -2874,42 +3095,30 @@ public List<E> getListFromTail(int size) {
 		 * @return items allocated.
 		 */
 		public int size() {
-			synchronized (list) {
+			synchronized (listLock) {
 				return size;
 			}
 		}
 	}
 
 	/**
-	 * Runnable to check how old is the last calibration, and to manage the time out of the current
-	 * calibration process
+	 * Runnable to check how old is the last calibration, and to manage the time
+	 * out of the current calibration process
+	 * 
 	 * @author lmmarguenda
-	 *
+	 * 
 	 */
 	class CalibrationStatusChecker implements Runnable {
 		public Handler mHandlerReviewParameters = null;
-		public CalibrationStatusChecker(Handler mHandlerReviewParameters){
+
+		public CalibrationStatusChecker(Handler mHandlerReviewParameters) {
 			this.mHandlerReviewParameters = mHandlerReviewParameters;
 		}
-		public void run(){
+
+		public void run() {
 			checkCalibrationOutOfTime();
-			if (isCalibrating && lastGlucometerDate > 0 && System.currentTimeMillis()-lastGlucometerDate > MedtronicConstants.TIME_20_MIN_IN_MS){
-				isCalibrating = false;
-				SharedPreferences.Editor editor = settings.edit();
-				lastGlucometerMessage = null;
-				if (calibrationStatus != MedtronicConstants.WITHOUT_ANY_CALIBRATION && calibrationFactor > 0){
-					calibrationStatus = MedtronicConstants.LAST_CALIBRATION_FAILED_USING_PREVIOUS;
-				}else
-					calibrationStatus = MedtronicConstants.WITHOUT_ANY_CALIBRATION;
-				editor.putInt("calibrationStatus", calibrationStatus);
-				editor.remove("lastGlucometerMessage");
-				editor.remove("expectedSensorSortNumber");
-				editor.remove("isCalibrating");
-				editor.remove("lastGlucometerValue");
-				editor.remove("lastGlucometerDate");
-				editor.commit();
-			}
-			mHandlerReviewParameters.postDelayed(this, MedtronicConstants.TIME_5_MIN_IN_MS);
+			mHandlerReviewParameters.postDelayed(this,
+					MedtronicConstants.TIME_5_MIN_IN_MS);
 		}
 	}
 
diff --git a/src/com/nightscout/android/upload/MedtronicPumpRecord.java b/src/com/nightscout/android/upload/MedtronicPumpRecord.java
index 39c9179..16f8bb1 100644
--- a/src/com/nightscout/android/upload/MedtronicPumpRecord.java
+++ b/src/com/nightscout/android/upload/MedtronicPumpRecord.java
@@ -2,6 +2,8 @@
 
 import java.io.Serializable;
 
+import org.bson.Document;
+
 import com.mongodb.DBObject;
 import com.nightscout.android.medtronic.MedtronicConstants;
 
@@ -80,47 +82,47 @@ public void setsParadigmLink3(String sParadigmLink3) {
 	public void setsSensorID(String sSensorID) {
 		this.sSensorID = sSensorID;
 	}
-	public void mergeCurrentWithDBObject(DBObject previousRecord){
-		if (!previousRecord.containsField("insulinLeft") || insulinLeft > 0){
+	public void mergeCurrentWithDBObject(Document previousRecord){
+		if (!previousRecord.containsKey("insulinLeft") || insulinLeft > 0){
 			previousRecord.put("insulinLeft", insulinLeft);
 		}
-		if (!previousRecord.containsField("status") || !("---".equals(status))){
+		if (!previousRecord.containsKey("status") || !("---".equals(status))){
 			previousRecord.put("status", status);
 		}
-		if (!previousRecord.containsField("alarm") || !("---".equals(alarm))){
+		if (!previousRecord.containsKey("alarm") || !("---".equals(alarm))){
 			previousRecord.put("alarm", alarm);
 		}
-		if (!previousRecord.containsField("temporaryBasal") || !("---".equals(temporaryBasal))){
+		if (!previousRecord.containsKey("temporaryBasal") || !("---".equals(temporaryBasal))){
 			previousRecord.put("temporaryBasal", temporaryBasal);
 		}
-		if (!previousRecord.containsField("batteryStatus") || !("---".equals(batteryStatus))){
+		if (!previousRecord.containsKey("batteryStatus") || !("---".equals(batteryStatus))){
 			previousRecord.put("batteryStatus", batteryStatus);
 		}
-		if (!previousRecord.containsField("batteryVoltage") || !("---".equals(batteryVoltage))){
+		if (!previousRecord.containsKey("batteryVoltage") || !("---".equals(batteryVoltage))){
 			previousRecord.put("batteryVoltage", batteryVoltage);
 		}
-		if (!previousRecord.containsField("model") || !("---".equals(model))){
+		if (!previousRecord.containsKey("model") || !("---".equals(model))){
 			previousRecord.put("model", model);
 		}
-		if (!previousRecord.containsField("sRemoteControlID1") || !("---".equals(sRemoteControlID1))){
+		if (!previousRecord.containsKey("sRemoteControlID1") || !("---".equals(sRemoteControlID1))){
 			previousRecord.put("sRemoteControlID1", sRemoteControlID1);
 		}
-		if (!previousRecord.containsField("sRemoteControlID2") || !("---".equals(sRemoteControlID2))){
+		if (!previousRecord.containsKey("sRemoteControlID2") || !("---".equals(sRemoteControlID2))){
 			previousRecord.put("sRemoteControlID2", sRemoteControlID2);
 		}
-		if (!previousRecord.containsField("sRemoteControlID3") || !("---".equals(sRemoteControlID3))){
+		if (!previousRecord.containsKey("sRemoteControlID3") || !("---".equals(sRemoteControlID3))){
 			previousRecord.put("sRemoteControlID3", sRemoteControlID3);
 		}
-		if (!previousRecord.containsField("sParadigmLink1") || !("---".equals(sParadigmLink1))){
+		if (!previousRecord.containsKey("sParadigmLink1") || !("---".equals(sParadigmLink1))){
 			previousRecord.put("sParadigmLink1", sParadigmLink1);
 		}
-		if (!previousRecord.containsField("sParadigmLink2") || !("---".equals(sParadigmLink2))){
+		if (!previousRecord.containsKey("sParadigmLink2") || !("---".equals(sParadigmLink2))){
 			previousRecord.put("sParadigmLink2", sParadigmLink2);
 		}
-		if (!previousRecord.containsField("sParadigmLink3") || !("---".equals(sParadigmLink3))){
+		if (!previousRecord.containsKey("sParadigmLink3") || !("---".equals(sParadigmLink3))){
 			previousRecord.put("sParadigmLink3", sParadigmLink3);
 		}
-		if (!("---".equals(sSensorID)) || (!previousRecord.containsField("sSensorID"))){
+		if (!("---".equals(sSensorID)) || (!previousRecord.containsKey("sSensorID"))){
 			previousRecord.put("sSensorID", sSensorID);
 		}
 		previousRecord.put("isWarmingUp", isWarmingUp);
diff --git a/src/com/nightscout/android/upload/UploadHelper.java b/src/com/nightscout/android/upload/UploadHelper.java
index 7a14066..e22b669 100644
--- a/src/com/nightscout/android/upload/UploadHelper.java
+++ b/src/com/nightscout/android/upload/UploadHelper.java
@@ -10,6 +10,8 @@
 import java.util.List;
 import java.util.Locale;
 
+import static com.mongodb.client.model.Filters.*;
+
 import org.apache.http.client.ResponseHandler;
 import org.apache.http.client.methods.HttpPost;
 import org.apache.http.entity.StringEntity;
@@ -18,6 +20,8 @@
 import org.apache.http.params.BasicHttpParams;
 import org.apache.http.params.HttpConnectionParams;
 import org.apache.http.params.HttpParams;
+import org.bson.BsonDocument;
+import org.bson.Document;
 import org.json.JSONArray;
 import org.json.JSONObject;
 
@@ -44,6 +48,10 @@
 import com.mongodb.MongoClient;
 import com.mongodb.MongoClientOptions;
 import com.mongodb.MongoClientOptions.Builder;
+import com.mongodb.client.FindIterable;
+import com.mongodb.client.MongoCollection;
+import com.mongodb.client.MongoCursor;
+import com.mongodb.client.MongoDatabase;
 import com.mongodb.MongoCredential;
 import com.mongodb.ServerAddress;
 import com.mongodb.WriteConcern;
@@ -71,12 +79,13 @@ public class UploadHelper extends AsyncTask<Record, Integer, Long> {
     public String dsCollectionName = null;
     public String gdCollectionName = null;
     public String devicesCollectionName = "devices";
-    public DB db = null;
-    public DBCollection dexcomData = null;
-    public DBCollection glucomData = null;
-    public DBCollection deviceData = null;
-    public DBCollection dsCollection = null;
+    public MongoDatabase db = null;
+    public MongoCollection<Document> dexcomData = null;
+    public MongoCollection<Document> glucomData = null;
+    public MongoCollection<Document> deviceData = null;
+    public MongoCollection<Document> dsCollection = null;
     public static Boolean isModifyingRecords = false;
+    public static Object isModifyingRecordsLock = new Object();
     private MongoClient client = null;
     public UploadHelper(Context context) {
         this(context, DexcomG4Activity.DEXCOMG4);
@@ -87,7 +96,7 @@ public UploadHelper(Context context, int cgmSelected) {
         this.cgmSelected = cgmSelected; 
         this.mClients = null;
         settings = context.getSharedPreferences(MedtronicConstants.PREFS_NAME, 0);
-        synchronized (isModifyingRecords) {
+        synchronized (isModifyingRecordsLock) {
 	        try {
 	        	long currentTime = System.currentTimeMillis();
 	    		long diff = currentTime - settings.getLong("lastDestroy", 0);
@@ -138,6 +147,26 @@ public UploadHelper(Context context, int cgmSelected, ArrayList<Messenger> mClie
     	this(context, cgmSelected);
         this.mClients = mClients;
     }
+    /**
+     * Sends a message to reconnect to mongo
+     */
+    private void sendRefreshDBConnToUI() {    	
+    	if (mClients != null && mClients.size() > 0){
+	        for (int i=mClients.size()-1; i>=0; i--) {
+	            try {
+	            	Message mSend = null;
+	            	mSend = Message.obtain(null, MedtronicConstants.MSG_REFRESH_DB_CONNECTION); 
+	                mClients.get(i).send(mSend);
+	            } catch (RemoteException e) {
+	                // The client is dead. Remove it from the list; we are going through the list from back to front so this is safe to do inside the loop.
+	                mClients.remove(i);
+	            }
+	        }
+    	}
+    }
+    
+    
+    
     /**
      * Sends a message to be printed in the display (DEBUG)
      * @param valuetosend
@@ -166,6 +195,37 @@ private void sendMessageToUI(String valuetosend, boolean clear) {
 	        }
     	}
     }
+    
+    /**
+     * Sends an error message to be printed in the display (DEBUG) if it is repeated, It is not printed again. If UI is not visible, It will launch a pop-up message.
+     * @param valuetosend
+     * @param clear, if true, the display is cleared before printing "valuetosend"
+     */
+	private void sendErrorMessageToUI(String valuetosend) {
+		Log.e("medtronicCGMService", valuetosend);
+		log.error("Send Error Message to UI "+ valuetosend);
+		if (mClients != null && mClients.size() > 0) {
+			for (int i = mClients.size() - 1; i >= 0; i--) {
+				try {
+					Message mSend = null;
+					mSend = Message
+							.obtain(null,
+									MedtronicConstants.MSG_MEDTRONIC_CGM_ERROR_RECEIVED);
+					Bundle b = new Bundle();
+					b.putString("data", valuetosend);
+					mSend.setData(b);
+					mClients.get(i).send(mSend);
+
+				} catch (RemoteException e) {
+					// The client is dead. Remove it from the list; we are going
+					// through the list from back to front so this is safe to do
+					// inside the loop.
+					mClients.remove(i);
+				}
+			}
+		} 
+	}
+    
     /**
      * 
      * @return constant String to identify the selected Device
@@ -422,7 +482,7 @@ private void doRESTUploadTo(String baseURI, Record[] records) {
             log.error("Unable to post data", e);
         }
         if (recordsNotUploadedListJson.size() > 0){
-        	synchronized (isModifyingRecords) {
+        	synchronized (isModifyingRecordsLock) {
     	        try {
 	        		JSONArray recordsNotUploadedJson = new JSONArray(settings.getString("recordsNotUploadedJson","[]"));
 	        		if (recordsNotUploadedJson.length() > 0 && recordsNotUploadedJson.length() < recordsNotUploadedListJson.size()){
@@ -554,15 +614,18 @@ private void populateLegacyAPIEntry(JSONObject json, Record oRecord) throws Exce
     private void doMongoUpload(SharedPreferences prefs, Record... records) {
         Integer typeSaved = null;
         boolean recordsTry = false;
+        boolean refreshAsked = false;
         if (dbURI != null) {
-        	DBCursor cursor = null;
-            BasicDBObject testData = new BasicDBObject();
+        	MongoCursor<Document> cursor = null;
+            Document testData = new Document();
             try {
                 // connect to db
                 Builder b = MongoClientOptions.builder();
-                b.heartbeatConnectTimeout(60000);
-                b.heartbeatSocketTimeout(60000);
-                b.maxWaitTime(60000);
+                b.heartbeatConnectTimeout(150000);
+                b.heartbeatFrequency(120000);
+                b.heartbeatSocketTimeout(150000);
+                b.maxWaitTime(150000);
+                b.connectTimeout(150000);
                 boolean bAchieved = false;
                 String user = "";
                 String password = "";
@@ -619,7 +682,7 @@ private void doMongoUpload(SharedPreferences prefs, Record... records) {
 	            			if (ob != null){
 		            			Iterator<String> keys = ob.keys();
 		            			boolean atLeastOne= false;
-		            			testData = new BasicDBObject();
+		            			testData = new Document();
 		            			while (keys.hasNext()){
 		            				String key = keys.next();
 		            				if (ob.get(key) != null){
@@ -628,19 +691,24 @@ private void doMongoUpload(SharedPreferences prefs, Record... records) {
 		            				}
 		            			}
 		            			if (atLeastOne)
-		            				dexcomData.save(testData, WriteConcern.UNACKNOWLEDGED);
+		            				dexcomData.insertOne(testData);
 	            			}
             			}catch(IllegalArgumentException ex){
-            				Log.e("UploaderHelper", "Illegal record");
+            				log.error("UploaderHelper", "Illegal record");
             			}catch (Exception e){
             				Log.e("UploaderHelper", "The retried can't be uploaded");
             				log.error("The retried record can't be uploaded ", e);
+            				sendErrorMessageToUI("Error retrying the upload of a stored mongo record "+ e.getLocalizedMessage());
             				if (recordsNotUploadedList.size() > 49){
 						    	recordsNotUploadedList.remove(0);
-						    	recordsNotUploadedList.add(49, new JSONObject(testData.toMap()));
+						    	recordsNotUploadedList.add(49, new JSONObject(testData.toJson()));
 							}else{
-								recordsNotUploadedList.add(new JSONObject(testData.toMap()));
+								recordsNotUploadedList.add(new JSONObject(testData.toJson()));
 							}
+            				if (!refreshAsked){
+                      			sendRefreshDBConnToUI();
+                      			refreshAsked = true;
+                      		}
             			}
             		}
             	}
@@ -650,7 +718,7 @@ private void doMongoUpload(SharedPreferences prefs, Record... records) {
                 for (Record oRecord : records) {
                 	recordsTry = true;
                 	try{
-	                	testData = new BasicDBObject();
+	                	testData = new Document();
 	                	Date date = DATE_FORMAT.parse(oRecord.displayTime);
 	                    testData.put("date", date.getTime());
 	                    testData.put("dateString", oRecord.displayTime);
@@ -674,56 +742,54 @@ private void doMongoUpload(SharedPreferences prefs, Record... records) {
 		                    	if (!prefs.getBoolean("isCheckedWUP", false) && deviceData != null){
 		                    		log.info("Testing isCheckedWUP -->GET INTO");
 			                		MedtronicPumpRecord pumpRecord = new MedtronicPumpRecord();
-			                		HashMap<String, Object> filter = new HashMap<String, Object>();
-			                		filter.put("deviceId", prefs.getString("medtronic_cgm_id", ""));
-			                		cursor = deviceData.find(new BasicDBObject(filter));
+			                		cursor = deviceData.find(eq("deviceId",prefs.getString("medtronic_cgm_id", ""))).iterator();
 			                		if (cursor.hasNext()){
-			                			DBObject previousRecord = cursor.next();
+			                			Document previousRecord = cursor.next();
 										previousRecord.put("date", testData.get("date"));
 										previousRecord.put("dateString", testData.get("dateString"));
-										JSONObject job = new JSONObject(previousRecord.toMap());
+										JSONObject job = new JSONObject(previousRecord.toJson());
 										isWarmingUp = job.getBoolean("isWarmingUp");
 										log.info("Testing isCheckedWUP -->NEXT -->ISWUP?? "+ isWarmingUp);
 										if (isWarmingUp){
 											pumpRecord.mergeCurrentWithDBObject(previousRecord);
 											log.info("Uploading a DeviceRecord");
-											deviceData.save(previousRecord, WriteConcern.ACKNOWLEDGED);
+											deviceData.replaceOne(eq("_id", previousRecord.get("_id")), previousRecord);
 											prefs.edit().putBoolean("isCheckedWUP", true).commit();
 										}
 			                		}
 		                    	}
 		                    }
 		                    log.info("Uploading a EGVRecord");
-		                    dexcomData.save(testData, WriteConcern.UNACKNOWLEDGED);
+		                    dexcomData.insertOne(testData);
 	                	}else if (oRecord instanceof GlucometerRecord && (glucomData != null || dexcomData != null)){
 	                		typeSaved = 2;
 	                		GlucometerRecord gdRecord = (GlucometerRecord) oRecord;
 	                		if (glucomData != null){//To be deprecated
 		                		testData.put("gdValue", gdRecord.numGlucometerValue);
 		                		log.info("Uploading a GlucometerRecord");
-		                		glucomData.save(testData, WriteConcern.UNACKNOWLEDGED);
+		                		glucomData.insertOne(testData);
 	                		}
 	                		if (dexcomData != null){
 	                			 testData.put("device", getSelectedDeviceName());
 	                             testData.put("type", "mbg");
 	                             testData.put("mbg", gdRecord.numGlucometerValue);
 	                             log.info("Uploading a Glucometer Record!");
-	 		                     dexcomData.save(testData, WriteConcern.UNACKNOWLEDGED);
+	 		                     dexcomData.insertOne(testData);
 	                		}
 	                	}else if (oRecord instanceof MedtronicPumpRecord && deviceData != null){
 	                		typeSaved = 3;
 	                		MedtronicPumpRecord pumpRecord = (MedtronicPumpRecord) oRecord;
 	                		HashMap<String, Object> filter = new HashMap<String, Object>();
 	                		filter.put("deviceId", pumpRecord.deviceId);
-	                		cursor = deviceData.find(new BasicDBObject(filter));
+	                		cursor = deviceData.find(eq("deviceId",pumpRecord.deviceId)).iterator();
 	                		if (cursor.hasNext()){
-	                			DBObject previousRecord = cursor.next();
+	                			Document previousRecord = cursor.next();
 								previousRecord.put("date", testData.get("date"));
 								previousRecord.put("dateString", testData.get("dateString"));
 								isWarmingUp = pumpRecord.isWarmingUp;
 								pumpRecord.mergeCurrentWithDBObject(previousRecord);
 								log.info("Uploading a DeviceRecord");
-								deviceData.save(previousRecord, WriteConcern.ACKNOWLEDGED);
+								deviceData.replaceOne(eq("_id", previousRecord.get("_id")), previousRecord);
 	                		}else{
 	                			testData.put("name", pumpRecord.getDeviceName());
 	                    		testData.put("deviceId", pumpRecord.deviceId);
@@ -736,7 +802,7 @@ private void doMongoUpload(SharedPreferences prefs, Record... records) {
 	                    		isWarmingUp = pumpRecord.isWarmingUp;
 	                    		testData.put("isWarmingUp", pumpRecord.isWarmingUp);
 	                    		log.info("Uploading a DeviceRecord");
-	                			deviceData.save(testData, WriteConcern.UNACKNOWLEDGED);
+	                			deviceData.insertOne(testData);
 	                		}
 	                		if (cursor != null)
 	                    		cursor.close();
@@ -746,24 +812,30 @@ private void doMongoUpload(SharedPreferences prefs, Record... records) {
         				if (cursor != null)
                     		cursor.close();
         			}catch(Exception ex2){
+        				sendErrorMessageToUI("Error uploading mongo record "+ ex2.getLocalizedMessage());
                 		if (cursor != null)
                     		cursor.close();
 						 if ((typeSaved != null && (typeSaved == 0  ||typeSaved == 1 ))){//Only EGV records are important enough.
+							 sendErrorMessageToUI("It is a SGV record, I am going to store it and retry the upload later.");
 							 if (isWarmingUp){
 								 prefs.edit().putBoolean("isCheckedWUP", false);
 							 }
 							 log.warn("added to records not uploaded");
 						    if (recordsNotUploadedList.size() > 49){
 						    	recordsNotUploadedList.remove(0);
-						    	recordsNotUploadedList.add(49, new JSONObject(testData.toMap()));
+						    	recordsNotUploadedList.add(49, new JSONObject(testData.toJson()));
 							}else{
-								recordsNotUploadedList.add(new JSONObject(testData.toMap()));
+								recordsNotUploadedList.add(new JSONObject(testData.toJson()));
 							}
 						 }else if (typeSaved == 3){
 							 prefs.edit().putBoolean("isWarmingUp", isWarmingUp);
 						 }
                 		 Log.w(TAG, "Unable to upload data to mongo in loop");
                 		 log.warn("Unable to upload data to mongo in loop");
+                		 if (!refreshAsked){
+                   			sendRefreshDBConnToUI();
+                   			refreshAsked = true;
+                   		}
                 	}
                 }
             } catch (Exception e) {
@@ -774,10 +846,12 @@ private void doMongoUpload(SharedPreferences prefs, Record... records) {
             	if (client != null){
             		client.close();
             		client = null;
-            	}
+            	} 
             	if (!recordsTry){
+            		sendErrorMessageToUI("Error uploading mongo records "+ e.getLocalizedMessage());
+            		sendErrorMessageToUI("If there are SGV records, I am going to store them to try a later upload. ");
             		for (Record oRecord : records) {
-                       	testData = new BasicDBObject();
+                       	testData = new Document();
 	                	Date date = null;
 	                	try {
 							date = DATE_FORMAT.parse(oRecord.displayTime);
@@ -805,12 +879,21 @@ private void doMongoUpload(SharedPreferences prefs, Record... records) {
 	                	}
 	                    if ((typeSaved != null && (typeSaved == 0  ||typeSaved == 1 ))){//Only EGV records are important enough.
 	                    	log.warn("added to records not uploaded");
-						    if (recordsNotUploadedList.size() > 49){
-						    	recordsNotUploadedList.remove(0);
-						    	recordsNotUploadedList.add(49, new JSONObject(testData.toMap()));
-							}else{
-								recordsNotUploadedList.add(new JSONObject(testData.toMap()));
-							}
+	                    	try{
+							    if (recordsNotUploadedList.size() > 49){
+							    	recordsNotUploadedList.remove(0);
+							    	recordsNotUploadedList.add(49, new JSONObject(testData.toJson()));
+								}else{
+									recordsNotUploadedList.add(new JSONObject(testData.toJson()));
+								}
+	                    	}catch(Exception ex){
+	                    		StringBuffer sb1 = new StringBuffer("");
+	                    		sb1.append("EXCEPTION!!!!!! "+ ex.getMessage()+" "+ex.getCause());
+	                     		 for (StackTraceElement st : ex.getStackTrace()){
+	                     			 sb1.append(st.toString());
+	                     		 }
+	                     		 sendMessageToUI(sb1.toString(), false);
+	                    	}
 						 }
                     }
             	}
@@ -822,6 +905,10 @@ private void doMongoUpload(SharedPreferences prefs, Record... records) {
           			 sb1.append(st.toString());
           		 }
           		 sendMessageToUI(sb1.toString(), false);
+          		if (!refreshAsked){
+          			sendRefreshDBConnToUI();
+          			refreshAsked = true;
+          		}
             }
             try{
             	if (db != null){
@@ -850,11 +937,11 @@ private void doMongoUpload(SharedPreferences prefs, Record... records) {
 	        			editor.commit();
 	                }
 	                if (update){
-		                BasicDBObject devicestatus = new BasicDBObject();
+		                Document devicestatus = new Document();
 		                devicestatus.put("uploaderBattery", DexcomG4Activity.batLevel);
 		                devicestatus.put("created_at", new Date());
 		                log.debug("Update Battery");
-		                dsCollection.insert(devicestatus, WriteConcern.UNACKNOWLEDGED);
+		                dsCollection.insertOne(devicestatus);
 	                }
             	}
             } catch (Exception e) {
@@ -873,7 +960,11 @@ private void doMongoUpload(SharedPreferences prefs, Record... records) {
           		 for (StackTraceElement st : e.getStackTrace()){
           			 sb1.append(st.toString());
           		 }
-          		 sendMessageToUI(sb1.toString(), false);
+          		sendMessageToUI(sb1.toString(), false);
+          		if (!refreshAsked){
+          			sendRefreshDBConnToUI();
+          			refreshAsked = true;
+          		}
             }
             if (cursor != null){
         		cursor.close();
@@ -884,7 +975,7 @@ private void doMongoUpload(SharedPreferences prefs, Record... records) {
         		client = null;
         	}
         	if (recordsNotUploadedList.size() > 0){
-            	synchronized (isModifyingRecords) {
+            	synchronized (isModifyingRecordsLock) {
         	        try {
     	        		JSONArray recordsNotUploaded = new JSONArray(settings.getString("recordsNotUploaded","[]"));
     	        		if (recordsNotUploaded.length() > 0 && recordsNotUploaded.length() < recordsNotUploadedList.size()){