Diff: Components/VL6180X/vl6180x_class.cpp

Revision:

12:71d589e6fd2c

Parent:

10:4954b09b72d8

Child:

14:0effa0bbf192

diff -r 88541229403e -r 71d589e6fd2c Components/VL6180X/vl6180x_class.cpp
--- a/Components/VL6180X/vl6180x_class.cpp	Tue Oct 06 09:43:25 2015 +0200
+++ b/Components/VL6180X/vl6180x_class.cpp	Tue Oct 13 14:22:45 2015 +0200
@@ -90,6 +90,7 @@
 
 
 /****************** define for i2c configuration *******************************/
+
 #define TEMP_BUF_SIZE	32
 
 #define IsValidGPIOFunction(x) ((x)==GPIOx_SELECT_GPIO_INTERRUPT_OUTPUT || (x)==GPIOx_SELECT_OFF)
@@ -826,7 +827,6 @@
         goto done;
     }
 
-
     /* poll for new sample ready */
     while(1 ){
         status=VL6180x_RangeGetInterruptStatus(dev, &IntStatus.val);
@@ -842,7 +842,7 @@
         if( IntStatus.status.Range == RES_INT_STAT_GPIO_NEW_SAMPLE_READY){
             break;
         }
-
+        
         VL6180x_PollDelay(dev);
     }
  /* //![single_shot_snipet] */
@@ -2667,5 +2667,353 @@
 }
 
 
