Revision 14:9a54b1b65bc8, committed 2018-12-16

Comitter:

pathfindr

Date:

Sun Dec 16 21:34:52 2018 +0000

Parent:

13:29f67f256709

Child:

15:7aad9a7f970c

Commit message:

reduction of lis3dh lib

Changed in this revision

--- a/LIS3DH.h	Sun Dec 16 15:21:38 2018 +0000
+++ b/LIS3DH.h	Sun Dec 16 21:34:52 2018 +0000
@@ -450,66 +450,67 @@
     
     //own functions 
     u8_t InitLIS3DH(LIS3DH_Mode_t Mode, LIS3DH_ODR_t Odr, LIS3DH_Fullscale_t Grange);
-    u8_t SetLIS3DHActivityDetection(uint8_t Th, LIS3DH_Int1Mode_t Mode, uint8_t OnOff);
+    //u8_t SetLIS3DHActivityDetection(uint8_t Th, LIS3DH_Int1Mode_t Mode, uint8_t OnOff);
     
     //Sensor Configuration Functions
-    status_t LIS3DH_SetODR(LIS3DH_ODR_t ov);
-    status_t LIS3DH_SetMode(LIS3DH_Mode_t md);
-    status_t LIS3DH_SetAxis(LIS3DH_Axis_t axis);
-    status_t LIS3DH_SetFullScale(LIS3DH_Fullscale_t fs);
-    status_t LIS3DH_SetBDU(State_t bdu);
-    status_t LIS3DH_SetBLE(LIS3DH_Endianess_t ble);
+    //status_t LIS3DH_SetODR(LIS3DH_ODR_t ov);
+    //status_t LIS3DH_SetMode(LIS3DH_Mode_t md);
+    //status_t LIS3DH_SetAxis(LIS3DH_Axis_t axis);
+    //status_t LIS3DH_SetFullScale(LIS3DH_Fullscale_t fs);
+    //status_t LIS3DH_SetBDU(State_t bdu);
+    //status_t LIS3DH_SetBLE(LIS3DH_Endianess_t ble);
     status_t LIS3DH_SetSelfTest(LIS3DH_SelfTest_t st);
     status_t LIS3DH_SetTemperature(State_t state);
-    status_t LIS3DH_SetADCAux(State_t state);
+    //status_t LIS3DH_SetADCAux(State_t state);
 
-  //Filtering Functions
-  status_t LIS3DH_HPFClickEnable(State_t hpfe);
-  status_t LIS3DH_HPFAOI1Enable(State_t hpfe);
-  status_t LIS3DH_HPFAOI2Enable(State_t hpfe);
-  status_t LIS3DH_SetHPFMode(LIS3DH_HPFMode_t hpf);
-  status_t LIS3DH_SetHPFCutOFF(LIS3DH_HPFCutOffFreq_t hpf);
-  status_t LIS3DH_SetFilterDataSel(State_t state);
+    //Filtering Functions
+    //status_t LIS3DH_HPFClickEnable(State_t hpfe);
+    //status_t LIS3DH_HPFAOI1Enable(State_t hpfe);
+    //status_t LIS3DH_HPFAOI2Enable(State_t hpfe);
+    //status_t LIS3DH_SetHPFMode(LIS3DH_HPFMode_t hpf);
+    //status_t LIS3DH_SetHPFCutOFF(LIS3DH_HPFCutOffFreq_t hpf);
+    //status_t LIS3DH_SetFilterDataSel(State_t state);
 
     //Interrupt Functions
-    status_t LIS3DH_SetInt1Pin(LIS3DH_IntPinConf_t pinConf);
-    status_t LIS3DH_SetInt2Pin(LIS3DH_IntPinConf_t pinConf);
-  status_t LIS3DH_IntLatchEnable(State_t latch);
+    //status_t LIS3DH_SetInt1Pin(LIS3DH_IntPinConf_t pinConf);
+    //status_t LIS3DH_SetInt2Pin(LIS3DH_IntPinConf_t pinConf);
+    status_t LIS3DH_IntLatchEnable(State_t latch);
     status_t LIS3DH_ResetInt1Latch(void);
     status_t LIS3DH_ResetInt2Latch(void);
-    status_t LIS3DH_SetIntConfiguration(LIS3DH_Int1Conf_t ic);
-    status_t LIS3DH_SetInt1Threshold(u8_t ths);
-  status_t LIS3DH_SetInt1Duration(LIS3DH_Int1Conf_t id);
-    status_t LIS3DH_SetIntMode(LIS3DH_Int1Mode_t ic);
-  status_t LIS3DH_SetClickCFG(u8_t status);
-    status_t LIS3DH_SetClickTHS(u8_t ths);
-    status_t LIS3DH_SetClickLIMIT(u8_t t_limit);
-    status_t LIS3DH_SetClickLATENCY(u8_t t_latency);
-    status_t LIS3DH_SetClickWINDOW(u8_t t_window);
-  status_t LIS3DH_SetInt6D4DConfiguration(LIS3DH_INT_6D_4D_t ic);
-  status_t LIS3DH_GetInt1Src(u8_t* val);
-  status_t LIS3DH_GetInt1SrcBit(u8_t statusBIT, u8_t* val);
+    //status_t LIS3DH_SetIntConfiguration(LIS3DH_Int1Conf_t ic);
+    //status_t LIS3DH_SetInt1Threshold(u8_t ths);
+    //status_t LIS3DH_SetInt1Duration(LIS3DH_Int1Conf_t id);
+    //status_t LIS3DH_SetIntMode(LIS3DH_Int1Mode_t ic);
+    //status_t LIS3DH_SetClickCFG(u8_t status);
+    //status_t LIS3DH_SetClickTHS(u8_t ths);
+    //status_t LIS3DH_SetClickLIMIT(u8_t t_limit);
+    //status_t LIS3DH_SetClickLATENCY(u8_t t_latency);
+    //status_t LIS3DH_SetClickWINDOW(u8_t t_window);
+    //status_t LIS3DH_SetInt6D4DConfiguration(LIS3DH_INT_6D_4D_t ic);
+    status_t LIS3DH_GetInt1Src(u8_t* val);
+    status_t LIS3DH_GetInt2Src(u8_t* val);
+    //status_t LIS3DH_GetInt1SrcBit(u8_t statusBIT, u8_t* val);
 
