Diff: Components/VL6180X/vl6180x_class.h

Revision:

12:71d589e6fd2c

Parent:

11:88541229403e

Child:

14:0effa0bbf192

--- a/Components/VL6180X/vl6180x_class.h	Tue Oct 06 09:43:25 2015 +0200
+++ b/Components/VL6180X/vl6180x_class.h	Tue Oct 13 14:22:45 2015 +0200
@@ -50,47 +50,75 @@
 //#include "vl6180x_appcfg.h"
 #include "STMPE1600_class.h"
 
+/* data struct containing range measure, light measure and type of error provided to the user */	
+typedef struct MeasureData 
+{
+	int32_t range_mm;
+	uint32_t lux;
+	uint32_t range_error;
+	uint32_t als_error;
+	uint32_t int_error;
+}MeasureData_t;
+
+/* sensor operating modes */ 
+typedef enum
+{
+	range_single_shot_polling=1,
+	als_single_shot_polling,
+	range_continuous_polling,
+	als_continuous_polling,
+	range_continuous_interrupt,
+	als_continuous_interrupt,
+	range_continuous_als_single_shot,
+	range_single_shot_als_continuous,
+	interleaved_mode,
+}OperatingMode;
+
+/* type of sensor measurement */
+typedef enum
+{
+  range_measure=1,
+	light_measure,
+	light_range_measure,
+}MeasureType;
+
+
 /** default device address */
 #define DEFAULT_DEVICE_ADDRESS		0x29
 
 /* Classes -------------------------------------------------------------------*/
 /** Class representing a VL6180X sensor component
  */
- //FIXME verficare se impostare le funzioni come virtual come nel caso IKS
 class VL6180X : public RangeSensor, public LightSensor 
 {
  public:
     /** Constructor
      * @param[in] i2c device I2C to be used for communication
      * @param[in] digital out pin/STMPE1600DigiOut pin to be used for GPIO expander communication
-     * @param[in] device address, 0x29 by default 
-     * @param[in] device id, 0 by default
+     * @param[in] gpio1 pin
+     * @param[in] device address, 0x29 by default  
      */
-		 VL6180X(DevI2C &i2c, DigitalOut &pin, /*PinName pin_gpio1,*/ uint8_t DevAddr=DEFAULT_DEVICE_ADDRESS) : RangeSensor(), LightSensor(), dev_i2c(i2c), gpio0(&pin)
+		 VL6180X(DevI2C &i2c, DigitalOut &pin, PinName pin_gpio1, uint8_t DevAddr=DEFAULT_DEVICE_ADDRESS) : RangeSensor(), LightSensor(), dev_i2c(i2c), gpio0(&pin), interrupt_measure(pin_gpio1)
 		 {
 			  MyDevice.I2cAddr=DevAddr;		 
         MyDevice.Present=0;
         MyDevice.Ready=0;
         Device=&MyDevice;;
 				expgpio0=NULL;
-			  //free_fall=new InterruptIn(pin_gpio1);
 		 }  
 		
-     VL6180X(DevI2C &i2c, STMPE1600DigiOut &pin, /*PinName pin_gpio1,*/ uint8_t DevAddr=DEFAULT_DEVICE_ADDRESS) : RangeSensor(), LightSensor(), dev_i2c(i2c), expgpio0(&pin)
+     VL6180X(DevI2C &i2c, STMPE1600DigiOut &pin, PinName pin_gpio1, uint8_t DevAddr=DEFAULT_DEVICE_ADDRESS) : RangeSensor(), LightSensor(), dev_i2c(i2c), expgpio0(&pin), interrupt_measure(pin_gpio1)
 		 {
 			  MyDevice.I2cAddr=DevAddr;		 
         MyDevice.Present=0;
         MyDevice.Ready=0;
         Device=&MyDevice;
-			  gpio0=NULL;			 
-        //free_fall=new InterruptIn(pin_gpio1);			 
-		 }  
-		 
+			  gpio0=NULL;			 		 
+		 }  	 
     
    /** Destructor
     */
-    //~VL6180X(){} 
-		 
+    //~VL6180X(){} 		 
 		 
 		 void VL6180x_On(void) {
 			if (gpio0) *gpio0=1;
@@ -101,54 +129,91 @@
 			if (gpio0) *gpio0=0;
 			else if (expgpio0) *expgpio0=0;			
 		}
-    
-		int InitSensor(uint8_t NewAddr) 
-		{
-		   int status;
-	  
-       VL6180x_Off();
-       VL6180x_On();
-	     status=IsPresent();
-	     if(!status)
-	     {
-		     Device->Present=1;
-		     status=Init();
-         if(status)
-			      error("Failed to init VL6180X sensor!\n");
-         status=Prepare();
-         if(status)
-			      error("Failed to prepare VL6180X!\n");
-	       status=SetI2CAddress(NewAddr);
-		     if(status)
-			      error("Failed to change I2C address!\n");
-		     Device->Ready=1;
-	     }
-			 return status;
-		}
-    
-    int Init() 
-    {
-       return VL6180x_InitData(Device); // ritorna 0 se corretto 
-    }
-		
+ 
 		int IsPresent()
 		{
 			 int status;
 			
 			 status=ReadID();
-       if(!status)
-				 error("Failed to read ID device! Device not present!\n");
+       if(status)
+				 printf("Failed to read ID device! Device not present!\n"); //FIXME da sistemare la funzione di stampa errore ErrLog da platform.h
 			 return status;
 		}
 		
-		void SetPresent()
+		int InitSensor(uint8_t NewAddr);	
+		
+		int StartMeasurement(OperatingMode operating_mode, void (*fptr)(void), MeasureData_t *Data); 
+		
+		int GetRangeError(MeasureData_t *Data, VL6180x_RangeData_t RangeData);
+		
+		int GetAlsError(MeasureData_t *Data, VL6180x_AlsData_t AlsData);
+		
+		int RangeMeasPollSingleShot(MeasureData_t *Data);
+		
+		int AlsMeasPollSingleShot(MeasureData_t *Data);
+				
+		int AlsStartContinuousMode()
 		{
-			 Device->Present=1;
+			 return VL6180x_AlsSetSystemMode(Device, MODE_START_STOP|MODE_CONTINUOUS);
 		}
 		
-		void SetReady()
+		int RangeMeasPollContinuousMode(MeasureData_t *Data);
+		
+		int AlsMeasPollContinuousMode(MeasureData_t *Data);
+		
+		int GetRangeMeasContinuousMode(MeasureData_t *Data);
+		
+		int GetAlsMeasContinuousMode(MeasureData_t *Data);
+		
+		int RangeMeasIntContinuousMode(void (*fptr)(void));
+		
+		int AlsMeasIntContinuousMode(void (*fptr)(void));
+		
+		int InterleavedMode(void (*fptr)(void));
+		
+		int StartInterleavedMode();
+
+		/* handling functions of the interrupt_measure */
+		
+		/** Attach a function to call when an interrupt is detected, i.e. measurement is ready
+	  *
+	  *  @param[in] fptr A pointer to a void function, or 0 to set as none
+	  */
+	  void AttachInterruptMeasureDetectionIRQ(void (*fptr)(void))
 		{
-			 Device->Ready=1;
+		  interrupt_measure.rise(fptr);
+	  }
+
+	  /** Enable interrupt measure IRQ
+	  */
+	  void EnableInterruptMeasureDetectionIRQ(void) 
+		{
+		  interrupt_measure.enable_irq();
+	  }
+
+	  /** Disable interrupt measure IRQ
+	  */
+	  void DisableInterruptMeasureDetectionIRQ(void) 
+		{
+		  interrupt_measure.disable_irq();
+	  }
+		
+		void HandleIRQ(MeasureType measure_type, MeasureData_t *Data); // FIXME sistemare la sequenza delle funzioni completandola con i print degli errori
+		
+		/* Wrapper functions */	
+		int WaitDeviceBooted()
+		{
+			 return VL6180x_WaitDeviceBooted(Device);
+		}
+		
+		int Init() 
+    {
+       return VL6180x_InitData(Device);
+    }
+		
+		int SetupGPIO1(uint8_t InitFunction, int ActiveHigh)
+		{
+			 return VL6180x_SetupGPIO1(Device, InitFunction, ActiveHigh);
 		}
 		
 		int Prepare()
@@ -156,6 +221,201 @@
 			 return VL6180x_Prepare(Device);
 		}
 		
