pwrlib.c

freescale的基于802.15.4的无线通讯例程

/******************************************************************************/
/* Please see in PWRLib.h for description */
void PWRLib_ResetMCUIOAfterPowerSavingMode(void) {
  #if (cPWR_SetupIOWhenInPD > 0)
    PWRLib_SaveDebugIOState();
    #if (cPWR_SetupIOWhenInPD >= 1)
      PTAD  = SavedPTAD ;
      PTBD  = SavedPTBD ;
      PTCD  = SavedPTCD ;
      PTDD  = SavedPTDD ;
      PTED  = SavedPTED ;
      PTFD  = SavedPTFD ;
      PTGD  = SavedPTGD ;
    #endif
    #if (cPWR_SetupIOWhenInPD == 1)
      PTAPE = SavedPTAPE;
      PTBPE = SavedPTBPE;
      PTCPE = SavedPTCPE;
      PTDPE = SavedPTDPE;
      PTEPE = SavedPTEPE;
      PTFPE = SavedPTFPE;
      PTGPE = SavedPTGPE;
      PTADD = SavedPTADD;
      PTBDD = SavedPTBDD;
      PTCDD = SavedPTCDD;
      PTDDD = SavedPTDDD;
      PTEDD = SavedPTEDD;
      PTFDD = SavedPTFDD;
      PTGDD = SavedPTGDD;
    #endif
    mPWRLib_RESTORE_PORT_A;
    mPWRLib_RESTORE_PORT_B;
    mPWRLib_RESTORE_PORT_C;
    mPWRLib_RESTORE_PORT_D;
    mPWRLib_RESTORE_PORT_E;
    mPWRLib_RESTORE_PORT_F;
    mPWRLib_RESTORE_PORT_G;
    PWRLib_RestoreDebugIOState();
    mPWRLib_SPINormalMode;
  #endif  /* #if (cPWR_SetupIOWhenInPD > 0) */
}   /* PWRLib_ResetMCUIOAfterPowerSavingMode ====*/


/*****************************************************************************/
/* Please see in PWRLib.h for description */
void PWRLib_MCUWait(void) {
  mMCU_SetStatus( MCU_Wait);
  mSETPIN_WAIT_MODE;
  __asm  WAIT;
  mRESETPIN_WAIT_MODE;
}   /* PWRLib_MCUWait =====*/


/*****************************************************************************/
/* Please see in PWRLib.h for description */
void PWRLib_MCUStop3(void) {
  mMCU_SetStatus( MCU_Stop3);
  mSETPIN_STOP3_MODE;
  __asm STOP;
  mRESETPIN_STOP3_MODE;
}   /* PWRLib_MCUStop3 ===== */


/*****************************************************************************/
/* Please see in PWRLib.h for description  */
void PWRLib_MCUStop2(void) {
  mMCU_SetStatus( MCU_Stop2);
  mSETPIN_STOP2_MODE;
  SPMSC2 |=  0x03;      /* Sets PDC and PPDC bits for Stop2 mode */
  __asm STOP;
/*  mRESETPIN_STOP2_MODE; This can't be called. Reset occurs instead */
}   /* PWRLib_MCUStop2 =====*/


/*****************************************************************************/
/* Please see in PWRLib.h for description */
void PWRLib_MCUStop1(void) {
  mMCU_SetStatus( MCU_Stop1);
  SPMSC2 |=  0x02;      /* Sets PDC bit for Stop1 mode */
  __asm STOP;
}   /* PWRLib_MCUStop1 =====*/


/*****************************************************************************/
/* Please see in PWRLib.h for description  */
void PWRLib_ICG_Mode(PWRLib_ICGMode_t Mode, PWRLib_ICGClockType_t Clock) {
    PWRLib_ICGMode = Mode; /* Store in global variable */
    ICGC1 = ((Clock<<6) | (0<<5) | (Mode<<3) | (0<<2));
    if( Mode == SCM)
        /* Select only one below */
        /*mSCM_2MHZ_DEFAULT_ICG_FILTER  */
        mSCM_DEFAULT_ICG_FILTER /* 4 MHz bus frequency. 8MHz CPU. */
        /*mSCM_8MHZ_DEFAULT_ICG_FILTER */
        /*mSCM_16MHZ_DEFAULT_ICG_FILTER */
        /*mSCM_20MHZ_DEFAULT_ICG_FILTER */
} /* PWRLib_ICG_Mode =====*/