-  //FIFO Functions
-  status_t LIS3DH_FIFOModeEnable(LIS3DH_FifoMode_t fm);
-  status_t LIS3DH_SetWaterMark(u8_t wtm);
-  status_t LIS3DH_SetTriggerInt(LIS3DH_TrigInt_t tr);
-  status_t LIS3DH_GetFifoSourceReg(u8_t* val);
-  status_t LIS3DH_GetFifoSourceBit(u8_t statusBIT, u8_t* val);
-  status_t LIS3DH_GetFifoSourceFSS(u8_t* val);
+    //FIFO Functions
+    //status_t LIS3DH_FIFOModeEnable(LIS3DH_FifoMode_t fm);
+    //status_t LIS3DH_SetWaterMark(u8_t wtm);
+    //status_t LIS3DH_SetTriggerInt(LIS3DH_TrigInt_t tr);
+    //status_t LIS3DH_GetFifoSourceReg(u8_t* val);
+    //status_t LIS3DH_GetFifoSourceBit(u8_t statusBIT, u8_t* val);
+    //status_t LIS3DH_GetFifoSourceFSS(u8_t* val);
 
     //Other Reading Functions   
-  status_t LIS3DH_GetStatusReg(u8_t* val);
-  status_t LIS3DH_GetStatusBit(u8_t statusBIT, u8_t* val);
-  status_t LIS3DH_GetStatusAUXBit(u8_t statusBIT, u8_t* val);
-  status_t LIS3DH_GetStatusAUX(u8_t* val);
+    //status_t LIS3DH_GetStatusReg(u8_t* val);
+    //status_t LIS3DH_GetStatusBit(u8_t statusBIT, u8_t* val);
+    //status_t LIS3DH_GetStatusAUXBit(u8_t statusBIT, u8_t* val);
+    //status_t LIS3DH_GetStatusAUX(u8_t* val);
 
     status_t LIS3DH_GetAccAxesRaw(AxesRaw_t* buff);
-  status_t LIS3DH_GetAuxRaw(LIS3DH_Aux123Raw_t* buff);
-  status_t LIS3DH_GetClickResponse(u8_t* val);
+    status_t LIS3DH_GetAuxRaw(LIS3DH_Aux123Raw_t* buff);
+    //status_t LIS3DH_GetClickResponse(u8_t* val);
     status_t LIS3DH_GetTempRaw(i8_t* val);
     status_t LIS3DH_GetWHO_AM_I(u8_t* val);
-  status_t LIS3DH_Get6DPosition(u8_t* val);
+    status_t LIS3DH_Get6DPosition(u8_t* val);
   
     u8_t LIS3DH_ReadReg(u8_t Reg, u8_t* Data);
     u8_t LIS3DH_WriteReg(u8_t WriteAddr, u8_t Data);
@@ -517,11 +518,10 @@
 private:
 
         
-    
 protected:
     SPI _spi;
     DigitalOut _ss;
-  
+    
 };
 } //Namespace
 #endif

--- a/LISD3H.cpp	Sun Dec 16 15:21:38 2018 +0000
+++ b/LISD3H.cpp	Sun Dec 16 21:34:52 2018 +0000
@@ -9,6 +9,7 @@
     _spi.frequency(4000000);
 }
 
+/*
 u8_t LIS3DH::InitLIS3DH(LIS3DH_Mode_t Mode, LIS3DH_ODR_t Odr, LIS3DH_Fullscale_t Grange)
 {
     uint8_t response;
@@ -29,6 +30,7 @@
     
     return response;
 }
+*/
 
 
 /*******************************************************************************
@@ -37,7 +39,7 @@
 * Input          : Char to empty by status register buffer
 * Output         : None
 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
-*******************************************************************************/
+*******************************************************************************
 status_t LIS3DH::LIS3DH_GetStatusAUX(u8_t* val) {
   
   if( !LIS3DH_ReadReg(LIS3DH_STATUS_AUX, val) )
@@ -45,6 +47,7 @@
   
   return MEMS_SUCCESS;  
 }
+*/
 
 /*******************************************************************************
 * Function Name  : LIS3DH_GetStatusAUXBIT
@@ -53,7 +56,7 @@
                    LIS3DH_STATUS_AUX_321DA, LIS3DH_STATUS_AUX_3DA, LIS3DH_STATUS_AUX_2DA, LIS3DH_STATUS_AUX_1DA
 * Output         : None
 * Return         : Status of BIT [MEMS_ERROR, MEMS_SUCCESS]
-*******************************************************************************/
+*******************************************************************************
 status_t LIS3DH::LIS3DH_GetStatusAUXBit(u8_t statusBIT, u8_t* val) {
   u8_t value;  
   
@@ -149,7 +152,9 @@
   }  
   return MEMS_ERROR;
 }
+*/
 
+/*
 u8_t LIS3DH::SetLIS3DHActivityDetection(uint8_t Th, LIS3DH_Int1Mode_t Mode, uint8_t OnOff)
 {
     uint8_t response;
@@ -180,6 +185,7 @@
     
     return response;
 }
+*/
 
 /*******************************************************************************
 * Function Name  : LIS3DH_SetODR
@@ -187,7 +193,7 @@
 * Input          : Output Data Rate
 * Output         : None
 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
-*******************************************************************************/
+*******************************************************************************
 status_t LIS3DH::LIS3DH_SetODR(LIS3DH_ODR_t ov){
   u8_t value;
   
@@ -202,6 +208,7 @@
   
   return MEMS_SUCCESS;
 }
+*/
 
 /*******************************************************************************
 * Function Name  : LIS3DH_SetMode
@@ -209,7 +216,7 @@
 * Input          : Modality (LIS3DH_NORMAL, LIS3DH_LOW_POWER, LIS3DH_POWER_DOWN)
 * Output         : None
 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
-*******************************************************************************/
+*******************************************************************************
 status_t LIS3DH::LIS3DH_SetMode(LIS3DH_Mode_t md) {
   u8_t value;
   u8_t value2;
@@ -257,6 +264,7 @@
   
   return MEMS_SUCCESS;
 }
+*/
 
 /*******************************************************************************
 * Function Name  : LIS3DH_SetAxis
@@ -265,7 +273,7 @@
 * Output         : None
 * Note           : You MUST use all input variable in the argument, as example
 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
-*******************************************************************************/
+*******************************************************************************
 status_t LIS3DH::LIS3DH_SetAxis(LIS3DH_Axis_t axis) {
   u8_t value;
   
@@ -279,6 +287,7 @@
   
   return MEMS_SUCCESS;
 }
+*/
 
 /*******************************************************************************
 * Function Name  : LIS3DH_SetFullScale
@@ -286,7 +295,7 @@
 * Input          : LIS3DH_FULLSCALE_2/LIS3DH_FULLSCALE_4/LIS3DH_FULLSCALE_8/LIS3DH_FULLSCALE_16
 * Output         : None
 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
-*******************************************************************************/
+*******************************************************************************
 status_t LIS3DH::LIS3DH_SetFullScale(LIS3DH_Fullscale_t fs) {
   u8_t value;
   
@@ -301,6 +310,7 @@
   
   return MEMS_SUCCESS;
 }
+*/
 
 /*******************************************************************************
 * Function Name  : LIS3DH_SetBDU
@@ -308,7 +318,7 @@
 * Input          : ENABLE/DISABLE
 * Output         : None
 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
-*******************************************************************************/
+*******************************************************************************
 status_t LIS3DH::LIS3DH_SetBDU(State_t bdu) {
   u8_t value;
   
@@ -323,6 +333,7 @@
   
   return MEMS_SUCCESS;
 }
+*/
 
 /*******************************************************************************
 * Function Name  : LIS3DH_SetBLE
@@ -330,7 +341,7 @@
 * Input          : BLE_LSB / BLE_MSB
 * Output         : None
 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
-*******************************************************************************/
+*******************************************************************************
 status_t LIS3DH::LIS3DH_SetBLE(LIS3DH_Endianess_t ble) {
   u8_t value;
   
@@ -345,6 +356,7 @@
   
   return MEMS_SUCCESS;
 }
+*/
 
 /*******************************************************************************
 * Function Name  : LIS3DH_SetSelfTest
@@ -374,7 +386,7 @@
 * Input          : MEMS_ENABLE/MEMS_DISABLE
 * Output         : None
 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
-*******************************************************************************/
+*******************************************************************************
 status_t LIS3DH::LIS3DH_HPFClickEnable(State_t hpfe) {
   u8_t value;
   
@@ -389,7 +401,7 @@
   
   return MEMS_SUCCESS;
 }
-
+*/
 
 /*******************************************************************************
 * Function Name  : LIS3DH_HPFAOI1
@@ -397,7 +409,7 @@
 * Input          : MEMS_ENABLE/MEMS_DISABLE
 * Output         : None
 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
-*******************************************************************************/
+*******************************************************************************
 status_t LIS3DH::LIS3DH_HPFAOI1Enable(State_t hpfe) {
   u8_t value;
   
@@ -412,7 +424,7 @@
   
   return MEMS_SUCCESS;
 }
-
+*/
 
 /*******************************************************************************
 * Function Name  : LIS3DH_HPFAOI2
@@ -420,7 +432,7 @@
 * Input          : MEMS_ENABLE/MEMS_DISABLE
 * Output         : None
 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
-*******************************************************************************/
+*******************************************************************************
 status_t LIS3DH::LIS3DH_HPFAOI2Enable(State_t hpfe) {
   u8_t value;
   
@@ -435,6 +447,7 @@
   
   return MEMS_SUCCESS;
 }
+*/
 
 /*******************************************************************************
 * Function Name  : LIS3DH_SetHPFMode
@@ -443,7 +456,7 @@
            LIS3DH_HPM_NORMAL_MODE/LIS3DH_HPM_AUTORESET_INT
 * Output         : None
 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
-*******************************************************************************/
+*******************************************************************************
 status_t LIS3DH::LIS3DH_SetHPFMode(LIS3DH_HPFMode_t hpm) {
   u8_t value;
   
@@ -458,6 +471,7 @@
   
   return MEMS_SUCCESS;
 }
+*/
 
 
 /*******************************************************************************
@@ -466,7 +480,7 @@
 * Input          : HPFCF [0,3]
 * Output         : None
 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
-*******************************************************************************/
+*******************************************************************************
 status_t LIS3DH::LIS3DH_SetHPFCutOFF(LIS3DH_HPFCutOffFreq_t hpf) {
   u8_t value;
   
@@ -483,8 +497,8 @@
     return MEMS_ERROR;
   
   return MEMS_SUCCESS;
-  
 }
+*/
 
 /*******************************************************************************
 * Function Name  : LIS3DH_SetFilterDataSel
@@ -492,7 +506,7 @@
 * Input          : MEMS_SET, MEMS_RESET
 * Output         : None
 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
-*******************************************************************************/
+*******************************************************************************
 status_t LIS3DH::LIS3DH_SetFilterDataSel(State_t state) {
   u8_t value;
   
@@ -506,8 +520,8 @@
     return MEMS_ERROR;
   
   return MEMS_SUCCESS;
-  
 }
+*/
 
 /*******************************************************************************
 * Function Name  : LIS3DH_SetTemperature
@@ -539,7 +553,7 @@
 * Input          : MEMS_ENABLE, MEMS_DISABLE
 * Output         : None
 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
-*******************************************************************************/
+*******************************************************************************
 status_t LIS3DH::LIS3DH_SetADCAux(State_t state){
   u8_t value;
   
@@ -554,6 +568,7 @@
   
   return MEMS_SUCCESS;
 }
