📄 drv_timer0.c.bak
字号:
////calculate Reactive Power Rate(Q), QP = (Ui*Ir-Ur*Ii)
ADC_QP = (ADU_Image*ADI_Real - ADU_Real*ADI_Image)/1000;
////calculate Power(S); SP = sqrt(WP^2+QP^2)
ADC_SP = ADC_WP*ADC_WP + ADC_QP*ADC_QP;
ADC_SP = sqrt((double)ADC_SP);
///////////////////////////////////////////////////////////////
ADC_U_Filter[ADC_FilterP] = (int16)ADC_UAC;
ADC_I_Filter[ADC_FilterP] = (int16)ADC_IAC;
ADC_WP_Filter[ADC_FilterP] = (int16)ADC_WP;
ADC_QP_Filter[ADC_FilterP] = (int16)ADC_QP;
ADC_SP_Filter[ADC_FilterP] = (int16)ADC_SP;
ADC_UL_Filter[ADC_FilterP] = (int16)ADU_DCLevel;
ADC_IL_Filter[ADC_FilterP] = (int16)ADI_DCLevel;
////
ADC_FilterP++;
if(ADC_FilterP >= AD_FILTER_SIZE){
ADC_FilterP=0;
}
if(ADC_EventCounter <= AD_FILTER_SIZE){
ADC_EventCounter++;
}
////
if((SysRunState==NORMAL_STATE)||(SysRunState==PRINT_STATE)){ //#define AD_SAMPLE_NUM 20
ADC_Period_mS = AD_SAMPLE_NUM*AD_SPEED_LOW_; //10 get 100 ad sample within 20/5 seconds
}
else{ //test and calibrate
ADC_Period_mS = AD_SAMPLE_NUM*AD_SPEED_HIGH; //get 100 ad sample within 10/5 seconds
}
////////////////////////////////////////////////////////////////////////////////////
CurVoltageOrg = 0; CurCurrentOrg = 0;
CurW_PowerOrg = 0; CurQ_PowerOrg = 0;
CurS_PowerOrg = 0;
CurU_DCLevelOrg = 0; CurI_DCLevelOrg = 0;
for(i=0;i<AD_FILTER_SIZE;i++){
CurVoltageOrg += ADC_U_Filter[i];
CurCurrentOrg += ADC_I_Filter[i];
CurW_PowerOrg += ADC_WP_Filter[i];
CurQ_PowerOrg += ADC_QP_Filter[i];
CurS_PowerOrg += ADC_SP_Filter[i];
CurU_DCLevelOrg += ADC_UL_Filter[i];
CurI_DCLevelOrg += ADC_IL_Filter[i];
}
CurVoltageOrg = CurVoltageOrg/AD_FILTER_SIZE;
CurCurrentOrg = CurCurrentOrg/AD_FILTER_SIZE;
CurW_PowerOrg = CurW_PowerOrg/AD_FILTER_SIZE;
CurQ_PowerOrg = CurQ_PowerOrg/AD_FILTER_SIZE;
CurS_PowerOrg = CurS_PowerOrg/AD_FILTER_SIZE;
CurU_DCLevelOrg = CurU_DCLevelOrg/AD_FILTER_SIZE; // voltage channel level
CurI_DCLevelOrg = CurI_DCLevelOrg/AD_FILTER_SIZE; // current channel level
///////////////////////////////////////////////////////////////////////////////////
if(ADC_EventCounter>AD_FILTER_SIZE){
#ifdef INCLUDE_DEBUGGING
Uart0SendString("distribute data to CurInputScale_...");
#endif
CurInputScale_U = CurVoltageOrg; //this two variables only for calibration
CurInputScale_I = CurCurrentOrg;
}
///////////////////////////////////////////////////////////////////////////////////
// get the final parameters
CurVoltageOrg = ((CurVoltageOrg * ADC_UUK_Value)+500)/1000; //if(CurInput_UU<300) CurInput_UU=0; //force to 0
CurCurrentOrg = ((CurCurrentOrg * ADC_IIK_Value)+500)/1000; //if(CurInput_II<300) CurInput_II=0; //force to 0
CurW_PowerOrg = CurW_PowerOrg * ADC_WPK_Value;
if(CurW_PowerOrg<0) CurW_PowerOrg = -CurW_PowerOrg; //reverse the negative
CurQ_PowerOrg = ((CurQ_PowerOrg * ADC_QPK_Value)+500)/1000; //if(CurInput_QP<300) CurInput_QP=0; //force to 0
if(CurQ_PowerOrg<0) CurQ_PowerOrg = -CurQ_PowerOrg; //reverse the negative
CurS_PowerOrg = ((CurS_PowerOrg * ADC_SPK_Value)+500)/1000; //if(CurInput_SP<300) CurInput_SP=0; //force to 0
if(CurS_PowerOrg!=0){
CurPFactorOrg = CurW_PowerOrg/CurS_PowerOrg; //if(CurInput_PF>1000) CurInput_PF=1000;
}
CurW_PowerOrg = (CurW_PowerOrg+500)/1000; //if(CurInput_WP<300) CurInput_WP=0; //force to 0
// calculation the resistance of load.
if(CurCurrentOrg != 0){
// CurRO_LoadOrg = ( 1000*CurVoltageOrg)/CurCurrentOrg;
CurRO_LoadOrg = ( 1000*2200)/CurCurrentOrg;
CurLC_LoadOrg = ((((1000*CurVoltageOrg)/CurCurrentOrg)
*CurQ_PowerOrg)/CurCurrentOrg);
}
//(1) (0.1*U)/(0.001*I)*10 = 1000* U/I(*220/U)=1000*220/I (unit=0.1Ohm)
//(2) (0.1*QP)/(0.001*I)/(0.001*I)*(0.1*U)/100*10 = 1000QU/I/I (unit=0.1Ohm)
// = 1000 U/I*Q/I
///////////////////////////////////////////////////////////////////////////
//// assigned to input channel parameter
if((ChannelState==1)&&(ADC_EventCounter>AD_FILTER_SIZE)){
#ifdef INCLUDE_DEBUGGING
Uart0SendString("distribute data to CurInput_...");
#endif
CurInputULevel = CurU_DCLevelOrg;
CurInputILevel = CurI_DCLevelOrg;
CurInput_UU = CurVoltageOrg;
CurInput_II = CurCurrentOrg;
CurInput_WP = CurW_PowerOrg;
CurInput_QP = CurQ_PowerOrg;
CurInput_SP = CurS_PowerOrg;
CurInput_PF = CurPFactorOrg;
}
//// assigned to output channel parameter
else if((ChannelState==2)&&(ADC_EventCounter>AD_FILTER_SIZE)){
#ifdef INCLUDE_DEBUGGING
Uart0SendString("distribute data to CurOutput_...");
#endif
CurOutputULevel = CurU_DCLevelOrg;
CurOutputILevel = CurI_DCLevelOrg;
CurOutput_U = CurVoltageOrg;
CurOutput_I = CurCurrentOrg;
CurOutput_WP = CurW_PowerOrg;
CurOutput_QP = CurQ_PowerOrg;
CurOutput_SP = CurS_PowerOrg;
CurOutput_PF = CurPFactorOrg;
}
//// if light off, force all output to zero.
if((StateValue & LIGHT_ON_FLG_BIT) != LIGHT_ON_FLG_BIT){ // if light is off
#ifdef INCLUDE_DEBUGGING
Uart0SendString("force data to zero");
#endif
CurOutput_U = 0; CurOutput_I = 0;
CurOutput_WP = 0; CurOutput_QP = 0;
CurOutput_SP = 0; CurOutput_PF = 0;
OutReadyTimer=POWER_UP_READY_TIME; //control alarm message
}
if(PW_FLAG==1) //掉电报警的时候，所有电量清零
{
CurInputULevel = 0; CurInputILevel = 0;
CurInput_UU = 0; CurInput_II = 0;
CurInput_WP = 0; CurInput_QP = 0;
CurInput_SP = 0; CurInput_PF = 0;
CurOutput_U = 0; CurOutput_I = 0;
CurOutput_WP = 0; CurOutput_QP = 0;
CurOutput_SP = 0; CurOutput_PF = 0;
}
///////////////////////////////////////////////////////////////////////////////
//// alarm bits setting area, //uint16 StateValue;
if(((StateValue&LIGHT_ON_FLG_BIT)==LIGHT_ON_FLG_BIT)&&(OutReadyTimer==0)){
// I alarm
if(CurInput_II < I_ALARM_LOW_LIMIT){ StateValue = StateValue| IIII__ALARM_TYPE; }
else{ StateValue = StateValue&(~IIII__ALARM_TYPE); }
// U alarm
if(CurInput_UU < U_ALARM_LOW_LIMIT){ StateValue = StateValue| UUUU__ALARM_TYPE; }
else{ StateValue = StateValue&(~UUUU__ALARM_TYPE);}
// PF alarm
if(CurInput_PF < PF_ALARM_LOW_LIMIT){ StateValue = StateValue| PFPF__ALARM_TYPE; }
else{ StateValue = StateValue&(~PFPF__ALARM_TYPE);}
}
}
/////////////////////////////////////////////////////////////////////////////
void AD_ChannelSwitch(void)
{
////set the sample ok flag
if((ADCmS_Counter>=(AD_SAMPLE_NUM-1))&& //check if 20 samples is ready
(ADC_Flag != AD_AVAILABLE )){ //check if the data last time already be used.
////(1) in normal and test state, change the ad channel.
if((SysRunState==NORMAL_STATE)||
(SysRunState==TEST_STATE) ||
(SysRunState==PRINT_STATE)){
if(ADC_ChannelTimer<=Channel_Input_Time){
if(ChannelState!=1){
//#ifdef INCLUDE_DEBUGGING
Uart0SendString("To input U channel");
//#endif
IO1CLR=DT__P1_31; //measuring the input voltage
ADC_EventCounter=0;
ADC_FilterP=0;
ChannelState=1;
}
}
else{
if(ChannelState!=2){
//#ifdef INCLUDE_DEBUGGING
Uart0SendString("To output U channel");
//#endif
IO1SET=DT__P1_31; //measuring the output voltage
ADC_EventCounter=0;
ADC_FilterP=0;
ChannelState=2;
if(ADC_Channel_num>0)
{
ADC_Channel_num--;
Channel_Max_Time=2*Channel_Input_Time;
}
else Channel_Max_Time=Channel_Input_Time+Channel_Output_Time;
}
}
}
////(2) in calibration state, don't change the ad channel.
else if(SysRunState==CALIBRATION_STATE){
if(ChannelState!=1){
//#ifdef INCLUDE_DEBUGGING
Uart0SendString("To input U channel");
//#endif
IO1CLR=DT__P1_31; // measuring the input voltage
ADC_EventCounter=0; // before calibration
ADC_FilterP=0;
ChannelState=1;
}
}
////(3) in unknown state
else{
SysRunState=NORMAL_STATE;
//#ifdef INCLUDE_DEBUGGING
Uart0SendString("Change RunState to NORMAL_STATE");
//#endif
}
}
}
/////////////////////////////////////////////////////////////////////////////
void ClearFilter(void)
{
uint8 i;
ADC_Period_mS = AD_SAMPLE_NUM*AD_SPEED_HIGH; //get 100 ad sample within 10/5 seconds
ADCmS_Counter=0;
ADC_EventCounter=0;
ADC_FilterP=0;
ADC_Flag = AD_AVAILABLE+1;
for(i=0;i<AD_FILTER_SIZE;i++){
ADC_U_Filter[i] = 0; ADC_I_Filter[i] = 0;
ADC_WP_Filter[i] = 0; ADC_QP_Filter[i] = 0;
ADC_SP_Filter[i] = 0;
ADC_UL_Filter[i] = 0; ADC_IL_Filter[i] = 0;
}
////
CurInputULevel = 0; CurInputILevel = 0;
CurInput_UU = 0; CurInput_II = 0;
CurInput_WP = 0; CurInput_QP = 0;
CurInput_SP = 0; CurInput_PF = 0;
CurOutputULevel = 0; CurOutputILevel = 0;
CurOutput_U = 0; CurOutput_I = 0;
CurOutput_WP = 0; CurOutput_QP = 0;
CurOutput_SP = 0; CurOutput_PF = 0;
}
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
void TimerInitialize(void)
{
/* 定时器0初始化 */
T0TC = 0; /* 定时器设置为0 */
T0PR = 0; /* 时钟不分频 */
T0MCR = 0x03; /* 设置T0MR0匹配后复位T0TC，并产生中断标志 */
T0MR0 = LPC_FPCLK /1000; /* 1/1000秒钟定时 */
T0TCR = 0x01; /* 启动定时器 */
/* 设置定时器0中断IRQ */
// VICIntSelect = 0x00000000; /* 所有中断通道设置为IRQ中断*/
VICVectCntl5 = 0x20|INT_TIMER0; /* 设置定时器0中断通道分配最高优先级*/
VICVectAddr5 = (uint32)IRQ_Timer0; /* 设置中断服务程序地址*/
VICIntEnable = 1<<INT_TIMER0; /* 使能定时器0中断*/
}
/*************************************************************************
** 函数名称 ：main()
** 函数功能 ：进行3通道电压ADC转换，并把结果转换成电压值，发送到串口。
** 调试说明 ：在config.h中包含stdio.h
**************************************************************************/
void ADC_Init(void)
{
PINSEL1=(PINSEL1&(~(0x03<<26)))|(1<<26); // P0.29连接到AD0.2
PINSEL1=(PINSEL1&(~(0x03<<28)))|(1<<28); // P0.30连接到AD0.3
}
//////////////////////////////////////////////////////////////////////////
void TestADC(void){
uint8 i;
uint32 dbuff=0;
char dbuffer[100];
Uart0SendString("TestADC()");
RF_SendString ("TestADC()");
////
for(i=0;i<AD_SAMPLE_NUM;i++){
ADI[i]=(ADI[i]>>6)&0x3ff; // 10 bits A/D
ADI[i]= ADI[i]*3000; // 参考电压3000 mV
ADI[i]= ADI[i]/1024;
dbuff+= ADI[i]; // A/D sample working buffer for I
}
dbuff=dbuff/AD_SAMPLE_NUM;
sprintf(dbuffer,"ADC(I)=%d(mV)",dbuff);
Uart0SendString(dbuffer); RF_SendString (dbuffer);
////
for(i=0;i<AD_SAMPLE_NUM;i++){
ADU[i]=(ADU[i]>>6)&0x3ff; // 10 bits A/D
ADU[i]= ADU[i]*3000; // 参考电压3000 mV
ADU[i]= ADU[i]/1024;
dbuff+= ADU[i]; // A/D sample working buffer for I
}
dbuff=dbuff/AD_SAMPLE_NUM;
sprintf(dbuffer,"ADC(U)=%d(mV),",dbuff);
Uart0SendString(dbuffer); RF_SendString (dbuffer);
}
//////////////////////////////////////////////////////////////////////////
// end of file //
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -