i2c.c

用dsp的pf脚实现i2c驱动进行数据存储

    }
    return SaveData.fData;
}

/*
void InitMenuItemType(void)
{
    if(GetStatus(ACQ_MENU,MENUITEM1) == 2)	//平均
    	SETMENUTYPE(ACQ_MENU,MENUITEM2,DOUBLE_MENU);
    else
    	SETMENUTYPE(ACQ_MENU,MENUITEM2,NULL_MENU);
}
*/

static bool CheckError(void)
{
short CNT1;
    if(ErrFlag)
    	return false;
    
    for(CNT1 = 0 ;CNT1 <3;CNT1++)
    {
		if(Y_range[CNT1].fVal > arrChVal[LEV5V] || Y_range[CNT1].fVal < arrChVal[LEV2MV])
			return false;
		if (offset0[CNT1]>PANEL_BOT || offset0[CNT1]<PANEL_TOP)
			return false;
    }
	if(X_range[0].Vallevel>LEV50S || X_range[0].Vallevel<LEV5NS)
		return false;
	
	for(CNT1 = 0;CNT1<5;CNT1++)
	{
	    if(mea_data[CNT1][1] > MAXPARAMS)
	    	return false;
	}
   	
/*	if(X_range[1].Vallevel >= X_range[0].Vallevel ||
		X_range[1].Vallevel < MAX(X_range[0].Vallevel-3,LEV100NS)
		)
		return false;*/
	
	return true;
}

short EC_ChanlInfo(void)
{
short Result = 0;

    Result = (ch1_range.active << 4) | (ch2_range.active << 3)
		  | (math_range.active << 2) | (RefA_act << 1)
		  | (RefB_act) | (iUpDwFlag << 5);
    return Result;
}

static void DC_ChanlInfo(short ChanelInfo)
{
    ch1_range.active  = 	(ChanelInfo >> 4)  & 0x01;
    ch2_range.active  = 	(ChanelInfo >> 3)  & 0x01;
    math_range.active = 	(ChanelInfo >> 2)  & 0x01;
    RefA_act 		  = 	(ChanelInfo >> 1)  & 0x01;
    RefB_act		  =		ChanelInfo         & 0x01;
    iUpDwFlag		  = 	(ChanelInfo >> 5)  & 0x07;
    iUpDwFlag 		 %= 	3;	//防止iupdow可能越界
}