+*/
 
 /*******************************************************************************
 * Function Name  : LIS3DH_GetAuxRaw
@@ -561,7 +576,7 @@
 * Input          : Buffer to empty
 * Output         : Aux Values Registers buffer
 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
-*******************************************************************************/
+*******************************************************************************
 status_t LIS3DH::LIS3DH_GetAuxRaw(LIS3DH_Aux123Raw_t* buff) {
   u8_t valueL;
   u8_t valueH;
@@ -592,6 +607,7 @@
   
   return MEMS_SUCCESS;  
 }
+*/
 
 /*******************************************************************************
 * Function Name  : LIS3DH_SetInt1Pin
@@ -606,7 +622,7 @@
 * Note           : To enable Interrupt signals on INT1 Pad (You MUST use all input variable in the argument, as example)
 * Output         : None
 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
-*******************************************************************************/
+*******************************************************************************
 status_t LIS3DH::LIS3DH_SetInt1Pin(LIS3DH_IntPinConf_t pinConf) {
   u8_t value;
   
@@ -621,6 +637,7 @@
   
   return MEMS_SUCCESS;
 }
+*/
 
 
 /*******************************************************************************
@@ -635,7 +652,7 @@
 * Note           : To enable Interrupt signals on INT2 Pad (You MUST use all input variable in the argument, as example)
 * Output         : None
 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
-*******************************************************************************/
+*******************************************************************************
 status_t LIS3DH::LIS3DH_SetInt2Pin(LIS3DH_IntPinConf_t pinConf) {
   u8_t value;
   
@@ -650,6 +667,7 @@
   
   return MEMS_SUCCESS;
 }
+*/
 
 /*******************************************************************************
 * Function Name  : LIS3DH_SetClickCFG
@@ -661,7 +679,7 @@
 * Note           : You MUST use all input variable in the argument, as example
 * Output         : None
 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
-*******************************************************************************/
+*******************************************************************************
 status_t LIS3DH::LIS3DH_SetClickCFG(u8_t status) {
   u8_t value;
   
@@ -675,7 +693,8 @@
     return MEMS_ERROR;
   
   return MEMS_SUCCESS;
-}  
+}
+*/
 
 
 /*******************************************************************************
@@ -684,7 +703,7 @@
 * Input          : Click-click Threshold value [0-127]
 * Output         : None
 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
-*******************************************************************************/
+*******************************************************************************
 status_t LIS3DH::LIS3DH_SetClickTHS(u8_t ths) {
   
   if(ths>127)     
@@ -694,7 +713,8 @@
     return MEMS_ERROR;
   
   return MEMS_SUCCESS;
-} 
+}
+*/
 
 
 /*******************************************************************************
@@ -703,7 +723,7 @@
 * Input          : Click-click Time Limit value [0-127]
 * Output         : None
 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
-*******************************************************************************/
+*******************************************************************************
 status_t LIS3DH::LIS3DH_SetClickLIMIT(u8_t t_limit) {
   
   if(t_limit>127)     
@@ -713,7 +733,8 @@
     return MEMS_ERROR;
   
   return MEMS_SUCCESS;
-} 
+}
+*/
 
 
 /*******************************************************************************
@@ -722,7 +743,7 @@
 * Input          : Click-click Time Latency value [0-255]
 * Output         : None
 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
-*******************************************************************************/
+*******************************************************************************
 status_t LIS3DH::LIS3DH_SetClickLATENCY(u8_t t_latency) {
   
   if( !LIS3DH_WriteReg(LIS3DH_TIME_LATENCY, t_latency) )
@@ -730,6 +751,7 @@
   
   return MEMS_SUCCESS;
 } 
+*/
 
 
 /*******************************************************************************
@@ -738,7 +760,7 @@
 * Input          : Click-click Time Window value [0-255]
 * Output         : None
 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
-*******************************************************************************/
+*******************************************************************************
 status_t LIS3DH::LIS3DH_SetClickWINDOW(u8_t t_window) {
   
   if( !LIS3DH_WriteReg(LIS3DH_TIME_WINDOW, t_window) )
@@ -746,6 +768,7 @@
   
   return MEMS_SUCCESS;
 }
+*/
 
 
 /*******************************************************************************
@@ -754,7 +777,7 @@
 * Input          : char to empty by Click Response Typedef
 * Output         : None
 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
-*******************************************************************************/
+*******************************************************************************
 status_t LIS3DH::LIS3DH_GetClickResponse(u8_t* res) {
   u8_t value;
   
@@ -831,6 +854,7 @@
   }
   return MEMS_ERROR;
 } 
+*/
 
 
 /*******************************************************************************
@@ -872,6 +896,7 @@
   return MEMS_SUCCESS;
 }
 
+
 /*******************************************************************************
 * Function Name  : LIS3DH_SetIntConfiguration
 * Description    : Interrupt 1 Configuration (without LIS3DH_6D_INT)
@@ -879,7 +904,7 @@
 * Output         : None
 * Note           : You MUST use all input variable in the argument, as example
 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
-*******************************************************************************/
+*******************************************************************************
 status_t LIS3DH::LIS3DH_SetIntConfiguration(LIS3DH_Int1Conf_t ic) {
   u8_t value;
   
@@ -894,6 +919,7 @@
   
   return MEMS_SUCCESS;
 } 
+*/
 
      
 /*******************************************************************************
@@ -903,7 +929,7 @@
                    LIS3DH_INT_MODE_6D_POSITION
 * Output         : None
 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
-*******************************************************************************/
+*******************************************************************************
 status_t LIS3DH::LIS3DH_SetIntMode(LIS3DH_Int1Mode_t int_mode) {
   u8_t value;
   
@@ -918,6 +944,7 @@
   
   return MEMS_SUCCESS;
 }
+*/
 
 /*******************************************************************************
 * Function Name  : LIS3DH_SetInt6D4DConfiguration
@@ -925,7 +952,7 @@
 * Input          : LIS3DH_INT1_6D_ENABLE, LIS3DH_INT1_4D_ENABLE, LIS3DH_INT1_6D_4D_DISABLE
 * Output         : None
 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
-*******************************************************************************/
+*******************************************************************************
 status_t LIS3DH::LIS3DH_SetInt6D4DConfiguration(LIS3DH_INT_6D_4D_t ic) {
   u8_t value;
   u8_t value2;
@@ -963,6 +990,7 @@
   
   return MEMS_SUCCESS;
 }