/*****************************************************************************/
/* Please see in PWRLib.h for description  */
bool_t PWRLib_ICG_Wait_Clock_Lock(void) {
    if((PWRLib_ICGMode == FEI) || (PWRLib_ICGMode == FEE)) {
        return(TRUE);
    } else {
        return(FALSE);
    }
}  /* PWRLib_ICG_Wait_Clock_Lock =====*/


/*****************************************************************************/
/* Please see in PWRLib.h for description   */
void PWRLib_ICG_Divider_Setup(PWRLib_ICGMultiplier_t N, PWRLib_ICGDivider_t R) {
    ICGC2 = ((0<<7) | (N<<4) | (0<<3) | (R<<0));
} /* PWRLib_ICG_Divider_Setup ====*/


/*****************************************************************************/
/* Please see in PWRLib.h for description   */
void PWRLib_ClockSetup(PWRLib_ICGClkMode_t ClkMode) {
    uint8_t CCR;
/*    uint16_t i = 1550; */
    uint16_t i = 800;
    IrqControlLib_BackupIrqStatus(CCR)
    IrqControlLib_DisableAllIrqs();
				

    /* Set LOW_CLOCK to insure FLL LOCK certain modes.   */
    PWRLib_ICG_Mode( SCM, LOW_CLOCK);
    while(i) { i--;WAIT_6_NOPS();}
    
    if ( ClkMode == Normal_16MHz) {
      /*--- Setup RADIO CLKO ---*/
      MC1319xDrv_WriteSpi(ABEL_regA, (gpMacNvram->Abel_Clock_Out_Setting & 0xfff8) | RADIO_CLKO_62_50KHZ);
      WAIT_6_NOPS();
      /*--- Setup the ICG module ---*/
      PWRLib_ICG_Divider_Setup( N8, R1);
      PWRLib_ICG_Mode( FEE, LOW_CLOCK);
    }
    else if ( ClkMode == Precice_1MHz) {
      /*--- Setup RADIO CLKO ---*/
       MC1319xDrv_WriteSpi(ABEL_regA, (gpMacNvram->Abel_Clock_Out_Setting & 0xfff8) | RADIO_CLKO_62_50KHZ);
      WAIT_6_NOPS();
      /*--- Setup the ICG module ---*/
      PWRLib_ICG_Divider_Setup( N4, R8);
      PWRLib_ICG_Mode( FEE, LOW_CLOCK);
    }
    else if ( ClkMode == SelfClk_2MHz) {
      PWRLib_ICG_Divider_Setup( N8, R2);
      PWRLib_ICG_Mode( SCM, LOW_CLOCK);
    }
    else if ( ClkMode == SelfClk_1MHz) {
      PWRLib_ICG_Divider_Setup( N8, R4);
      PWRLib_ICG_Mode( SCM, LOW_CLOCK);
    }
    else if ( ClkMode == SelfClk_125kHz) {
      PWRLib_ICG_Divider_Setup( N8, R32);
      PWRLib_ICG_Mode( SCM, LOW_CLOCK);
    }
    /* Wait for clock to lock in some ICG modes */
    WAIT_6_NOPS();
    if(PWRLib_ICG_Wait_Clock_Lock() == TRUE)
        while((ICGS1 & cICG_FLL_LOCKED) != cICG_FLL_LOCKED);
    IrqControlLib_RestoreIrqStatus(CCR)
    
} /* PWRLib_ClockSetup =====*/


/*****************************************************************************/
/* Please see in PWRLib.h for description  */
void PWRLib_RTIClockStart(uint8_t ClkMode, uint32_t Ticks) {
  uint8_t CCR;
  IrqControlLib_BackupIrqStatus(CCR)
  IrqControlLib_DisableAllIrqs();
  mSETPIN_RTISTARTED_MODE;
  #if (cPWR_RTIFromExternalClock)
    ICGC1 |= 0x02;      /* Set the OSCSTEN to enable RTI from external clk in stop modes 2 and 3*/
    SRTISC = cSRTISC_Start | cSRTISC_IntClear | ClkMode | cSRTISC_External;
  #else
    SRTISC = cSRTISC_Start | cSRTISC_IntClear | ClkMode;
  #endif
  PWRLib_RTIRemainingTicks = Ticks;
    IrqControlLib_RestoreIrqStatus(CCR)
}  /* PWRLib_RTIClockStart ======*/