extern void a_fine(char which, short gap);
void RecallLastStatus(void)
{
    short CNT1,CNT2,parIndex,temp;
    parIndex = 0;
	
    
    for(CNT1 = 0;CNT1<3;CNT1++)					//CH1,CH2,EDGE_TRIGGER
	    for(CNT2 = 0;CNT2 < 5; CNT2++)
	        SetStatus(CNT1,CNT2,LoadPara(parIndex++));
	
	parIndex = IND_NTSC_SOURCE;       
	for(CNT1 = 1;CNT1<4;CNT1++) 				//NTSC_MENU
		SetStatus(NTSC_MENU,CNT1,LoadPara(parIndex++));
	
	//SetStatus(PULWIDTH_MENU,MENUITEM2,LoadPara(IND_PLUS_SOURCE));	//Plus
	SetStatus(PULWIDTH_MENU,MENUITEM3,LoadPara(IND_PLUS_WHEN));
	SetStatus(PULWIDTH2_MENU,MENUITEM2,LoadPara(IND_PLUS_POLA));
	//SetStatus(PULWIDTH2_MENU,MENUITEM3,LoadPara(IND_PLUS_MODE));
	//SetStatus(PULWIDTH2_MENU,MENUITEM4,LoadPara(IND_PLUS_COUP));
	
	parIndex = IND_MATH_TYPE;
	for(CNT1 = 0;CNT1<3;CNT1++) 
		SetStatus(MATH_MENU,CNT1,LoadPara(parIndex++));			//MATH
	
	SetStatus(FFT_MENU,MENUITEM2,LoadPara(IND_FFT_SOURCE));		//FFT
	SetStatus(FFT_MENU,MENUITEM3,LoadPara(IND_FFT_WINDOW));
	
	SetStatus(ACQ_MENU,MENUITEM1,LoadPara(IND_ACQ_TYPE));
	//SetStatus(ACQ_MENU,MENUITEM2,LoadPara(IND_ACQ_AVERAGE));
	SetStatus(ACQ_MENU,MENUITEM3,LoadPara(IND_ACQ_MODE));
		
	SetStatus(ZOOM_MENU, MENUITEM4, LoadPara(IND_ZOOM_WINSET));
	
	SetStatus(DISP_MENU, MENUITEM1, LoadPara(IND_DISP_TYPE));
	SetStatus(DISP_MENU, MENUITEM2, LoadPara(IND_DISP_FORMAT));
	SetStatus(DISP_MENU, MENUITEM3, LoadPara(IND_DISP_PERSIST));
	
	SetStatus(CURSOR_MENU, MENUITEM1, LoadPara(IND_CURS_TYPE));
	
	SetStatus(WAVES_MENU, MENUITEM1, LoadPara(IND_SAVE_TYPE));
	SetStatus(WAVES_MENU, MENUITEM2, LoadPara(IND_WAVE_SOURCE));
	SetStatus(WAVES_MENU, MENUITEM3, LoadPara(IND_WAVE_DEST));
	
	SetStatus(SETUP_MENU, MENUITEM2, LoadPara(IND_SET_DEST));
	
	//SetStatus(RECORD_MENU, MENUITEM2, LoadPara(IND_REC_SOURCE));
	//SetStatus(RECORD_MENU, MENUITEM4, LoadPara(IND_REC_OPERAT));
	
	//SetStatus(FILTER_MENU, MENUITEM3, LoadPara(IND_FILT_TYPE));
	
	SetStatus(USER_MENU, MENUITEM4, LoadPara(IND_USR_LANG));
	
	SetStatus(REF_MENU, MENUITEM1, LoadPara(IND_REFA_FROM));
	SetStatus(REF_MENU, MENUITEM2, LoadPara(IND_REFB_FROM));

//ZZZ	CoarseFlag = LoadPara(IND_COARSE_FLAG);	
	
	SetStatus(USER1_MENU,MENUITEM3 , LoadPara(IND_PANEL_SEL));
	#ifdef BLACKLCD
		temp = GetStatus(USER1_MENU,MENUITEM3)&0x01;
		SKIN = temp<<1;
	#else
		SKIN = GetStatus(USER1_MENU,MENUITEM3);
	#endif
	
	//ShowAllPara = LoadPara(IND_SHOWALL_PARA);
	
	DTimer=LoadShortPara(IND_Hold_Off);
	DTimer = (DTimer << 16 ) | (LoadShortPara(IND_Hold_Off+1));
	
	ModiTimer(0);		//调整触发适宜时间。
	/////REF LOAD
	DC_ChanlInfo(LoadPara(IND_CHANNEL_ACT));	//读取通道活动信息

	if(RefA_act)
		if(LoadWave(GETREFAPOS,0) != ERR_NORMAL)
			RefA_act = false;
	if(RefB_act)
		if(LoadWave(GETREFBPOS,1) != ERR_NORMAL)
			RefB_act = false;
///////////////////////////////
short i;
	for(i=0;i<5;i++)
	{
		mea_data[i][0] = LoadPara(IND_MEA_STATE + i);
		mea_data[i][1] = LoadPara(IND_MEA_STATE + 5 + i);
	}

	//////////////		
		
	//初始化挡位数据
	for(CNT1=0;CNT1<3;CNT1++)
	{
		Y_range[CNT1].fVal = LoadFloatPara(IND_Y1_FVAL+CNT1*2);
//		Y_range[CNT1].Valunit = LoadPara(IND_Y1_UNIT+CNT1);			//不能存储UNIT，否则逻辑混乱产生5V变成5ps
		offset0[CNT1] = LoadPara(IND_CH1_OFFSET+CNT1);
	}
		
	X_range[0].Vallevel = (int)LoadShortPara(IND_MX_LEVEL);			//主时基
	X_range[1].Vallevel = (int)LoadShortPara(IND_WX_LEVEL);			//视窗时基
	//ZZZ SaveRS();
				
	if(!CheckError())	//检查校正出错
	{
		LoadDefaultSet();					//调用出厂设置
		return;
	}

	//通道初始化动作
	for(CNT1=0;CNT1<2;CNT1++)		//细调初始化
	{
		a_fine(CNT1,0);
		if(!GetStatus(CNT1,MENUITEM3))
			a_modi(CNT1);			//Solve the "5.00 V -> 4.99 V" problem
	}
	
	t_modi();
	
	Tri_range.Vallevel  = (int)LoadShortPara(IND_TRI_LEVEL);	//必须放在a_fine后面
	T_range[0].Vallevel = (int)LoadShortPara(IND_TRI_POS);
	
	std_Tmpos(0);				//主时基水平触发初始数据
	std_Tmpos(1);

	for(CNT1=0;CNT1<3;CNT1++)
		moveY0(CNT1,0);
		
	//////////////////////////////
	//菜单初始化  要注意校验
	if(LoadPara(IND_CUR_MENU) == 0xff)
		cur_menu = (cPopMenu *)0;
	else
		SETMENU(LoadPara(IND_CUR_MENU));
	
	//InitMenuItemType();
	SETMAINW;
}