+*/
 
 /*******************************************************************************
 * Function Name  : LIS3DH_Get6DPosition
@@ -1009,7 +1037,7 @@
 * Input          : Threshold = [0,31]
 * Output         : None
 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
-*******************************************************************************/
+*******************************************************************************
 status_t LIS3DH::LIS3DH_SetInt1Threshold(u8_t ths) {
   if (ths > 127)
     return MEMS_ERROR;
@@ -1019,6 +1047,7 @@
   
   return MEMS_SUCCESS;
 }
+*/
 
 /*******************************************************************************
 * Function Name  : LIS3DH_SetInt1Duration
@@ -1026,7 +1055,7 @@
 * Input          : Duration value
 * Output         : None
 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
-*******************************************************************************/
+*******************************************************************************
 status_t LIS3DH::LIS3DH_SetInt1Duration(LIS3DH_Int1Conf_t id) {
   
   if (id > 127)
@@ -1037,6 +1066,7 @@
   
   return MEMS_SUCCESS;
 }
+*/
 
 /*******************************************************************************
 * Function Name  : LIS3DH_FIFOModeEnable
@@ -1045,7 +1075,7 @@
            LIS3DH_FIFO_STREAM_MODE, LIS3DH_FIFO_TRIGGER_MODE
 * Output         : None
 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
-*******************************************************************************/
+*******************************************************************************
 status_t LIS3DH::LIS3DH_FIFOModeEnable(LIS3DH_FifoMode_t fm) {
   u8_t value;  
   
@@ -1145,6 +1175,7 @@
   
   return MEMS_SUCCESS;
 }
+*/
 
 /*******************************************************************************
 * Function Name  : LIS3DH_SetTriggerInt
@@ -1152,7 +1183,7 @@
 * Input          : LIS3DH_TRIG_INT1/LIS3DH_TRIG_INT2
 * Output         : None
 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
-*******************************************************************************/
+*******************************************************************************
 status_t LIS3DH::LIS3DH_SetTriggerInt(LIS3DH_TrigInt_t tr) {
   u8_t value;  
   
@@ -1167,6 +1198,7 @@
   
   return MEMS_SUCCESS;
 }
+*/
 
 /*******************************************************************************
 * Function Name  : LIS3DH_SetWaterMark
@@ -1174,7 +1206,7 @@
 * Input          : Watermark = [0,31]
 * Output         : None
 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
-*******************************************************************************/
+*******************************************************************************
 status_t LIS3DH::LIS3DH_SetWaterMark(u8_t wtm) {
   u8_t value;
   
@@ -1192,6 +1224,7 @@
   
   return MEMS_SUCCESS;
 }
+*/
 
 /*******************************************************************************
 * Function Name  : LIS3DH_GetStatusReg
@@ -1199,13 +1232,14 @@
 * Input          : char to empty by Status Reg Value
 * Output         : None
 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
-*******************************************************************************/
+*******************************************************************************
 status_t LIS3DH::LIS3DH_GetStatusReg(u8_t* val) {
   if( !LIS3DH_ReadReg(LIS3DH_STATUS_REG, val) )
     return MEMS_ERROR;
   
   return MEMS_SUCCESS;  
 }
+*/
 
 
 /*******************************************************************************
@@ -1217,7 +1251,7 @@
            val: Byte to be filled with the status bit 
 * Output         : status register BIT
 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
-*******************************************************************************/
+*******************************************************************************
 status_t LIS3DH::LIS3DH_GetStatusBit(u8_t statusBIT, u8_t* val) {
   u8_t value;  
   
@@ -1301,6 +1335,7 @@
   }
   return MEMS_ERROR;
 }
+*/
 
 /*******************************************************************************
 * Function Name  : LIS3DH_GetAccAxesRaw
@@ -1356,6 +1391,21 @@
   return MEMS_SUCCESS;
 }
 
+/*******************************************************************************
+* Function Name  : LIS3DH_GetInt2Src
+* Description    : Reset Interrupt 2 Latching function
+* Input          : Char to empty by Int2 source value
+* Output         : None
+* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t LIS3DH::LIS3DH_GetInt2Src(u8_t* val) {
+  
+  if( !LIS3DH_ReadReg(LIS3DH_INT2_SRC, val) )
+    return MEMS_ERROR;
+  
+  return MEMS_SUCCESS;
+}
+
 
 /*******************************************************************************
 * Function Name  : LIS3DH_GetInt1SrcBit
@@ -1364,7 +1414,7 @@
 *                  val: Byte to be filled with the status bit
 * Output         : None
 * Return         : Status of BIT [MEMS_ERROR, MEMS_SUCCESS]
-*******************************************************************************/
+*******************************************************************************
 status_t LIS3DH::LIS3DH_GetInt1SrcBit(u8_t statusBIT, u8_t* val) {
   u8_t value;  
    
@@ -1448,6 +1498,7 @@
   }
   return MEMS_ERROR;
 }
+*/
 
 
 /*******************************************************************************
@@ -1456,7 +1507,7 @@
 * Input          : Byte to empty by FIFO source register value
 * Output         : None
 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
-*******************************************************************************/
+*******************************************************************************
 status_t LIS3DH::LIS3DH_GetFifoSourceReg(u8_t* val) {
   
   if( !LIS3DH_ReadReg(LIS3DH_FIFO_SRC_REG, val) )
@@ -1464,6 +1515,7 @@
   
   return MEMS_SUCCESS;
 }
+*/
 
 
 /*******************************************************************************
@@ -1473,7 +1525,7 @@
 *          val: Byte to fill  with the bit value
 * Output         : None
 * Return         : Status of BIT [MEMS_ERROR, MEMS_SUCCESS]
-*******************************************************************************/
+*******************************************************************************
 status_t LIS3DH::LIS3DH_GetFifoSourceBit(u8_t statusBIT,  u8_t* val){
   u8_t value;  
   
@@ -1514,7 +1566,7 @@
   }
   return MEMS_ERROR;
 }
