ycc_driver.c

在SoC单片机上实现对内部Flash的操作,基于uc/os-II.

	memset(tmpBuf,0,MEMBLKSIZE);
	if(nand_memory_read(tmpBuf,MEMBLKSIZE,SYSPARASECTION)!=1 ||
					0!=memcmp(tmpBuf,SYSPARAFLAG,sizeof(SYSPARAFLAG)-1))
	{
		if(nand_memory_read(tmpBuf,MEMBLKSIZE,SYSBACKSECTION)!=1 || 
					0!=memcmp(tmpBuf,SYSBACKFLAG,sizeof(SYSBACKFLAG)-1))	
		{
		#ifdef __YCC_DEBUG
			ycc_printf("when get para,read failed!\n");
		#endif
			*iErr|=0x80;
		}
	}
	
	unsigned char *pBuf=NULL;
	if(FRMINFOID & itemID)
	{
		pBuf=tmpBuf+FRMINFOOFFSET;
		if(0!=memcmp(pBuf,FRMINFOFLAG,sizeof(FRMINFOFLAG)-1))
		{
			yccpara.TGAP=15;

			sprintf(yccpara.frmPasswd,"123456");
			//yccno默认值为999999
			yccpara.yccno[0]=0x39;
			yccpara.yccno[1]=0x39;
			yccpara.yccno[2]=0x39;
			yccpara.yccno[3]=0x39;
			yccpara.yccno[4]=0x39;
			yccpara.yccno[5]=0x39;

			yccpara.frmIP[0]=192;
			yccpara.frmIP[1]=168;
			yccpara.frmIP[2]=0;
			yccpara.frmIP[3]=1;
			

			sprintf(yccpara.frmTel,"CMNET");
			yccpara.frmPort=8501;		
			*iErr|=FRMINFOID;
		}
		else
		{
			pBuf=tmpBuf+FRMINFOOFFSET+sizeof(FRMINFOFLAG)-1;
			memcpy(&yccpara,pBuf,sizeof(yccpara));
		}
	}
	
	if(METERINFOID & itemID)
	{
		if(p_meter)
			clear_meter_list();
		
		METER_PARA_PTR *p=NULL;
		pBuf=tmpBuf+METERINFOOFFSET;
		int i=0,flag=0;
	#ifdef __YCC_DEBUG
		/*int t=0;
		unsigned char Testbuf[]=METERINFOFLAG;
		for(t=0;t<sizeof(METERINFOFLAG)-1;t++)
			ycc_printf("%02x,%02x\n",*(pBuf+t),Testbuf[t]);*/
	#endif
		if(0==memcmp(pBuf,METERINFOFLAG,sizeof(METERINFOFLAG)-1))
		{
		#ifdef __YCC_DEBUG
			//ycc_printf("GET METER LIST\n");
		#endif
			pBuf=pBuf+sizeof(METERINFOFLAG)-1;
			for(i=0;i<4;i++)
			{
				if(0==memcmp(pBuf,ENDMETERSEC,sizeof(ENDMETERSEC)-1))
					flag=1;//fangzhi no endmeterinfo to death pc
				pBuf+=sizeof(METER_PARA_PTR);
			}
			pBuf=tmpBuf+METERINFOOFFSET+sizeof(METERINFOFLAG)-1;
			p=(METER_PARA_PTR *)malloc(sizeof(METER_PARA_PTR));
			
			while(1)
			{
				if(0==flag)
				{
					break;
				}
				
				if(0==memcmp(pBuf,ENDMETERSEC,sizeof(ENDMETERSEC)-1))
					break;
				
				if(!p)
				{
				#ifdef __YCC_DEBUG	
					//ycc_printf("cann't malloc memory for meter list\n");
				#endif
					break;
					*iErr|=METERINFOID;
				}
				memcpy(p,pBuf,sizeof(METER_PARA_PTR));

				p->status=0;
				p->next=p_meter;
				p->ASlTime=0;
				p->BSlTime=0;
				p->CSlTime=0;
				if((((p->mpara.cbMode)&0x80)!=0x80) && 
													(p->mpara.cbMode!=0))
				{
					p_meter=p;
					p=(METER_PARA_PTR *)malloc(sizeof(METER_PARA_PTR));	
				}
				pBuf+=sizeof(METER_PARA_PTR);
			}
			if(NULL!=p)
				free(p);
		}
	}
	
	if(ALMINFOID & itemID)
	{
		if(p_alm)
			clear_alarm_list();
			
		METER_ALARM_PTR *pp;
		pBuf=tmpBuf+ALMINFOOFFSET;
		int j=0,flag1=0;	
		time_t curt;

		if(0==memcmp(pBuf,ALMINFOFLAG,sizeof(ALMINFOFLAG)-1))
		{
			pBuf=pBuf+sizeof(ALMINFOFLAG)-1;
			for(j=0;j<4;j++)
			{
				if(0==memcmp(pBuf,ENDALMSEC,sizeof(ENDALMSEC)-1))
					flag1=1;//fangzhi no endmeterinfo to death pc
				pBuf+=sizeof(METER_ALARM_PTR);
			}
			pBuf=tmpBuf+ALMINFOOFFSET+sizeof(ALMINFOFLAG)-1;
			pp=(METER_ALARM_PTR *)malloc(sizeof(METER_ALARM_PTR));
			
			while(1)
			{			
				if(0==flag1)
					break;
				if(0==memcmp(pBuf,ENDALMSEC,sizeof(ENDALMSEC)-1))
					break;			
				if(!pp)
				{
				#ifdef __YCC_DEBUG
					ycc_printf("cann't malloc memory for alm listr!\n");
				#endif
					break;
					*iErr|=ALMINFOID;
				}
				memcpy(pp,pBuf,sizeof(METER_ALARM_PTR));
				pp->next=p_alm;
				curt=time(NULL);
				pp->mpara.FLevelStartTime=curt;
				pp->mpara.FLevelStartTime1=curt;
				p_alm=pp;
				pp=(METER_ALARM_PTR*)malloc(sizeof(METER_ALARM_PTR));
				pBuf+=sizeof(METER_ALARM_PTR);
			}
			if(NULL!=pp)
				free(pp);
		}
	}
	
	if(LOGRECINFOID & itemID)
	{
		pBuf=tmpBuf+LOGNUMOFFSET;
		if(0==memcmp(pBuf,LOGINFOFLAG,sizeof(LOGINFOFLAG)-1))
		{
			pBuf=tmpBuf+LOGNUMOFFSET+sizeof(LOGINFOFLAG)-1;
			iErrLogRec=*pBuf;
			iRunLogRec=*(pBuf+1);
			iAlmLogRec=*(pBuf+2);
			if(iErrLogRec<0 || iErrLogRec>256)
				iErrLogRec=0;
			if(iRunLogRec<0 || iRunLogRec>256)
				iRunLogRec=0;
			if(iAlmLogRec<0 || iAlmLogRec>256)
				iAlmLogRec=0;
		}
		else
		{
			iErrLogRec=0;
			iRunLogRec=0;
			iAlmLogRec=0;
			*iErr|=LOGRECINFOID;
		}
	}
	
	if(CURDATABLKID & itemID)
	{
		time_t t1,t2;
		
		struct tm dt;
		struct tm *CurDate;
		dt.tm_year=2005-1900;
		dt.tm_mon=0;
		dt.tm_mday=1;
		dt.tm_hour=0;
		dt.tm_min=0;
		dt.tm_sec=0;
		t2=mktime(&dt);
		
		t1=time(NULL);
		CurDate=localtime(&t1);
		
		memset(tmpBuf,0,MEMBLKSIZE);
		unsigned int nMemBlk=0;
		unsigned short days=0;
		unsigned int iCurYear,iCurMon;
		days=labs((unsigned long)difftime(t1,t2))/(60*60*24);
		nMemBlk=(days%125)*24+1;	//24 memblks nand flash size per day
		if(1==nand_memory_read(tmpBuf,10,nMemBlk))
		{
			iCurYear=tmpBuf[6];
			iCurYear=(iCurYear<<8) | tmpBuf[5];
			if(iCurYear==(CurDate->tm_year+1900) && tmpBuf[7]==(CurDate->tm_mon+1) &&
								tmpBuf[8]==CurDate->tm_mday)
			{
				iCurBlk=(int)tmpBuf[0];
			}
			else
				iCurBlk=0;
			if(iCurBlk<0 || iCurBlk>96)
				iCurBlk=0;
		}
		else
		{
			iCurBlk=0;
			*iErr|=CURDATABLKID;
		}
	#ifdef __YCC_DEBUG
		ycc_printf("in get para,days:%d,iCurBlk:%d\n",days,iCurBlk);
	#endif
	}
	
	free(tmpBuf);
	LJC_Mutex_unlock(MemLock);
	return 0;
}