void RecDefState(void)
{
short CNT1,CNT2,parIndex;

    parIndex = 0;
    
    for(CNT1 = 0;CNT1<3;CNT1++)					//CH1,CH2,EDGE_TRIGGER
	    for(CNT2 = 0;CNT2 < 5; CNT2++)
	        StorePara(GetStatus(CNT1,CNT2),parIndex++);
	
	parIndex = IND_NTSC_SOURCE;       
	for(CNT1 = 1;CNT1<4;CNT1++) 				//NTSC_MENU
		StorePara(GetStatus(NTSC_MENU,CNT1),parIndex++);
	
	StorePara(GetStatus(PULWIDTH_MENU,MENUITEM2),IND_PLUS_SOURCE);	//Plus
	StorePara(GetStatus(PULWIDTH_MENU,MENUITEM3),IND_PLUS_WHEN);
	StorePara(GetStatus(PULWIDTH2_MENU,MENUITEM2),IND_PLUS_POLA);
	StorePara(GetStatus(PULWIDTH2_MENU,MENUITEM3),IND_PLUS_MODE);
	StorePara(GetStatus(PULWIDTH2_MENU,MENUITEM4),IND_PLUS_COUP);
	
	parIndex = IND_MATH_TYPE;
	for(CNT1 = 0;CNT1<3;CNT1++) 
		StorePara(GetStatus(MATH_MENU,CNT1),parIndex++);			//MATH
	
	StorePara(GetStatus(FFT_MENU,MENUITEM2),IND_FFT_SOURCE);		//FFT
	StorePara(GetStatus(FFT_MENU,MENUITEM3),IND_FFT_WINDOW);
	
	StorePara(GetStatus(ACQ_MENU,MENUITEM1),(IND_ACQ_TYPE));
	StorePara(GetStatus(ACQ_MENU,MENUITEM2),(IND_ACQ_AVERAGE));
	
	StorePara(GetStatus(ZOOM_MENU, MENUITEM4), (IND_ZOOM_WINSET));
	
	StorePara(GetStatus(DISP_MENU, MENUITEM1), (IND_DISP_TYPE));
	StorePara(GetStatus(DISP_MENU, MENUITEM2), (IND_DISP_FORMAT));
	StorePara(GetStatus(DISP_MENU, MENUITEM3), (IND_DISP_PERSIST));
	
	StorePara(GetStatus(CURSOR_MENU, MENUITEM1), (IND_CURS_TYPE));
	
	StorePara(GetStatus(WAVES_MENU, MENUITEM1), (IND_SAVE_TYPE));
	StorePara(GetStatus(WAVES_MENU, MENUITEM2), (IND_WAVE_SOURCE));
	StorePara(GetStatus(WAVES_MENU, MENUITEM3), (IND_WAVE_DEST));
	
	StorePara(GetStatus(SETUP_MENU, MENUITEM2), (IND_SET_DEST));
	
	StorePara(GetStatus(RECORD_MENU, MENUITEM2), (IND_REC_SOURCE));
	StorePara(GetStatus(RECORD_MENU, MENUITEM4), (IND_REC_OPERAT));
	
	StorePara(GetStatus(FILTER_MENU, MENUITEM3), (IND_FILT_TYPE));
	
	StorePara(GetStatus(USER_MENU, MENUITEM4), (IND_USR_LANG));
	
	StorePara(GetStatus(REF_MENU, MENUITEM1), (IND_REFA_FROM));
	StorePara(GetStatus(REF_MENU, MENUITEM2), (IND_REFB_FROM));
	
//ZZZ	StorePara(CoarseFlag, IND_COARSE_FLAG);
	StorePara(GetStatus(USER1_MENU, MENUITEM3), IND_PANEL_SEL);
	
	for(CNT1 = 0;CNT1 < 3;CNT1++)
	{
		StoreFloatPara(Y_range[CNT1].fVal,IND_Y1_FVAL+2*CNT1);
		StorePara(Y_range[CNT1].Valunit,IND_Y1_UNIT+CNT1);
		StorePara(offset0[CNT1],IND_CH1_OFFSET + CNT1);			//偏移数据
	}
	
	StoreShortPara((short)X_range[0].Vallevel,IND_WX_LEVEL);			//视窗时基
	StoreShortPara((short)X_range[1].Vallevel,IND_MX_LEVEL);			//主时基
	
	StoreShortPara((short)(T_range[0].Vallevel),IND_TRI_POS);
	StoreShortPara((short)Tri_range.Vallevel,IND_TRI_LEVEL);
	
	StorePara(ShowAllPara,IND_SHOWALL_PARA);
	  
	StorePara(EC_ChanlInfo(),IND_CHANNEL_ACT);
	
	int i;
	for(i=0;i<5;i++)	
	{
		StorePara(mea_data[i][0],IND_MEA_STATE + i);
		StorePara(mea_data[i][1],IND_MEA_STATE + 5 + i);
	}
}