-
+*/
 
 /*******************************************************************************
 * Function Name  : LIS3DH_GetFifoSourceFSS
@@ -1522,7 +1574,7 @@
 * Input          : Byte to empty by FIFO unread sample value
 * Output         : None
 * Return         : Status [value of FSS]
-*******************************************************************************/
+*******************************************************************************
 status_t LIS3DH::LIS3DH_GetFifoSourceFSS(u8_t* val){
   u8_t value;
   
@@ -1535,6 +1587,7 @@
   
   return MEMS_SUCCESS;
 }
+*/
 
 /*******************************************************************************
 * Function Name  : LIS3DH_GetTempRaw

--- a/README.md	Sun Dec 16 15:21:38 2018 +0000
+++ b/README.md	Sun Dec 16 21:34:52 2018 +0000
@@ -1,7 +1,7 @@
 MUST DO!!!!!!
 
 1) Add watchdog kicks to modem functions
-
+2) USSDmessage index needs to work
 
 
 

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/acd_nrf52_saadc.cpp	Sun Dec 16 21:34:52 2018 +0000
@@ -0,0 +1,46 @@
+#include "acd_nrf52_saadc.h"
+
+// add and remove analog channels -> +/- maxcnt
+
+NRF52_SAADC::NRF52_SAADC(){
+    NRF_SAADC->ENABLE = 1;
+    memset(data, 0, sizeof(data));
+    NRF_SAADC->RESULT.PTR =(uint32_t)data;
+    NRF_SAADC->RESULT.MAXCNT = 0;
+}
+
+NRF52_SAADC::~NRF52_SAADC(){
+    NRF_SAADC->ENABLE = 0;
+}
+
+void NRF52_SAADC::updateData(){
+    NRF_SAADC->TASKS_START = 1;
+    while(!NRF_SAADC->EVENTS_STARTED);
+    NRF_SAADC->TASKS_SAMPLE = 1;
+    for(uint8_t i = 0; i < NRF_SAADC->RESULT.MAXCNT; ++i)
+    {
+        while(!NRF_SAADC->EVENTS_RESULTDONE);
+        while(!NRF_SAADC->EVENTS_DONE);
+        while(!NRF_SAADC->EVENTS_END);
+        while(NRF_SAADC->STATUS == 1); // while conversion is is progress
+    }
+    NRF_SAADC->TASKS_STOP = 1;
+    while(!NRF_SAADC->EVENTS_STOPPED);
+}
+
+bool NRF52_SAADC::addChannel(uint8_t pin){
+    if(NRF_SAADC->RESULT.MAXCNT < 8)
+    {
+        int channel = NRF_SAADC->RESULT.MAXCNT;
+        NRF_SAADC->CH[channel].PSELP = pin;     // Input positive pin is VDD = 9
+        NRF_SAADC->CH[channel].CONFIG = 0x00020000; // reset
+        NRF_SAADC->RESULT.MAXCNT++;
+        return 0;
+    }
+    return 1;
+}
+
+void NRF52_SAADC::calibrate(){
+    NRF_SAADC->TASKS_CALIBRATEOFFSET = 1;
+    while(!NRF_SAADC->EVENTS_CALIBRATEDONE);
+}
\ No newline at end of file

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/acd_nrf52_saadc.h	Sun Dec 16 21:34:52 2018 +0000
@@ -0,0 +1,38 @@
+/*
+ * Made by Jurica Resetar and Karlo Milicevic @ aconno, 2017
+ * jurica_resetar@yahoo.com
+ * aconno.de  
+ * All rights reserved 
+ *
+ */
+
+#ifndef ACD_NRF52_SAADC_H
+#define ACD_NRF52_SAADC_H
+
+#include "mbed.h"
+
+/** NRF52 adc library 
+ */
+class NRF52_SAADC{
+    public:
+        /** Initializes adc module
+         */
+        NRF52_SAADC();
+        ~NRF52_SAADC();
+        /** @returns
+         *     0 on success, 1 otherwise
+         */
+        bool addChannel(uint8_t pin);
+        void calibrate();
+        /** Reads analog pins
+         */
+        void updateData();
+        /** @returns
+         *     pointer to analog input data - data is stored in channel add order
+         */
+        int16_t *getData() { return data; }
+    private:
+        int16_t data[sizeof(int16_t)*8]; // 8 channels
+};
+ 
+ #endif // ACD_NRF52_SAADC_H
\ No newline at end of file

--- a/board.h	Sun Dec 16 15:21:38 2018 +0000
+++ b/board.h	Sun Dec 16 21:34:52 2018 +0000
@@ -31,5 +31,10 @@
 #define PN_I2C_SDA              P0_26
 #define PN_I2C_SCL              P0_27
 
+//MEMORY FOR DISK
+#define BD_PAGE_SIZE    4096
+#define BD_TOTAL_SIZE   4096 * 35 //must be multiple of 4096
+#define BD_PAGE_ADDRESS 0x5d000 //380928
+
 //NVSTORAGE KEYS
 //#define NV_IDENTIFIER          1
\ No newline at end of file

--- a/filesystem.cpp	Sun Dec 16 15:21:38 2018 +0000
+++ b/filesystem.cpp	Sun Dec 16 21:34:52 2018 +0000
@@ -5,21 +5,18 @@
 #define FILENAME_ACTIVITY "log_activity.txt"
 #define FILENAME_PENDING "pending_broadcasts.txt"
 
+/*
+//SD
 Filesystem::Filesystem(PinName mosi, PinName miso, PinName clk, PinName cs):  bd(mosi,miso,clk,cs), fs("fs")
 {
-    /*int err;
-    DEBUG("Mounting the filesystem... ");
-    fflush(stdout);
-    err = fs.mount(&_bd);
-    DEBUG("%s\n", (err ? "Fail :(" : "OK"));
-    if (err) {
-        // Reformat if we can't mount the filesystem
-        // this should only happen on the first boot
-        DEBUG("No filesystem found, formatting... ");
-        fflush(stdout);
-        err = fs.reformat(&bd);
-        DEBUG("%s\n", (err ? "Fail :(" : "OK"));
-    }*/
+    //do nothing
+}
+*/
+
+//ONBOARD FLASH
+Filesystem::Filesystem(uint16_t page_address, uint16_t total_size):  bd(page_address, total_size), fs("fs")
+{
+    //do nothing   
 }
 
 void Filesystem::addLogEntry_temperature(time_t timestamp, float temperature) 