/*****************************************************************************/
/* Please see in PWRLib.h for description  */
uint32_t PWRLib_RTIClockCheck(void) {
  uint32_t  x ;
  uint8_t CCR;
  IrqControlLib_BackupIrqStatus(CCR)
  IrqControlLib_DisableAllIrqs();
  x = PWRLib_RTIRemainingTicks;
   IrqControlLib_RestoreIrqStatus(CCR)
  return x;
}  /* PWRLib_RTIClockCheck ======*/

/*****************************************************************************/
/* Please see in PWRLib.h for description  */
void PWRLib_RTIClockStop(void) {
    uint8_t CCR;
  IrqControlLib_BackupIrqStatus(CCR)
  IrqControlLib_DisableAllIrqs();
  mRESETPIN_RTISTARTED_MODE;
  SRTISC = cSRTISC_Stop;
   IrqControlLib_RestoreIrqStatus(CCR)
}  /* PWRLib_RTIClockStop ======*/

#endif  /* #if (cPWR_UsePowerDownMode==1) */


/*****************************************************************************/
/* Please see WARNINGS in PWRLib.h                                           */
__interrupt void PWRLib_RTIClock_ISR(void) {
  SRTISC |= cSRTISC_IntClear;
  PWRLib_MCU_WakeupReason.Bits.FromRTI = 1;
  #if (cPWR_UsePowerDownMode)
    if ( PWRLib_RTIRemainingTicks > 0) {
      PWRLib_RTIRemainingTicks--;
    }
    /*--- Low Voltage Check */
    #if (cPWR_LVD_Enable==2)
      if ( --PWRLib_LVD_CollectCounter == 0) {
        PWRLib_MCU_WakeupReason.Bits.LVD_Updated = 1;
        PWRLib_LVD_CollectCounter = cPWR_LVD_Ticks;
        PWRLib_LVD_SavedLevel = PWRLib_LVD_CollectLevel();
      }
    #endif  /* #if (cPWR_LVD_Enable==2) */
  #endif  /* #if (cPWR_UsePowerDownMode==1) */
}  /* PWRLib_RTIClock_ISR ======*/


/*****************************************************************************/
/* Please see in PWRLib.h for description       */
#if (cPWR_KBIInitAndVectorEnable)
__interrupt void PWRLib_KBI_ISR(void) {
  KBI1SC =  cKBI1SC | cKBI1SC_Ack;
  PWRLib_MCU_WakeupReason.Bits.FromKBI = 1;
}  /* PWRLib_KBI_ISR ====== */
#endif

/*****************************************************************************/
/* Please see in PWRLib.h for description                                    */
PWRLib_LVD_VoltageLevel_t PWRLib_LVD_CollectLevel(void) {
#if (cPWR_LVD_Enable > 0)
  /*--- Check low detect voltage ~1.8V */
  if (SPMSC1 & cSPMSC1_LVDFlag)  {
    /* Low detect voltage reached */
    SPMSC1 = cSPMSC2_ClearWarning; /* Clear flag */
    return(PWR_NODEPOWER_LEVEL_CRITICAL);
  }

  /*--- Check low trip voltage ~2.1V */
  SPMSC2 = (cSPMSC2_ClearWarning | cSPMSC2_LowTripVoltage); /* Set low trip voltage and clear warning flag */
  if (SPMSC2 & cSPMSC2_LVWFlag) {
    /* Low trip voltage reached */
    SPMSC2 = cSPMSC2_ClearWarning; /* Clear flag (and set low trip voltage) */
    return(PWR_NODEPOWER_LEVEL_33);
  }

  /*--- Check high trip voltage ~2.4V and below 2.4V */
  SPMSC2 = (cSPMSC2_ClearWarning | cSPMSC2_HighTripVoltage); /* Set high trip voltage and clear warning flag */
  if(SPMSC2 & cSPMSC2_LVWFlag) {
      /* High trip voltage reached */
      SPMSC2 = cSPMSC2_ClearWarning; /* Clear flag (and set low trip voltage) */
      if(PWRLib_LVD_L2Counter == 0) {
          return(PWR_NODEPOWER_LEVEL_50); /* Timer controlled level */
      } else {
        PWRLib_LVD_L2Counter--;
        return(PWR_NODEPOWER_LEVEL_66); /* Voltage below 2.4V */
      }
  } else {
    PWRLib_LVD_L2Counter = cPWR_LVD_LEVEL_50_Ticks; /* Reset counter */
  }
#endif  /* #if (cPWR_LVD_Enable > 0) */
  /*--- Voltage level is okay > 2.4V */
  return(PWR_NODEPOWER_LEVEL_100);
}  /* PWRLib_LVD_CollectLevel ======= */