int ycc_save_para(int item,unsigned char *iErr)
{
#ifdef __YCC_DEBUG
	ycc_printf("start save para......\n");
#endif
	*iErr=0;
	LJC_Mutex_lock(MemLock);
	unsigned char *buf,*SysBuf=NULL;
	buf=malloc(MEMBLKSIZE);
	if(NULL==buf)
	{
	#ifdef __YCC_DEBUG
		ycc_printf("when save sys parameters,failed!\n");
	#endif
		LJC_Mutex_unlock(MemLock);
		return 1;
	}
	
	memset(buf,0,MEMBLKSIZE);	
	if(nand_memory_read(buf,MEMBLKSIZE,SYSPARASECTION)!=1 ||
					0!=memcmp(buf,SYSPARAFLAG,sizeof(SYSPARAFLAG)-1))
	{
		if(nand_memory_read(buf,MEMBLKSIZE,SYSBACKSECTION)!=1 ||
					0!=memcmp(buf,SYSBACKFLAG,sizeof(SYSBACKFLAG)-1))	
		{
		#ifdef __YCC_DEBUG
			ycc_printf("when save para,read failed!\n");
		#endif
			SysBuf=(unsigned char*)SYSPARAFLAG;
			memset(buf,0,MEMBLKSIZE);
		  	memcpy(buf,SysBuf,sizeof(SYSPARAFLAG)-1);
			*iErr|=0x80;
		}
	}
	
	unsigned char *pBuf=NULL;	
	if(FRMINFOID & item)//save yccpara parameters
	{
		pBuf=buf+FRMINFOOFFSET;
		if(0!=memcmp(pBuf,FRMINFOFLAG,sizeof(FRMINFOFLAG)-1))
		{
			memcpy(pBuf,FRMINFOFLAG,sizeof(FRMINFOFLAG)-1);
			*iErr|=FRMINFOID;
		}
		
		pBuf=pBuf+sizeof(FRMINFOFLAG)-1;
		memcpy(pBuf,&yccpara,sizeof(yccpara));
		if(CHANGEIP&item)
		{
			unsigned char IPbuf[20];
			memset(IPbuf,0,sizeof(IPbuf));
			sprintf(IPbuf,"%d.%d.%d.%d",
				yccpara.frmIP[0],yccpara.frmIP[1],yccpara.frmIP[2],yccpara.frmIP[3]);
		
			change_rs_addr(IPbuf,false);	
			change_rs_port(yccpara.frmPort,true);	
		}
		reset_tcp_ppp();
	}
	
	if(METERINFOID & item)//save meters parameters
	{
		METER_PARA_PTR *p=NULL;
		pBuf=buf+METERINFOOFFSET;
		if(0!=memcmp(pBuf,METERINFOFLAG,sizeof(METERINFOFLAG)-1))
		{
			memcpy(pBuf,METERINFOFLAG,sizeof(METERINFOFLAG)-1);
			*iErr|=METERINFOID;
		}
		
		pBuf=pBuf+sizeof(METERINFOFLAG)-1;
		p=p_meter;
		int iMCounter=0;
		while(NULL!=p)
		{
		#ifdef __YCC_DEBUG
			//ycc_printf("SAVE METER LIST\n");
		#endif	
			memcpy(pBuf,p,sizeof(METER_PARA_PTR));
			p=p->next;
			pBuf+=sizeof(METER_PARA_PTR);
			iMCounter++;
			if(iMCounter>4)
				break;
		}
		memcpy(pBuf,ENDMETERSEC,sizeof(ENDMETERSEC)-1);
	}
	
	if(ALMINFOID & item)
	{
		METER_ALARM_PTR *pp=NULL;
		pBuf=buf+ALMINFOOFFSET;
		if(0!=memcmp(pBuf,ALMINFOFLAG,sizeof(ALMINFOFLAG)-1))
		{
			memcpy(pBuf,ALMINFOFLAG,sizeof(ALMINFOFLAG)-1);
			*iErr|=ALMINFOID;
		}
		
		pBuf=pBuf+sizeof(ALMINFOFLAG)-1;		
		pp=p_alm;
		int iAlmCounter=0;
	
		while(NULL!=pp)
		{
			memcpy(pBuf,pp,sizeof(METER_ALARM_PTR));
		#ifdef __YCC_DEBUG
			//ycc_printf("type:%d\n",pp->mpara.st.type);
		#endif			
			pp=pp->next;
			pBuf+=sizeof(METER_ALARM_PTR);
			iAlmCounter++;
			if(iAlmCounter>4)
				break;
		}
		memcpy(pBuf,ENDALMSEC,sizeof(ENDALMSEC)-1);
	}
	
	if(LOGRECINFOID & item)
	{
		pBuf=buf+LOGNUMOFFSET;
		if(0!=memcmp(pBuf,LOGINFOFLAG,sizeof(LOGINFOFLAG)-1))
		{
			memcpy(pBuf,LOGINFOFLAG,sizeof(LOGINFOFLAG)-1);
			*iErr|=LOGRECINFOID;
		}
		
		pBuf=pBuf+sizeof(LOGINFOFLAG)-1;		
		*pBuf=(unsigned char)iErrLogRec;
		*(pBuf+1)=(unsigned char)iRunLogRec;
		*(pBuf+2)=(unsigned char)iAlmLogRec;
	}
	
	nand_memory_write(buf,MEMBLKSIZE,SYSPARASECTION);
	SysBuf=(unsigned char*)SYSBACKFLAG;
	memcpy(buf,SysBuf,sizeof(SYSBACKFLAG)-1);
	nand_memory_write(buf,MEMBLKSIZE,SYSBACKSECTION);
	
	if(CURDATABLKID & item)
	{
		time_t t1,t2;
		t1=time(NULL);
		
		struct tm dt;
		dt.tm_year=2005-1900;
		dt.tm_mon=0;
		dt.tm_mday=1;
		dt.tm_hour=0;
		dt.tm_min=0;
		dt.tm_sec=0;
		t2=mktime(&dt);
		
		memset(buf,0,MEMBLKSIZE);
		unsigned int MemBlk=0;
		unsigned short days=0;
		days=labs((unsigned long)difftime(t1,t2))/(60*60*24);
		MemBlk=(days%125)*24+1;	//24 memblks nand flash size per day
	#ifdef __YCC_DEBUG
		ycc_printf("when save current,days:%d,blk:%d\n",days,MemBlk);
	#endif
		if(1==nand_memory_read(buf,MEMBLKSIZE,MemBlk))
		{
			if(iCurBlk>=0 && iCurBlk<95)
			{
				buf[0]=(unsigned char)iCurBlk;
				if(0==nand_memory_write(buf,MEMBLKSIZE,MemBlk))
				{
					if(0==nand_memory_write(buf,MEMBLKSIZE,MemBlk))
						*iErr|=CURDATABLKID;
				}
			}
			else
				*iErr|=CURDATABLKID;
		}
		else
			*iErr|=CURDATABLKID;
	}
#ifdef __YCC_DEBUG
	ycc_printf("save para end\n");
#endif
	free(buf);
	LJC_Mutex_unlock(MemLock);
	return 0;
}