--- a/filesystem.h	Sun Dec 16 15:21:38 2018 +0000
+++ b/filesystem.h	Sun Dec 16 21:34:52 2018 +0000
@@ -3,19 +3,18 @@
 
 #include "main.h"
 
-#include "SDBlockDevice.h"
-
-//#include "LittleFileSystem.h"
-#include "FATFileSystem.h"
-
-//#define SD_MOUNT_PATH   "sd"
+//#include "SDBlockDevice.h"
+#include "FlashIAPBlockDevice.h"
+#include "LittleFileSystem.h"
+//#include "FATFileSystem.h"
 
 namespace mbed {
     
     class Filesystem
     {
         public:  
-            Filesystem(PinName mosi, PinName miso, PinName clk, PinName cs);
+            //Filesystem(PinName mosi, PinName miso, PinName clk, PinName cs); //SD
+            Filesystem(uint16_t page_address, uint16_t total_size);
             ~Filesystem();
             
             //funcs
@@ -24,9 +23,10 @@
         private:
         
         protected:
-            SDBlockDevice bd;
-            //LittleFileSystem fs;
-            FATFileSystem fs;
+            FlashIAPBlockDevice bd;
+            //SDBlockDevice bd;
+            LittleFileSystem fs;
+            //FATFileSystem fs;
     };
 
 } //Namespace

--- a/main.cpp	Sun Dec 16 15:21:38 2018 +0000
+++ b/main.cpp	Sun Dec 16 21:34:52 2018 +0000
@@ -250,20 +250,52 @@
     }
 }
 
+//------------------------------------------------------------------------------
+// UPDATE OPERATING SETTINGS
+//------------------------------------------------------------------------------ 
+bool saveSettings(char* settingsBuffer) {
+    //process result
+    int matchCount = 0;
+    time_t TEMP_a = 0;
+    int TEMP_b = 0;
+    int TEMP_c = 0;
+    int TEMP_d = 0;
+    int TEMP_e = 0;
+    int TEMP_f = 0;
+    int TEMP_g = 0;
+    int TEMP_h = 0;
+    int TEMP_i = 0;
+    int TEMP_j = 0;
+    int TEMP_k = 0;
+    int TEMP_l = 0;
+    int TEMP_m = 0;
+    int TEMP_n = 0;
+    if ( (matchCount = sscanf(settingsBuffer,"a:%u,b:%d,c:%d,d:%d,e:%d,f:%d,g:%d,h:%d,i:%d,j:%d,k:%d,l:%d,m:%d,n:%d",
+    &TEMP_a,&TEMP_b,&TEMP_c,&TEMP_d,&TEMP_e,&TEMP_f,&TEMP_g,&TEMP_h,&TEMP_i,&TEMP_j,&TEMP_k,&TEMP_l,&TEMP_m,&TEMP_n) ) > 0 ) {
+        DEBUG("VALUES: a:%u,b:%d,c:%d,d:%d,e:%d,f:%d,g:%d,h:%d,i:%d,j:%d,k:%d,l:%d,m:%d,n:%d",TEMP_a,TEMP_b,TEMP_c,TEMP_d,TEMP_e,TEMP_f,TEMP_g,TEMP_h,TEMP_i,TEMP_j,TEMP_k,TEMP_l,TEMP_m,TEMP_n);
+        return true;
+    } else {
+        return false;   
+    }
+}
+
 
 //------------------------------------------------------------------------------
 // SETUP
 //------------------------------------------------------------------------------ 
 bool setup() {
     bool pass = true;
+    
     Modem modem(PN_UART_TX, PN_UART_RX, PN_UART_CTS, PN_UART_RTS, PN_GSM_PWR_KEY, PN_VREG_EN);
     if (modem.on()) {
         RET_imei = modem.getIMEI();
+        GLOBAL_imei = RET_imei;
         DEBUG("imei: %lld \n",RET_imei);
         if (modem.registerOnNetwork(3,60000)) {
                 char* result = modem.USSDmessage("blahblah\0", true, 2);
                 if (result != "err") {
                     DEBUG("result: %s \n",result);
+                    saveSettings(result);
                 }
         } else {
             //modem failed to register on network
@@ -295,6 +327,7 @@
         case MODE_SETUP :
             factoryReset();
             if (setup()) {
+                copyRETtoGLOBAL();
                 RET_mode = MODE_NORMAL;
             }
             break;
@@ -314,7 +347,7 @@
             }
             //Environmental
             if(RET_RTCunixtime > RET_eventTime_environmental_log && RET_eventTime_environmental_log > 0) {
-                Filesystem filesystem(PN_SPI_MOSI,PN_SPI_MISO,PN_SPI_CLK,PN_SPI_CS1);
+                Filesystem filesystem(BD_PAGE_ADDRESS,BD_TOTAL_SIZE);
                 SI7060 temperature(PN_I2C_SDA,PN_I2C_SCL);
                 float temperature_c = temperature.getTemperature();
                 DEBUG("Temperature log: %u,%f \n", RET_RTCunixtime,temperature_c);
@@ -383,6 +416,7 @@
     //CHECK FOR FIRST BOOT
     if (RET_coldBoot != 0) factoryReset();
     
+    //COPY ESSENTIAL VALUES FROM RET TO GLOBAL
     copyRETtoGLOBAL();
     
     while(true) {
@@ -395,11 +429,6 @@
         
         //MAIN LOGIC
         DEBUG("mode: %i  time: %i, %i, %i, %i \n", RET_mode, RET_RTCmicros, RET_RTCunixtime, RET_buttonHoldTime, RET_buttonPressCount);
-        
-        Thread::wait(5000);
-        RET_coldBoot = 0;
-        system_reset();
-        
         mainStateEngine();
         
         //PRE-SLEEP ACTIONS

--- a/main.h	Sun Dec 16 15:21:38 2018 +0000
+++ b/main.h	Sun Dec 16 21:34:52 2018 +0000
@@ -22,7 +22,6 @@
 #include "board.h"
 #include "WatchdogTimer.h"
 #include "ble/BLE.h"
-
 //#include "nvstore.h"
 
 
@@ -31,6 +30,7 @@
 //------------------------------------------------------------------------------
 #include "LIS3DH.h"
 #include "SI7060.h"
+#include "acd_nrf52_saadc.h"
 
 //------------------------------------------------------------------------------
 //C Standard Libraries

--- a/mbed_app.json	Sun Dec 16 15:21:38 2018 +0000
+++ b/mbed_app.json	Sun Dec 16 21:34:52 2018 +0000
@@ -18,17 +18,13 @@
         },
         "NRF52_DK": {
             "target.OUTPUT_EXT": "bin",
+            "target.bootloader_img": null,
             "target.uart_hwfc": 0,
             "nordic.uart_0_fifo_size": 1024,
             "nordic.uart_dma_size": 32,
             "target.device_has_add": ["LOWPOWERTIMER"],
             "target.macros_add": ["MBED_TICKLESS"],
-            "target.components_add": ["SD"],
-            "nvstore.max_keys": 20,
-            "nvstore.area_1_address": "0x0007e000",
-            "nvstore.area_1_size"   : "0x1000",
-            "nvstore.area_2_address": "0x0007f000",
-            "nvstore.area_2_size"   : "0x1000"
+            "target.components_add": ["FLASHIAP"]
         }
     }
 }
\ No newline at end of file

--- a/modem.cpp	Sun Dec 16 15:21:38 2018 +0000
+++ b/modem.cpp	Sun Dec 16 21:34:52 2018 +0000
@@ -121,6 +121,7 @@
         }
     }
     t.stop();