void ProcSave(void)
{
   /*
    static short cnt = 0;
    int temp=0;
	if(kscan)
	{
		cnt = 0;
		return;
	}
	
    if(cnt>30)
    {
		cnt = 0;
		if(ChangeFlag.TriLel_Change == true)		//Trigger level
		{
			RT_RECORD_SHT(Tri_range.Vallevel,IND_TRI_LEVEL);
			ChangeFlag.TriLel_Change = false;
		}
		if(ChangeFlag.TriPos_Change == true)		//Trigger Position
		{
			RT_RECORD_SHT((T_range[0].Vallevel),IND_TRI_POS);
			ChangeFlag.TriPos_Change = false;
		}
		if(ChangeFlag.CH1_Offset_Change == true)	//CH1 Offset
		{
			RT_RECORD(offset0[0],IND_CH1_OFFSET);
			ChangeFlag.CH1_Offset_Change = false;
		}
		if(ChangeFlag.CH2_Offset_Change == true)	//CH2 offset
		{
			RT_RECORD(offset0[1],IND_CH2_OFFSET);
			ChangeFlag.CH2_Offset_Change = false;
		}
		if(ChangeFlag.MATH_Offset_Change == true)	//Math offset
		{
			RT_RECORD(offset0[2],IND_MATH_OFFSET);
			ChangeFlag.MATH_Offset_Change = false;
		}
		if(ChangeFlag.Hold_Off_Change == true)	//  Hold off
		{	
			StoreShortPara((DTimer>>16)&0xffff,IND_Hold_Off);	//high16				
			StoreShortPara(DTimer&0xffff,IND_Hold_Off+1);
			ChangeFlag.Hold_Off_Change = false;
		}
    }
    else
		cnt++;
		*/
}

///////////////////////////////////////////////////////////////////////////////////
void StoreGeneral(char *src, unsigned short len, char dest)
{
char i;
short RecordStart;
	RecordStart = PARA_START+dest*2;
    for (i=0; i<len; i++)
    {
        //I2C_write(RecordStart+i,0x5a);	//存高位		//校验位
    	I2C_write(RecordStart+i, src[i]);	//存低位
    }
}

void LoadGeneral(char *src, unsigned short len, char dest)
{
char i;
short RecordStart;

	RecordStart = PARA_START+dest*2;
    for (i=0; i<len; i++)
    {
        src[i]=I2C_read(RecordStart+i);
    }
}