void clear_meter_list(void)
{
	METER_PARA_PTR * p;
	p=p_meter;
	while(p)
	{
		p_meter=p->next;
		free(p);
		p=p_meter;
	}
	p_meter=NULL;
}

void clear_alarm_list(void)
{
	METER_ALARM_PTR *p;
	p=p_alm;
	while(p)
	{
		p_alm=p->next;
		free(p);
		p=p_alm;
	}
	p_alm=NULL;
}
/*
int AddItemOption(char* key,int type,unsigned char *value,int len)
{
	return 0;
	struct config_option *opt;
	LJC_Mutex_lock(MemLock);

	if(CONFIG_STRING==type) 
	{
		opt = (struct config_option*) malloc(sizeof(struct config_option) + MAX_STRING_LENGTH);
		if(!opt)
		{
			ljc_memory_lack_handler();
		}
		memset(opt, 0, sizeof(struct config_option) + MAX_STRING_LENGTH);
		opt->dflt = (unsigned long)((unsigned char*)opt + sizeof(struct config_option));		
	}	
	else
	{
		opt = (struct config_option*) malloc(sizeof(struct config_option));
		if (!opt)
		{
			ljc_memory_lack_handler();
		}
		memset(opt, 0, sizeof(struct config_option));
	}	
	
	opt->key=key;
	opt->type = type;
	if(CONFIG_STRING==type)
	{
		memcpy((unsigned char*)(opt->dflt),value,len);
	}
	else 
	{
		if(len<4)
		{
			ycc_printf(" error var len %d .\n", len);
			LJC_Mutex_unlock(MemLock);
			return -1;
		}
		memcpy(&opt->dflt,value,len);
	}
		
	//opt.enable =enable;
	//opt.enable_sense = sense;
	//opt.title = title;
	
	if(!ljc_flash_add_config(opt,true))
	{
		ycc_printf("add config failed!\n");
		free(opt);
		LJC_Mutex_unlock(MemLock);
		return -1;
	}
	free(opt);
	LJC_Mutex_unlock(MemLock);
	return 0;	
}
*/
/*
int GetItemValue(char* key,int type,int *value)
{
	LJC_Mutex_lock(MemLock);
	if(!ljc_flash_get_config(key,value,type))
	{
		ycc_printf("get parameter error!\n");
		LJC_Mutex_unlock(MemLock);
		return -1;
	}
	
	LJC_Mutex_unlock(MemLock);*/
	/*
	if ((ret = ljc_flash_get_config("voice_num2", val, CONFIG_STRING)))
        {
        	strcpy(ljc_admin_number2, (char*)(*val));
        	gt08_printf("get admin number2 ok =%s\n",ljc_admin_number2);
        	
        }*/
	
	/*return 0;
}*/