+    flushSerial();
     if (GLOBAL_registeredOnNetwork) {
         return true;
     } else {
@@ -150,12 +151,14 @@
     }
 }
 
-char* Modem::USSDreceive() 
+char* Modem::USSDreceive(int messageIndex) 
 {
     bool received = false;
     uint32_t timeout = 15000;
     int bufferIndex = 0;
-    char ATinBuffer[180];
+    int USSDmessageIndex = 0;
+    char ATinBuffer[160];
+    int matchCount = 0;
     Timer t;
     t.start();
     //TRY UNTIL TIMEOUT
@@ -163,53 +166,49 @@
     uint32_t runtime = 0;
     while(!received && runtime < timeout) {
         runtime = (t.read_ms() - startmillis);
-        if (ATwaitForWord("+CUSD: 0,\"%",5000)) {
+        if (ATwaitForWord("+CUSD: 0",5000)) {
             led1 = 0;
-            while(!received && runtime < timeout) {
-                runtime = (t.read_ms() - startmillis);
-                if(_uart.readable()) {
-                    char c = _uart.getc();
-                    if (c == '%') {
-                        led1 = 1;
-                        flushSerial();
-                        received = true;
-                    } else {
-                        ATinBuffer[bufferIndex] = c;
-                    }
-                    bufferIndex ++; //this must got at end otherwise first digit is \0
+            if ( (matchCount = _uart.scanf(",\"%d#%[^#]",USSDmessageIndex,ATinBuffer) ) > 0 ) {
+                if (USSDmessageIndex == messageIndex) {
+                    //NEED TO GET THIS WORKING SO WE KNOW WE ARE DEALING WITH THE RIGT MESSAGE
+                    //MOVE THE BELOW INTO THIS IF STAEMEBNTS
                 }
+                led1 = 1;
+                received = true;
             }
         }
     }
+    flushSerial();
     if (received) {
         return ATinBuffer;
     } else {
-        return "error";   
+        return "err";   
     }
 }
 
 
 char* Modem::USSDmessage(char* message, bool needResponse, int maxAttempts) 
 {
-    uint8_t postStatus = 0;
-    uint8_t postStatusTarget = 1;
-    if (needResponse) {
-        postStatusTarget = 2;
-    }
+    char bytestosend[160];
+    int messageIndex = 1;
     int messageLength = strlen(message);
     if (messageLength > USSD_MAXLENGTH) {
-           char* message;
-           sprintf(message,"('a':'%lld','b':'gps2','v':<voltage>)",GLOBAL_imei,1.0);
-    } else {
-        
+        snprintf(bytestosend,sizeof(bytestosend),"(a:%lld,b:gps2,c:%i,d:3,v:%.2f,z:TOOBIG)",GLOBAL_imei,messageIndex,GLOBAL_voltage);
     }
-    
-    if (messageLength <= USSD_MAXLENGTH) {
-        return message;
+    if (USSDsend(bytestosend, maxAttempts)) {
+        if (needResponse) {
+            char* response = USSDreceive(messageIndex);
+            if (response != "err") {
+                return response;
+            } else {
+                return "sendonly";   
+            }
+        } else {
+            return "ok";   
+        } 
     } else {
-        return "toolong";
+        return "err";   
     }
-    
 }
 
 Modem::~Modem(){};
\ No newline at end of file

--- a/modem.h	Sun Dec 16 15:21:38 2018 +0000
+++ b/modem.h	Sun Dec 16 21:34:52 2018 +0000
@@ -7,7 +7,7 @@
 
     #define UC20_BAUDRATE       115200
     #define SIM7600_BAUDRATE    115200
-    #define USSD_MAXLENGTH      130
+    #define USSD_MAXLENGTH      1
     
     class Modem
     {
@@ -22,7 +22,7 @@
             //funcs
             bool registerOnNetwork(int maxAttempts, uint32_t timeout);
             bool USSDsend(char* message, int maxAttempts);
-            char* USSDreceive();
+            char* USSDreceive(int messageIndex);
             char* USSDmessage(char* message, bool needResponse, int maxAttempts);
             
             //AT