-
+int VL6180X::InitSensor(uint8_t NewAddr) //FIXME printf da sostituire con VL6180x_ErrLog e poi specificare il contenuto di questa funzione
+{
+   int status=0;
+	  
+   VL6180x_Off();
+   VL6180x_On();
+   status=IsPresent();
+   if(!status)
+   {
+     Device->Present=1;
+		 status=Init();
+     if(status)
+       printf("Failed to init VL6180X sensor!\n");
+		 status=Prepare();
+     if(status)
+       printf("Failed to prepare VL6180X!\n");
+     //status=SetI2CAddress(NewAddr);
+     if(status)
+			 printf("Failed to change I2C address!\n");
+		 /* disable early convergence estimate 
+		 status=VL6180x_RangeSetEceState(Device, 0);
+		 if(status)
+			 printf("Failed to disable ECE!");*/
+		 Device->Ready=1;
+ 	 }
+	 return status;
+}
+
+
+int VL6180X::StartMeasurement(OperatingMode operating_mode, void (*fptr)(void), MeasureData_t *Data) 
+{
+   int status;
+	
+   switch(operating_mode)
+   {
+		  case(1):
+				return RangeMeasPollSingleShot(Data);
+		
+      case(2):
+			  return AlsMeasPollSingleShot(Data);
+			
+			case(3):
+				return RangeMeasPollContinuousMode(Data);
+				 
+			case(4):
+				return AlsMeasPollContinuousMode(Data);  
+				 
+      case(5):
+				return RangeMeasIntContinuousMode(fptr);
+					 
+		  case(6):
+				return AlsMeasIntContinuousMode(fptr);
+				
+	    case(7): break;
+				
+	    case(8): break;
+				
+		  case(9):
+			  return InterleavedMode(fptr); 
+				
+		  default:
+			   return INVALID_PARAMS;
+	 }
+}
+
+
+int VL6180X::GetRangeError(MeasureData_t *Data, VL6180x_RangeData_t RangeData)
+{
+	 IntrStatus_t IntStatus;
+	 int status;
+	 
+	 status=VL6180x_RangeGetInterruptStatus(Device, &IntStatus.val);
+	 if(status)
+		 return status;
+	 Data->range_error=RangeData.errorStatus;
+	 Data->int_error=IntStatus.status.Error;
+	 if((Data->int_error!=0)||(Data->range_error!=0))
+	 {
+      VL6180x_ErrLog("GPIO int Error report %d",(int)IntStatus.val);
+      status=RANGE_ERROR;
+	 }
+	 return status;
+}
+
+
+int VL6180X::GetAlsError(MeasureData_t *Data, VL6180x_AlsData_t AlsData)
+{
+	 Data->als_error=AlsData.errorStatus;
+	 if(Data->als_error!=0)
+     return API_ERROR;
+	 return API_NO_ERROR;
+}
+
+
+int VL6180X::RangeMeasPollSingleShot(MeasureData_t *Data)
+{
+	 VL6180x_RangeData_t RangeData;
+	 int status;
+	
+	 status=RangePollMeasurement(&RangeData);
+	 if(!status)
+	 {
+	    status=GetRangeError(Data, RangeData);
+		  if(!status)
+	      Data->range_mm=RangeData.range_mm;
+	 }
+	 return status;	 
+}	
+
+
+int VL6180X::AlsMeasPollSingleShot(MeasureData_t *Data)
+{
+	 VL6180x_AlsData_t AlsData;
+	 int status;
+	
+	 status=AlsPollMeasurement(&AlsData);
+	 if(!status)
+	 {
+	    status=GetAlsError(Data, AlsData);
+	    if(!status)
+	      Data->lux=AlsData.lux;
+	 }
+	 return status;	
+}
+
+
+int VL6180X::RangeMeasPollContinuousMode(MeasureData_t *Data)
+{
+   int status;
+			
+	 status=VL6180x_RangeClearInterrupt(Device);
+	 if(status)
+	 {
+		  VL6180x_ErrLog("VL6180x_RangeClearInterrupt fail");
+		  return status;
+	 }
+	 status=VL6180x_ClearErrorInterrupt(Device);
+	 if(status)
+	 {
+		  VL6180x_ErrLog("VL6180x_ClearErrorInterrupt fail");
+		  return status;
+	 }
+	 return RangeStartContinuousMode();
+}
+
+
+int VL6180X::AlsMeasPollContinuousMode(MeasureData_t *Data) 
+{
+	 int status;			
+	 
+	 status=VL6180x_AlsClearInterrupt(Device);
+	 if(status)
+	 {
+			VL6180x_ErrLog("VL6180x_AlsClearInterrupt fail");
+			return status;
+	 }
+	 status=VL6180x_ClearErrorInterrupt(Device);
+	 if(status)
+	 {
+		  VL6180x_ErrLog("VL6180x_ClearErrorInterrupt fail");
+			return status;
+	 }
+	 return AlsStartContinuousMode();
+}
+	
+
+int VL6180X::GetRangeMeasContinuousMode(MeasureData_t *Data)
+{
+   VL6180x_RangeData_t RangeData;
+	 int status;
+	
+	 status=VL6180x_RangeGetMeasurement(Device, &RangeData);
+	 if(!status)
+	 {
+		  status=GetRangeError(Data, RangeData);
+		  if(!status)
+		    Data->range_mm=RangeData.range_mm;
+	 }
+	 return status;
+}
+
+
+int VL6180X::GetAlsMeasContinuousMode(MeasureData_t *Data)
+{
+	 VL6180x_AlsData_t AlsData;
+	 int status;
+	
+	 status=VL6180x_AlsGetMeasurement(Device, &AlsData);
+	 if(!status)
+	 {
+	    status=GetAlsError(Data, AlsData);
+		  if(!status)
+				Data->lux=AlsData.lux;
+	 }
+	 return status;
+}
+
+
+int VL6180X::RangeMeasIntContinuousMode(void (*fptr)(void))
+{
+	 int status;
+	 
+	 EnableInterruptMeasureDetectionIRQ();
+	 AttachInterruptMeasureDetectionIRQ(fptr);
+	 status=SetupGPIO1(GPIOx_SELECT_GPIO_INTERRUPT_OUTPUT, 1);
+	 /*ClrStatus=VL6180x_ClearAllInterrupt(Device);
+		if(ClrStatus)
+			VL6180x_ErrLog("VL6180x_ClearErrorInterrupt fail");*/
+   if(!status)
+		 return RangeStartContinuousMode();
+}
+
+
+int VL6180X::AlsMeasIntContinuousMode(void (*fptr)(void))
+{
+   int status;
+	
+	 EnableInterruptMeasureDetectionIRQ();
+   AttachInterruptMeasureDetectionIRQ(fptr);
+   status=SetupGPIO1(GPIOx_SELECT_GPIO_INTERRUPT_OUTPUT, 1);
+	 /*ClrStatus=VL6180x_ClearAllInterrupt(Device);
+		if(ClrStatus)
+			VL6180x_ErrLog("VL6180x_ClearErrorInterrupt fail");*/
+   if(!status)
+     return AlsStartContinuousMode(); 
+}	
+
+
+int VL6180X::StartInterleavedMode()
+{
+	 int status;
+	 uint16_t integration_period, intermeasurement_period_ms;
+	 uint8_t max_convergence_time;
+	
+   status=VL6180x_WrByte(Device, 0x2A3, 1);
+   if(status)
+   {
+		 VL6180x_ErrLog("Failed to read INTERLEAVED_MODE_ENABLE!\n\r");
+		 return status;
+	 }
+	 status=VL6180x_RdByte(Device, SYSRANGE_MAX_CONVERGENCE_TIME, &max_convergence_time);
+	 if(status)
+	 {
+		 VL6180x_ErrLog("Failed to read SYSRANGE_MAX_CONVERGENCE_TIME!\n\r");
+		 return status;
+	 }
+	 status=VL6180x_RdWord(Device, SYSALS_INTEGRATION_PERIOD, &integration_period);
+	 if(status)
+	 {
+		 VL6180x_ErrLog("Failed to read SYSALS_INTEGRATION_PERIOD!\n\r");
+		 return status;
+	 }
+	 max_convergence_time&=0x3F;
+	 integration_period&=0x01FF;
+	 intermeasurement_period_ms=((max_convergence_time+5)+(integration_period*1.1));
+	 intermeasurement_period_ms=(intermeasurement_period_ms/0.9)+10;
+	 status=VL6180x_AlsSetInterMeasurementPeriod(Device, intermeasurement_period_ms);
+	 if(status)
+   {
+		 VL6180x_ErrLog("Failed to write SYSALS_INTERMEASUREMENT_PERIOD!\n\r");
+		 return status;
+	 }
+	 return AlsStartContinuousMode();
+}
+
+
+int VL6180X::InterleavedMode(void (*fptr)(void))
+{
+	  int status;
+	
+	  EnableInterruptMeasureDetectionIRQ();
+    AttachInterruptMeasureDetectionIRQ(fptr);
+    status=SetupGPIO1(GPIOx_SELECT_GPIO_INTERRUPT_OUTPUT, 1);
+	  /*ClrStatus=VL6180x_ClearAllInterrupt(Device);
+		if(ClrStatus)
+			VL6180x_ErrLog("VL6180x_ClearErrorInterrupt fail");*/
+    if(!status)
+      return StartInterleavedMode();
+}
+
+
+void VL6180X::HandleIRQ(MeasureType measure_type, MeasureData_t *Data)
+{
+	 int status, ClrStatus;
+	 /* range measure */
+	 if(measure_type==1)
+	 {
+		  VL6180x_RangeData_t RangeData;
+		  status=RangeGetMeasurement(&RangeData);
+			if(status)
+				VL6180x_ErrLog("Failed to get range measurement");
+			ClrStatus=VL6180x_RangeClearInterrupt(Device);
+			if(ClrStatus)
+				VL6180x_ErrLog("VL6180x_RangeClearInterrupt fail");
+			ClrStatus=VL6180x_ClearErrorInterrupt(Device);
+			if(ClrStatus)
+				VL6180x_ErrLog("VL6180x_ClearErrorInterrupt fail");
+		  EnableInterruptMeasureDetectionIRQ();
+			status=GetRangeError(Data, RangeData);
+		  if(!status)
+		     Data->range_mm=RangeData.range_mm;
+   }
+	 /* light measure */
+	 else if(measure_type==2)
+	 {
+	    VL6180x_AlsData_t AlsData;
+		  status=AlsGetMeasurement(&AlsData);
+		  if(status)
+				VL6180x_ErrLog("Failed to get light measurement");
+			ClrStatus=VL6180x_AlsClearInterrupt(Device);
+			if(ClrStatus)
+				VL6180x_ErrLog("VL6180x_AlsClearInterrupt fail");
+			ClrStatus=VL6180x_ClearErrorInterrupt(Device);
+			if(ClrStatus)
+				VL6180x_ErrLog("VL6180x_ClearErrorInterrupt fail");
+			EnableInterruptMeasureDetectionIRQ();
+			status=GetAlsError(Data, AlsData);
+		  if(!status)
+			   Data->lux=AlsData.lux;
+	 }
+	 /* light and range measure */
+	 else if(measure_type==3)
+	 {
+		  VL6180x_RangeData_t RangeData;
+		  VL6180x_AlsData_t AlsData;
+		  status=RangeGetMeasurement(&RangeData);
+			if(status)
+				VL6180x_ErrLog("Failed to get range measurement");
+			status=AlsGetMeasurement(&AlsData);
+		  if(status)
+				VL6180x_ErrLog("Failed to get light measurement");		 
+		  ClrStatus=VL6180x_ClearAllInterrupt(Device);
+			if(ClrStatus)
+				VL6180x_ErrLog("VL6180x_ClearErrorInterrupt fail");	
+			EnableInterruptMeasureDetectionIRQ();
+			status=GetAlsError(Data, AlsData);
+			if(!status)
+				Data->lux=AlsData.lux;
+			status=GetRangeError(Data, RangeData);
+			if(!status)
+				Data->range_mm=RangeData.range_mm;
+	 }
+   else
+		  printf("Error! Invalid parameter!");
+}
+
+
+
+	
 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/