#ifndef __ECOS
// 1 is ok and 0 is error
int nand_memory_read(unsigned char *buf, unsigned long len, unsigned int block)
{
#ifdef __YCC_DEBUG
	ycc_printf("in nand_memory_read,block:%d\n",block);
#endif	
	if(len<0 || len>MEMBLKSIZE)
	{
		ycc_printf("in nand_read,data too long!\n");
		return 0;
	}
	if(block<0 || block>nand_memory_valid())
	{
		ycc_printf("in nand_read,read block over boundary,blk:%d!\n",block);
		return 0;
	}
		
	FILE *fp;
	fp=fopen("/home/test.dat","rb");
	if(!fp)
	{
		ycc_printf("in nand_read,open file failed\n");
		return 0;
	}
	fseek(fp,(block-1)*MEMBLKSIZE,SEEK_SET);//file from 0,
	if(fread(buf,1,len,fp)!=len)
	{
		fclose(fp);
		ycc_printf("in nand_read,read failed\n");
		return 0;
	}
	fclose(fp);
	
	return 1;
}

// 1 is ok and 0 is error
int nand_memory_write(unsigned char *buf, unsigned long len, unsigned int block)
{
	//boundary check
#ifdef __YCC_DEBUG
	ycc_printf("in nand_memory_write,block:%d\n",block);
#endif
	if(len<0 || len>MEMBLKSIZE)
	{
		ycc_printf("write data too long!\n");
		return 0;
	}
	
	if(block<0 || block>nand_memory_valid())
	{
		ycc_printf("write block over boundary!\n");
		return 0;
	}

	FILE *fp;	
	fp=fopen("/home/test.dat","rb+");
	if(!fp)
	{
		ycc_printf("in drive,open file err!\n");
		return 0;
	}
	fseek(fp,(block-1)*MEMBLKSIZE,SEEK_SET);
	
	if(fwrite(buf,1,len,fp)!=len)
	{
		ycc_printf("in drive,write file err!\n");
		fclose(fp);
		return 0;
	}
	
	fclose(fp);
	return 1;
}