+		int RangeStartContinuousMode()
+		{
+			 return VL6180x_RangeStartContinuousMode(Device);
+		}
+		
+		int RangeStartSingleShot()
+		{
+			return VL6180x_RangeStartSingleShot(Device);
+		}
+		
+		int RangeSetMaxConvergenceTime(uint8_t MaxConTime_msec)
+		{
+			 return VL6180x_RangeSetMaxConvergenceTime(Device, MaxConTime_msec);
+		}
+		
+		int RangePollMeasurement(VL6180x_RangeData_t *pRangeData)
+		{
+			 return VL6180x_RangePollMeasurement(Device, pRangeData);
+		}
+		
+		int RangeGetMeasurementIfReady(VL6180x_RangeData_t *pRangeData)
+		{
+		   return VL6180x_RangeGetMeasurementIfReady(Device, pRangeData);
+		}
+		
+		int RangeGetMeasurement(VL6180x_RangeData_t *pRangeData)
+		{
+			 return VL6180x_RangeGetMeasurement(Device, pRangeData);
+		}
+		
+		int GetRange(int32_t *piData)
+		{
+			 return VL6180x_RangeGetResult(Device, piData);
+		}
+		
+		int RangeConfigInterrupt(uint8_t ConfigGpioInt)
+		{
+			 return VL6180x_RangeConfigInterrupt(Device, ConfigGpioInt);
+		}
+		
+		int RangeGetInterruptStatus(uint8_t *pIntStatus)
+		{
+			 return VL6180x_RangeGetInterruptStatus(Device, pIntStatus);
+		}
+		
+		int AlsPollMeasurement(VL6180x_AlsData_t *pAlsData)
+		{
+			 return VL6180x_AlsPollMeasurement(Device, pAlsData);
+		}
+		
+		int AlsGetMeasurement(VL6180x_AlsData_t *pAlsData)
+		{
+			 return VL6180x_AlsGetMeasurement(Device, pAlsData);
+		}
+	
+		int AlsConfigInterrupt(uint8_t ConfigGpioInt)
+		{
+			 return VL6180x_AlsConfigInterrupt(Device, ConfigGpioInt);
+		}
+		
+		int AlsSetIntegrationPeriod(uint16_t period_ms)
+		{
+       return VL6180x_AlsSetIntegrationPeriod(Device, period_ms);	
+		}
+		
+		int AlsSetInterMeasurementPeriod(uint16_t intermeasurement_period_ms)
+		{
+       return VL6180x_AlsSetInterMeasurementPeriod(Device, intermeasurement_period_ms);
+    }
+
+    int AlsSetAnalogueGain(uint8_t gain)
+		{
+			 return VL6180x_AlsSetAnalogueGain(Device, gain);
+		}
+		
+		int AlsSetThresholds(uint8_t low, uint8_t high)
+		{
+			 return VL6180x_AlsSetThresholds(Device, low, high);
+		}
+
+    int AlsGetInterruptStatus(uint8_t *pIntStatus)
+		{
+       return VL6180x_AlsGetInterruptStatus(Device, pIntStatus);
+    }
+
+    int StaticInit()
+		{
+			 return VL6180x_StaticInit(Device);
+		}
+		
+		int RangeWaitDeviceReady(int MaxLoop )
+		{
+			 return VL6180x_RangeWaitDeviceReady(Device, MaxLoop);
+		}
+		
+		int RangeSetInterMeasPeriod(uint32_t  InterMeasTime_msec)
+		{
+			 return VL6180x_RangeSetInterMeasPeriod(Device, InterMeasTime_msec);
+	  }
+		
+		int UpscaleSetScaling(uint8_t scaling)
+		{
+			 return VL6180x_UpscaleSetScaling(Device, scaling);
+		}
+		
+		int UpscaleGetScaling()
+		{
+			 return VL6180x_UpscaleGetScaling(Device);
+		}
+		
+		uint16_t GetUpperLimit()
+		{
+			 return VL6180x_GetUpperLimit(Device);
+		}
+		
+		int RangeSetThresholds(uint16_t low, uint16_t high, int SafeHold)
+		{
+			 return VL6180x_RangeSetThresholds(Device, low, high, SafeHold);
+		}
+
+		int RangeGetThresholds(uint16_t *low, uint16_t *high)
+		{
+			 return VL6180x_RangeGetThresholds(Device, low, high);
+		}
+			
+		int RangeSetRawThresholds(uint8_t low, uint8_t high)
+		{
+			 return VL6180x_RangeSetRawThresholds(Device, low, high);
+		}
+		
+		int RangeSetEceFactor(uint16_t  FactorM, uint16_t FactorD)
+		{
+			 return VL6180x_RangeSetEceFactor(Device, FactorM, FactorD);
+		}
+		
+		int RangeSetEceState(int enable)
+		{
+			 return VL6180x_RangeSetEceState(Device, enable);
+		}
+			
+		int FilterSetState(int state)
+		{
+			 return VL6180x_FilterSetState(Device, state);
+		}
+			
+		int FilterGetState()
+		{
+			 return VL6180x_FilterGetState(Device);
+		}
+		
+		int DMaxSetState(int state)
+		{
+			 return VL6180x_DMaxSetState(Device, state);
+		}
+		
+		int DMaxGetState()
+		{
+			 return VL6180x_DMaxGetState(Device);
+		}
+		
+		int RangeSetSystemMode(uint8_t mode)
+		{
+			 return VL6180x_RangeSetSystemMode(Device, mode);
+		}
+		
+		int8_t GetOffsetCalibrationData()
+		{
+			 return VL6180x_GetOffsetCalibrationData(Device);
+		}
+		
+		void SetOffsetCalibrationData(int8_t offset)
+		{
+			 return VL6180x_SetOffsetCalibrationData(Device, offset);
+		}
+		
+		int SetXTalkCompensationRate(FixPoint97_t Rate)
+		{
+			 return VL6180x_SetXTalkCompensationRate(Device, Rate);
+		}
+		
+		int AlsWaitDeviceReady(int MaxLoop)
+		{
+			 return VL6180x_AlsWaitDeviceReady(Device, MaxLoop);
+		}
+		
+		int AlsSetSystemMode(uint8_t mode)
+		{
+			 return VL6180x_AlsSetSystemMode(Device, mode);
+		}
+
+		int SetGroupParamHold(int Hold)
+		{
+			 return VL6180x_SetGroupParamHold(Device, Hold);
+		}		
+		
 		int SetI2CAddress(int NewAddr)
 		{
 			 int status;
@@ -166,46 +426,43 @@
 			 return status;
 		}
 		
