/*
 *  ======== Power_sleep ========
 */
Power_Status Power_sleep(Power_SleepState sleepState, UArg arg0, UArg arg1)
{
    Power_Status status = Power_SOK;
    UInt xosc_hf_active = FALSE;
    Power_Event postEventLate;
    UInt32 poweredDomains = 0;
    Bool exitNow = FALSE;
    Power_Event preEvent;
    Power_Event postEvent;
    UInt32 constraints;
    Bool retainCache = FALSE;
    UInt32 modeVIMS;
    UInt taskKey;
    UInt swiKey;
    UInt hwiKey;

    /* first validate the sleep code */
    if ( sleepState != Power_STANDBY) {
        status = Power_EFAIL;
    }

    if (status == Power_SOK) {

        /* make sure Power is not still busy with a previous transition */
        hwiKey = Hwi_disable();

        if (Power_module->state == Power_ACTIVE) {

            /* set transition state to entering sleep */
            Power_module->state = Power_ENTERING_SLEEP;
        }
        else {
            exitNow = TRUE;
        }

        Hwi_restore(hwiKey);

        if (exitNow == TRUE) {
            status = Power_EBUSY;
        }

        else {

            /* setup sleep vars */
            if (sleepState == Power_STANDBY) {
                preEvent = Power_ENTERING_STANDBY;
                postEvent = Power_AWAKE_STANDBY;
                postEventLate = Power_AWAKE_STANDBY_LATE;
            }

            /* disable Task scheduling; allow Swis and Hwis for notifications */
            taskKey = Task_disable();

            /* signal all clients registered for pre-sleep notification */
            status = Power_notify(preEvent);

            /* check for any error */
            if (status != Power_SOK) {
                Power_module->state = Power_ACTIVE;
                Task_restore(taskKey);          /* re-enable scheduler */
                return (status);
            }

            /* now disable Swi scheduling */
            swiKey = Swi_disable();

            /* freeze the IOs on the boundary between MCU and AON */
            AONIOCFreezeEnable();

            /* if XOSC_HF is active, force it off */
            if(OSCClockSourceGet(OSC_SRC_CLK_HF) == OSC_XOSC_HF) {
                xosc_hf_active = TRUE;
                ti_sysbios_family_arm_cc26xx_Power_XOSC_HF(DISABLE);
            }

            /* allow AUX to power down */
            AONWUCAuxWakeupEvent(AONWUC_AUX_ALLOW_SLEEP);

            /* make sure writes take effect */
            SysCtrlAonSync();

            /* invoke specific sequences to activate sleep states... */

            if (sleepState == Power_STANDBY) {

                /* query and save domain states before powering them off */
                if (Power_getDependencyCount(DOMAIN_RFCORE)) {
                    poweredDomains |= PRCM_DOMAIN_RFCORE;
                }
                if (Power_getDependencyCount(DOMAIN_SERIAL)){
                    poweredDomains |= PRCM_DOMAIN_SERIAL;
                }
                if (Power_getDependencyCount(DOMAIN_PERIPH)) {
                    poweredDomains |= PRCM_DOMAIN_PERIPH;
                }

                /* gate running deep sleep clocks for Crypto and DMA */
                if (Power_getDependencyCount(PERIPH_CRYPTO)) {
                    PRCMPeripheralDeepSleepDisable(
                        ti_sysbios_family_arm_cc26xx_Power_db[
                            PERIPH_CRYPTO].driverlibID);
                }
                if (Power_getDependencyCount(PERIPH_UDMA)) {
                    PRCMPeripheralDeepSleepDisable(
                        ti_sysbios_family_arm_cc26xx_Power_db[
                            PERIPH_UDMA].driverlibID);
                }
                /* make sure clock settings take effect */
                PRCMLoadSet();

                /* request power off of domains in the MCU voltage domain */
                PRCMPowerDomainOff(poweredDomains | PRCM_DOMAIN_CPU);

                /* request uLDO during standby */
                PRCMMcuUldoConfigure(true);

                /* query constraints to determine if cache should be retained */
                constraints = Power_getConstraintInfo();
                if ((constraints & Power_SB_VIMS_CACHE_RETAIN) != 0) {
                    retainCache = TRUE;
                }

                /* if don't want retention in standby, disable it now ... */
                if (retainCache == FALSE) {
                    modeVIMS = VIMSModeGet(VIMS_BASE);
                    /* wait if invalidate in progress... */
                    while (modeVIMS == VIMS_MODE_CHANGING) {
                        modeVIMS = VIMSModeGet(VIMS_BASE);
                    }
                    PRCMCacheRetentionDisable();
                    VIMSModeSet(VIMS_BASE, VIMS_MODE_OFF);
                }

                /* setup recharge parameters */
                SysCtrlSetRechargeBeforePowerDown(XoscInHighPowerMode);

                /* make sure all writes have taken effect */
                SysCtrlAonSync();

                /* invoke deep sleep to go to STANDBY */
                PRCMDeepSleep();

                /* if didn't retain cache in standby, re-enable retention now */
                if (retainCache == FALSE) {
                    VIMSModeSet(VIMS_BASE, modeVIMS);
                    PRCMCacheRetentionEnable();
                }

                /* force power on of AUX to keep it on when system is not
                 * sleeping; this also counts as a write to the AON interface
                 * ensuring that a following sync of the AON interface will
                 * force an update of all registers
                 */
                AONWUCAuxWakeupEvent(AONWUC_AUX_WAKEUP);
                while(!(AONWUCPowerStatusGet() & AONWUC_AUX_POWER_ON)) {};

                /* if XOSC_HF was forced off above, initiate switch back */
                if (xosc_hf_active == TRUE) {
                    ti_sysbios_family_arm_cc26xx_Power_XOSC_HF(ENABLE);
                }

                /* restore power domain states in effect before standby */
                PRCMPowerDomainOn(poweredDomains);
                while (PRCMPowerDomainStatus(poweredDomains) !=
                    PRCM_DOMAIN_POWER_ON){};

                /* restore deep sleep clocks of Crypto and DMA */
                if (Power_getDependencyCount(PERIPH_CRYPTO)) {
                    PRCMPeripheralDeepSleepEnable(
                        ti_sysbios_family_arm_cc26xx_Power_db[
                            PERIPH_CRYPTO].driverlibID);
                }
                if (Power_getDependencyCount(PERIPH_UDMA)) {
                    PRCMPeripheralDeepSleepEnable(
                        ti_sysbios_family_arm_cc26xx_Power_db[
                            PERIPH_UDMA].driverlibID);
                }
                /* make sure clock settings take effect */
                PRCMLoadSet();
            }

            /* release request for uLDO */
            PRCMMcuUldoConfigure(false);

            /* set transition state to EXITING_SLEEP */
            Power_module->state = Power_EXITING_SLEEP;

            /*
             * signal clients registered for early post-sleep notification;
             * this should be used to initialize any timing critical or IO
             * dependent hardware
             */
            status = Power_notify(postEvent);

            /* disable IO freeze and ensure RTC shadow value is updated */
            AONIOCFreezeDisable();
            SysCtrlAonSync();

            /* re-enable interrupts */
            CPUcpsie();

            /* signal all clients registered for late post-sleep notification */
            status = Power_notify(postEventLate);

            /* now clear the transition state before re-enabling scheduler */
            Power_module->state = Power_ACTIVE;

            /* re-enable Swi scheduling */
            Swi_restore(swiKey);

            /* adjust recharge parameters */
            SysCtrlAdjustRechargeAfterPowerDown();

            /* re-enable Task scheduling */
            Task_restore(taskKey);

            /* check for any notification error */
            if (status != Power_SOK) {
                return (status);
            }
        }
    }

    return (status);
}
Esempio n. 2
0
//*****************************************************************************
//
// Force the system in to low power modes.
//
//*****************************************************************************
void
PowerCtrlStateSet(uint32_t ui32Powerstate)
{
    //
    // Check the arguments.
    //
    ASSERT((ui32Powerstate == PWRCTRL_STANDBY) ||
           (ui32Powerstate == PWRCTRL_POWER_DOWN) ||
           (ui32Powerstate == PWRCTRL_SHUTDOWN));

    //
    // Configure the desired power state.
    //
    if(ui32Powerstate == PWRCTRL_STANDBY)
    {
        //
        //
        // Turn of all power domains in the MCU voltage domain. This is
        // necessary to conserve power before switching to the uLDO.
        //
        PRCMPowerDomainOff(PRCM_DOMAIN_RFCORE | PRCM_DOMAIN_SERIAL |
                           PRCM_DOMAIN_PERIPH | PRCM_DOMAIN_CPU |
                           PRCM_DOMAIN_VIMS);

        //
        // Make sure to request power off of the JTAG domain.
        //
        AONWUCJtagPowerOff();

        //
        // Configuration of clock source for MCU and AUX in standby mode.
        //
        AONWUCMcuPowerDownConfig(AONWUC_CLOCK_SRC_LF);
        AONWUCAuxPowerDownConfig(AONWUC_CLOCK_SRC_LF);

        //
        // Configure the recharge controller and request the uLDO as power
        // source.
        //
        AONWUCRechargeCtrlConfigSet(true, 34, 2500, 5000);

        //
        // Enable AUX power down
        // This will tell the system that no HF source is needed and will
        // allow the system to use the low-leakage/effect power supply.
        // NB. This does not allow co-existence of an independent
        // Sensor Controller.
        //
        AUXWUCPowerCtrl(AUX_WUC_POWER_DOWN);
        while(AONWUCPowerStatusGet() & AONWUC_AUX_POWER_ON);

        //
        // Request the uLDO for standby power consumption.
        //
        PowerCtrlSourceSet(PWRCTRL_PWRSRC_ULDO);

        //
        // Sync the AON interface to ensure all writes have gone through
        //
        HWREG(AON_RTC_BASE + AON_RTC_O_SYNC);

        //
        // Enable transition to standby.
        //
        PRCMDeepSleep();
    }
    else if(ui32Powerstate == PWRCTRL_POWER_DOWN)
    {
        //
        // Latch the current IO configuration before going to sleep to ensure
        // the IOs retain their value even after boot and reset of the
        // configuration.
        //
        AONIOCFreezeEnable();

        //
        // Make sure retention on MCU SRAM is on - on pr. default.
        //
        AONWUCMcuSRamConfig(MCU_RAM0_RETENTION | MCU_RAM1_RETENTION |
                            MCU_RAM2_RETENTION | MCU_RAM3_RETENTION);

        //
        // Allow power off on all domains in the MCU voltage domain.
        // This is necessary to conserve power before switching to the uLDO.
        //
        PRCMPowerDomainOff(PRCM_DOMAIN_RFCORE | PRCM_DOMAIN_SERIAL |
                           PRCM_DOMAIN_PERIPH | PRCM_DOMAIN_CPU |
                           PRCM_DOMAIN_VIMS);

        //
        // Turn off the MCU voltage domain. This will not take effect until System CPU
        // is in deep sleep.
        //
        PRCMMcuPowerOff();

        //
        // Set the wake up mode  - default value coming out of reset
        //
        AONWUCMcuWakeUpConfig(MCU_IMM_WAKE_UP);

        //
        // VIRTUAL POWER OFF DISABLE is the default value coming out of reset
        //
        AONWUCMcuPowerOffConfig(MCU_VIRT_PWOFF_DISABLE);

        //
        // Configure the recharge controller and request the uLDO as power
        // source.
        // Recommended maximum numbers for lowest power consumption
        // AdaptRate = 96
        // MaxPeriod = 21440
        // InitPeriod = 14816
        //
        AONWUCRechargeCtrlConfigSet(true, 75, 5000, 7500);

        //
        // Enable AUX power down with LF clock source
        // Turn off JTAG domain and enable powerdown - values are default.
        //
        AONWUCAuxPowerDownConfig(AONWUC_CLOCK_SRC_LF);
        AUXWUCPowerCtrl(AUX_WUC_POWER_DOWN);
        AONWUCDomainPowerDownEnable();
        while(AONWUCPowerStatusGet() & AONWUC_AUX_POWER_ON);

        //
        // Sync the AON interface to ensure all writes have gone through
        //
        HWREG(AON_RTC_BASE + AON_RTC_O_SYNC);

        //
        // Enable transition to power down.
        //
        PRCMDeepSleep();
    }
    else
    {
        //
        // Latch the current IO configuration before going to sleep to ensure
        // the IOs retain their value even after boot and reset of the
        // configuration.
        //
        AONIOCFreezeEnable();

        //
        // Turn of all power domains in the MCU voltage domain.
        //
        PRCMPowerDomainOff(PRCM_DOMAIN_RFCORE | PRCM_DOMAIN_SERIAL |
                           PRCM_DOMAIN_PERIPH | PRCM_DOMAIN_CPU |
                           PRCM_DOMAIN_VIMS);

        //
        // Turn off the MCU voltage domain. This will not take effect until System CPU
        // is in deep sleep.
        //
        PRCMMcuPowerOff();

        //
        // Set the wake up mode of MCU to immediate
        //
        AONWUCMcuWakeUpConfig(MCU_IMM_WAKE_UP);
        AONWUCMcuPowerOffConfig(MCU_VIRT_PWOFF_DISABLE);

        //
        // Turn off the AUX domain and wait for power to be off.
        //
        // Is this required for shutdown mode? or will AUX automatically
        // power off.
        AUXWUCPowerCtrl(AUX_WUC_POWER_OFF);
        while(AONWUCPowerStatusGet() & AONWUC_AUX_POWER_ON)
        { }

        //
        // Latch the IOs in the padring before going to sleep to retain their
        // value even after boot and reset of the configuration.
        //
        PowerCtrlIOFreezeEnable();

        //
        // Enable shutdown and make sure the AON interface is in sync on the
        // 32kHz clock.
        //
        AONWUCShutDownEnable();

        //
        // Sync the AON interface to ensure all writes have gone through
        //
        HWREG(AON_RTC_BASE + AON_RTC_O_SYNC);

        //
        // Enable transition to shutdown.
        //
        PRCMDeepSleep();
    }
}
/*
 *  ======== Power_shutdown ========
 */
Power_Status Power_shutdown(UArg arg)
{
    Power_Status status = Power_EFAIL;
    Bool exitNow = FALSE;
    UInt32 constraints;
    UInt hwiKey;

    /* make sure shutdown request doesn't violate a constraint */
    constraints = Power_getConstraintInfo();
    if ((constraints & (Power_SD_DISALLOW)) != 0) {
        status = Power_ECHANGE_NOT_ALLOWED;
    }

    if (status == Power_EFAIL) {

        /* make sure Power is not still busy with a previous transition */
        hwiKey = Hwi_disable();

        if (Power_module->state == Power_ACTIVE) {
            /* set new transition state to entering shutdown */
            Power_module->state = Power_SHUTDOWN;
        }
        else {
            exitNow = TRUE;
        }

        Hwi_restore(hwiKey);

        if (exitNow == TRUE) {
            status = Power_EBUSY;
        }

        else {

            /* disable interrupts as start the shutdown sequence */
            Hwi_disable();

            /* signal all clients registered for pre-shutdown notification */
            status = Power_notify(Power_ENTERING_SHUTDOWN);

            /* check for any error */
            if (status != Power_SOK) {
                Power_module->state = Power_ACTIVE;
                CPUcpsie();
                return (status);
            }

            /* proceed with shutdown sequence ... */

            /* switch to RCOSC_HF and RCOSC_LF */
            OSCInterfaceEnable();
            if(OSCClockSourceGet(OSC_SRC_CLK_HF) != OSC_RCOSC_HF) {
                OSCClockSourceSet(OSC_SRC_CLK_HF | OSC_SRC_CLK_MF,
                    OSC_RCOSC_HF);
                while(!OSCHfSourceReady());
                OSCHfSourceSwitch();
            }
            OSCClockSourceSet(OSC_SRC_CLK_LF,OSC_RCOSC_LF);
            while(OSCClockSourceGet(OSC_SRC_CLK_LF) != OSC_RCOSC_LF);
            OSCInterfaceDisable();

            /* make sure DMA and CRYTO clocks are off in deep-sleep */
            PRCMPeripheralDeepSleepDisable(PRCM_PERIPH_CRYPTO);
            PRCMPeripheralDeepSleepDisable(PRCM_PERIPH_UDMA);
            PRCMLoadSet();
            while(!PRCMLoadGet()){};

            /* power OFF AUX and disconnect from bus */
            AUXWUCPowerCtrl(AUX_WUC_POWER_OFF);

            /* remove AUX force ON */
            HWREG(AON_WUC_BASE + AON_WUC_O_AUXCTL) &=
                ~AON_WUC_AUXCTL_AUX_FORCE_ON;

            /*
             * reset AON event source IDs to avoid pending events powering
             * on MCU/AUX
             */
            HWREG(AON_EVENT_BASE + AON_EVENT_O_MCUWUSEL) = 0x3F3F3F3F;
            HWREG(AON_EVENT_BASE + AON_EVENT_O_AUXWUSEL) = 0x003F3F3F;

            /* sync AON */
            HWREG(AON_RTC_BASE + AON_RTC_O_SYNC);

            /*
             * enable shutdown - this latches the IOs, so configuration of
             * IOCFGx registers must be done prior to this
             */
            AONWUCShutDownEnable();

            /* sync AON */
            HWREG(AON_RTC_BASE + AON_RTC_O_SYNC);

            /* wait until AUX powered off */
            while (AONWUCPowerStatusGet() & AONWUC_AUX_POWER_ON);

            /* request to power off MCU when go to deep sleep */
            PRCMMcuPowerOff();

            /* turn off power domains inside MCU VD (BUS, FL_BUS, RFC, CPU) */
            PRCMPowerDomainOff(PRCM_DOMAIN_RFCORE | PRCM_DOMAIN_SERIAL |
                PRCM_DOMAIN_PERIPH | PRCM_DOMAIN_CPU | PRCM_DOMAIN_VIMS);

            /* deep sleep to activate shutdown */
            PRCMDeepSleep();
        }
    }

    Power_module->state = Power_ACTIVE;

    /* if get here failed to shutdown, return failure code */
    return (Power_EFAIL);
}
Esempio n. 4
0
 int main(void) {

  uint8_t payload[ADVLEN];

  //Disable JTAG to allow for Standby
  AONWUCJtagPowerOff();

  //Force AUX on
  powerEnableAuxForceOn();
  powerEnableRFC();

  powerEnableXtalInterface();
  

  // Divide INF clk to save Idle mode power (increases interrupt latency)
  powerDivideInfClkDS(PRCM_INFRCLKDIVDS_RATIO_DIV32);

  initRTC();

  powerEnablePeriph();
  powerEnableGPIOClockRunMode();
  /* Wait for domains to power on */
  while((PRCMPowerDomainStatus(PRCM_DOMAIN_PERIPH) != PRCM_DOMAIN_POWER_ON));

  sensorsInit();
  ledInit();

  //Config IOID4 for external interrupt on rising edge and wake up
  //IOCPortConfigureSet(BOARD_IOID_KEY_RIGHT, IOC_PORT_GPIO, IOC_IOMODE_NORMAL | IOC_FALLING_EDGE | IOC_INT_ENABLE | IOC_IOPULL_UP | IOC_INPUT_ENABLE | IOC_WAKE_ON_LOW);

  // Config reedSwitch as input
  IOCPortConfigureSet(BOARD_IOID_DP0, IOC_PORT_GPIO, IOC_IOMODE_NORMAL | IOC_RISING_EDGE | IOC_INT_ENABLE | IOC_IOPULL_DOWN | IOC_INPUT_ENABLE | IOC_WAKE_ON_HIGH);
  //Set device to wake MCU from standby on PIN 4 (BUTTON1)
  HWREG(AON_EVENT_BASE + AON_EVENT_O_MCUWUSEL) = AON_EVENT_MCUWUSEL_WU0_EV_PAD;  //Does not work with AON_EVENT_MCUWUSEL_WU0_EV_PAD4 --> WHY??

  IntEnable(INT_EDGE_DETECT);

  powerDisablePeriph();
  //Disable clock for GPIO in CPU run mode
  HWREGBITW(PRCM_BASE + PRCM_O_GPIOCLKGR, PRCM_GPIOCLKGR_CLK_EN_BITN) = 0;
  // Load clock settings
  HWREGBITW(PRCM_BASE + PRCM_O_CLKLOADCTL, PRCM_CLKLOADCTL_LOAD_BITN) = 1;

  initInterrupts();
  initRadio();




  // baek: before while
      powerEnablePeriph();
      powerEnableGPIOClockRunMode();

       /* Wait for domains to power on */
     while((PRCMPowerDomainStatus(PRCM_DOMAIN_PERIPH) != PRCM_DOMAIN_POWER_ON)); // CRASH !!!!!!!!!!!!!!

       sensorsInit();
       ledInit();
  // end baek:


  // Turn off FLASH in idle mode
  powerDisableFlashInIdle();

  // Cache retention must be enabled in Idle if flash domain is turned off (to avoid cache corruption)
  powerEnableCacheRetention();

  //AUX - request to power down (takes no effect since force on is set)
  powerEnableAUXPdReq();
  powerDisableAuxRamRet();

  //Clear payload buffer
  memset(payload, 0, ADVLEN);

  while(1) {

  //if((g_count& 0x04)== 1){

    rfBootDone  = 0;
    rfSetupDone = 0;
    rfAdvertisingDone = 0;

	select_bmp_280();     				// activates I2C for bmp-sensor
	enable_bmp_280(1);					// works

    //Wait until RF Core PD is ready before accessing radio
    waitUntilRFCReady();
    initRadioInts();
    runRadio();

    //Wait until AUX is ready before configuring oscillators
    waitUntilAUXReady();

    //Enable 24MHz XTAL
    OSCHF_TurnOnXosc();

    //IDLE until BOOT_DONE interrupt from RFCore is triggered
    while( ! rfBootDone) {
      powerDisableCPU();
      PRCMDeepSleep();
    }

    //This code runs after BOOT_DONE interrupt has woken up the CPU again
    // ->
    //Request radio to keep on system bus
    radioCmdBusRequest(true);

    //Patch CM0 - no RFE patch needed for TX only
    radioPatch();

    //Start radio timer
    radioCmdStartRAT();

    //Enable Flash access while doing radio setup
    powerEnableFlashInIdle();

    //Switch to XTAL
    while( !OSCHF_AttemptToSwitchToXosc())
    {}
  
/* baek: before while
    powerEnablePeriph();
    powerEnableGPIOClockRunMode();

     /* Wait for domains to power on */
 /*    while((PRCMPowerDomainStatus(PRCM_DOMAIN_PERIPH) != PRCM_DOMAIN_POWER_ON)); // CRASH !!!!!!!!!!!!!!

     sensorsInit();
     ledInit();
*/
/*****************************************************************************************/
// Read sensor values


     uint32_t pressure = 0;  			// only 3 Bytes used
	//uint32_t temp = 0;
	select_bmp_280();     				// activates I2C for bmp-sensor
	enable_bmp_280(1);					// works

	do{
		pressure = value_bmp_280(BMP_280_SENSOR_TYPE_PRESS);  //  read and converts in pascal (96'000 Pa)
		//temp = value_bmp_280(BMP_280_SENSOR_TYPE_TEMP);
	}while(pressure == 0x80000000);
		if(pressure == 0x80000000){
			CPUdelay(100);

			pressure = value_bmp_280(BMP_280_SENSOR_TYPE_PRESS);  //  read and converts in pascal (96'000 Pa)

		}


    //Start Temp measurement
    uint16_t temperature;
    enable_tmp_007(1);

   //Wait for, read and calc temperature
    {
    int count = 0;
    do{
    	temperature = value_tmp_007(TMP_007_SENSOR_TYPE_AMBIENT);
    	//g_count++;
    }while( ((temperature == 0x80000000) || (temperature == 0)) && (count <=5) );
    count++;
	count--;
    }
    enable_tmp_007(0);
    char char_temp[2];



   //start hum measurement
        configure_hdc_1000();
        start_hdc_1000();
//    //Wait for, read and calc humidity
    while(!read_data_hdc_1000());
   int humidity = value_hdc_1000(HDC_1000_SENSOR_TYPE_HUMIDITY);
//    char char_hum[5];



//END read sensor values
/*****************************************************************************************/

    powerDisablePeriph();
	// Disable clock for GPIO in CPU run mode
	HWREGBITW(PRCM_BASE + PRCM_O_GPIOCLKGR, PRCM_GPIOCLKGR_CLK_EN_BITN) = 0;
	// Load clock settings
	HWREGBITW(PRCM_BASE + PRCM_O_CLKLOADCTL, PRCM_CLKLOADCTL_LOAD_BITN) = 1;

/*****************************************************************************************/
// Set payload and transmit
	uint8_t p;
    p = 0;

    /*jedes 5.te mal senden*/


		payload[p++] = ADVLEN-1;        /* len */
		payload[p++] = 0x03;
		payload[p++] = 0xde;
		payload[p++] = 0xba;
		payload[p++] =(sequenceNumber >> 8);				// laufnummer
		payload[p++] = sequenceNumber;

		// Speed
		payload[p++] = g_diff >> 24;						// higher seconds
		payload[p++] = g_diff >> 16;						// lower  seconds
		payload[p++] = g_diff >> 8;							// higher subseconds
		payload[p++] = g_diff;								// lower  subseconds

		//pressure
		payload[p++] = 0;
		payload[p++] = 0; //(pressure >> 16);
		payload[p++] = 0; //(pressure >> 8);
		payload[p++] = 0; //pressure;

		//temperature
		payload[p++] = 0;
		payload[p++] = 0; // char_temp[2];
		payload[p++] = 0;//temperature >> 8; // char_temp[1];
		payload[p++] = 0; //temperature; //char_temp[0];

		// huminity
		payload[p++] = 0;
		payload[p++] = 0;//char_hum[0];
		payload[p++] = 0;//char_hum[1];
		payload[p++] = 0;//char_hum[2];

		payload[p++] = 0;
		payload[p++] = 0;



		//Start radio setup and linked advertisment
		radioUpdateAdvData(ADVLEN, payload);

		//Start radio setup and linked advertisment
		radioSetupAndTransmit();
	//}


//END: Transmit
/*****************************************************************************************/


    //Wait in IDLE for CMD_DONE interrupt after radio setup. ISR will disable radio interrupts
    while( ! rfSetupDone) {
      powerDisableCPU();
      PRCMDeepSleep();
    }

    //Disable flash in IDLE after CMD_RADIO_SETUP is done (radio setup reads FCFG trim values)
    powerDisableFlashInIdle();

    //Wait in IDLE for LAST_CMD_DONE after 3 adv packets
    while( ! rfAdvertisingDone) {
      powerDisableCPU();
      PRCMDeepSleep();
    }

    //Request radio to not force on system bus any more
    radioCmdBusRequest(false);

 // } // end if
 // g_count++;

    //
    // Standby procedure
    //

    powerDisableXtal();

    // Turn off radio
    powerDisableRFC();

    // Switch to RCOSC_HF
    OSCHfSourceSwitch();

    // Allow AUX to turn off again. No longer need oscillator interface
    powerDisableAuxForceOn();

    // Goto Standby. MCU will now request to be powered down on DeepSleep
    powerEnableMcuPdReq();

    // Disable cache and retention
    powerDisableCache();
    powerDisableCacheRetention();

    //Calculate next recharge
    SysCtrlSetRechargeBeforePowerDown(XOSC_IN_HIGH_POWER_MODE);

    // Synchronize transactions to AON domain to ensure AUX has turned off
    SysCtrlAonSync();

    //
    // Enter Standby
    //

    powerDisableCPU();
    PRCMDeepSleep();

    SysCtrlAonUpdate();

    SysCtrlAdjustRechargeAfterPowerDown();

    SysCtrlAonSync();

    //
	// Wakeup from RTC, code starts execution from here
	//
   
    powerEnableRFC();

    powerEnableAuxForceOn();

    //Re-enable cache and retention
    powerEnableCache();
    powerEnableCacheRetention();

    //MCU will not request to be powered down on DeepSleep -> System goes only to IDLE
    powerDisableMcuPdReq();
  }
}