int get_12v_status()
{
	return 0;
}

void ds1302_set_time(unsigned char sec,unsigned char min,unsigned char hr,
			unsigned char date,unsigned char mon, unsigned char week, unsigned char yr)
{
	struct tm dt;
	time_t t;
	dt.tm_year=yr+100;
	dt.tm_mon=mon-1;
	dt.tm_mday=date;
	dt.tm_hour=hr;
	dt.tm_min=min;
	dt.tm_sec=sec;
	
	t=mktime(&dt);
	stime(&t);
}
void ds1302_get_time(unsigned char *sec,unsigned char *min,unsigned char *hr,
		unsigned char *date,unsigned char *mon, unsigned char *week, unsigned char *yr)
{
	time_t t;
	struct tm *dt;
	
	t=time(NULL);
	dt=localtime(&t);
	*yr=dt->tm_year-100;
	*mon=dt->tm_mon+1;
	*date=dt->tm_mday;
	*hr=dt->tm_hour;
	*min=dt->tm_min;
	*sec=dt->tm_sec;
	*week=dt->tm_wday;
}
void firmware_up_data(void *buf, int len)
{
	if(NULL==buf)
	{
	#ifdef __YCC_DEBUG
		ycc_printf("when update firmware,buf is null\n");
	#endif
		return;
	}
	FILE *fp;
	fp=fopen("/home/firmware","wb");
	if(NULL==fp)
	{
	#ifdef __YCC_DEBUG
		ycc_printf("when save updatefile,open file err!\n");
	#endif
		return;
	}
	if(fwrite(buf,1,len,fp)!=len)
	{
	#ifdef __YCC_DEUBG
		ycc_printf("when save updatefile,write failed!\n");
	#endif
		fclose(fp);
		return;
	}
	fclose(fp);
	system_reset();
	return;
}
#endif