-		int StartMeasurement(int operating_mode)
+		int SetupGPIOx(int pin, uint8_t IntFunction, int ActiveHigh)
 		{
-		  int status;
-	
-	    switch(operating_mode)
-	    {
-		     case(1):
-			     return VL6180x_RangePollMeasurement(Device, &RangeData);
-         case(2):
-			     return VL6180x_AlsPollMeasurement(Device, &AlsData);
-         case(3): break;		
-		     case(4): break;
-	       case(5): break;
-	       case(6): break;
-		     case(7): break;
-		     default:
-			     return INVALID_PARAMS;
-	    }
-	  }
-    /*
-    int GetRange(int *piData) {
-        return VL6180X_RangeGetMeasurement(piData);
-    }
-
-    int GetLight(int *piData) {
-        return VL6180X_AlsGetMeasurement(piData);
-    }*/
-		
-		int RangePollMeasurement()
-		{
-			 return VL6180x_RangePollMeasurement(Device, &RangeData);
+			 return VL6180x_SetupGPIOx(Device, pin, IntFunction, ActiveHigh);
 		}
 		
-		int AlsPollMeasurement()
+		int SetGPIOxPolarity(int pin, int active_high)
+		{
+			 return VL6180x_SetGPIOxPolarity(Device, pin, active_high);
+		}
+		 
+		int SetGPIOxFunctionality(int pin, uint8_t functionality)
 		{
-			 return VL6180x_AlsPollMeasurement(Device, &AlsData);
+			 return VL6180x_SetGPIOxFunctionality(Device, pin, functionality);
+		}
+	
+		int DisableGPIOxOut(int pin)
+		{
+			 return VL6180x_DisableGPIOxOut(Device, pin);
 		}
 		
-		    
-		/* api.c functions */
+		int GetInterruptStatus(uint8_t *status)
+		{
+			 return VL6180x_GetInterruptStatus(Device, status);
+		}
+		
+		int ClearInterrupt(uint8_t IntClear)
+		{
+			 return VL6180x_ClearInterrupt(Device, IntClear );
+		}
+		
+		int GetLight(uint32_t *piData)
+		{
+		   return VL6180x_AlsGetLux(Device, piData);
+	  }
+		
+		
+		/* api.h functions */
 		int VL6180x_WaitDeviceBooted(VL6180xDev_t dev);
 		int VL6180x_InitData(VL6180xDev_t dev );
 		int VL6180x_SetupGPIO1(VL6180xDev_t dev, uint8_t IntFunction, int ActiveHigh);
@@ -256,6 +513,8 @@
 		int VL6180x_DisableGPIOxOut(VL6180xDev_t dev, int pin);
 		int VL6180x_GetInterruptStatus(VL6180xDev_t dev, uint8_t *status);
 		int VL6180x_ClearInterrupt(VL6180xDev_t dev, uint8_t IntClear );
+		
+		/*  Other functions defined in api.c */
 		int VL6180x_RangeStaticInit(VL6180xDev_t dev); 
 		int VL6180x_UpscaleRegInit(VL6180xDev_t dev);
 		int VL6180x_UpscaleStaticInit(VL6180xDev_t dev); 
@@ -292,15 +551,11 @@
     DigitalOut *gpio0;
     /* GPIO expander */
     STMPE1600DigiOut *expgpio0;
-    /* Input interrupt */
-    //InterruptIn *free_fall;
+    /* Measure detection IRQ */
+    InterruptIn interrupt_measure;
     /* Device data */
     MyVL6180Dev_t MyDevice;
     VL6180xDev_t Device;  
-    /* Device range data */
-    VL6180x_RangeData_t RangeData;
-    /* Device als data */
-    VL6180x_AlsData_t AlsData;
 };
 
 #endif // __VL6180X_CLASS_H