exchange.bak

工业控制,模拟量,数字量转化,采集数据,有模拟量,有数字量

void saveMcheck(unsigned char *data)
{
   write_backup_ram(29002,data[1]);
   write_backup_ram(29003,data[2]);
   write_backup_ram(29004,data[3]);
   write_backup_ram(29005,data[4]);
   write_backup_ram(29006,data[5]);
   write_backup_ram(29007,data[6]);
   write_backup_ram(29008,data[7]);
   write_backup_ram(29009,data[8]);
   write_backup_ram(29009,data[9]);
}
void savemobil(unsigned char *data,int position)
{
int i=0;
data++;
if (position==0) while (i<11)
  {
	 write_backup_ram(29970+i,*data);
     data++;
     i++;
  }
i=0;
if (position==1) while (i<11)
  {
     write_backup_ram(29981+i,*data);
     data++;
     i++;
  }
}

void loadmobil(char *mobil,int position)
{
int i=0;
switch (position)
  {
    case 0: while (i<11)
     {
	*mobil=read_backup_ram(29970+i);
	mobil++;
	i++;
     }
     break;
    case 1: while (i<11)
     {
     *mobil=read_backup_ram(29981+i);
     mobil++;
     i++;
     }
     break;
  }
*mobil=0;
}

int streql(char *str1,char *str2)
{
   while ((*str1==*str2) && (*str1))
      {
      str1++;
      str2++;
      }
   return ((*str1==NULL) && (*str2==NULL));
}
int sumcheck(unsigned char *check,int checklong)
{
int i;unsigned char ch=0;
for (i=0;i<checklong;i++) ch=(ch+(*(check+i)))%255;
if (*(check+i)==ch) return(1);
return(0);
}

char *strstr_rem(char *string,char *substring)
{
  int i,j,k,loc=-1;
  for (i=0;string[i] && (loc==-1);i++)
  for (j=i,k=0;string[j]==substring[k];j++,k++)
  if (!substring[k+1]) loc=i;
  if (loc!=-1)
    {
      for (k=0;substring[k];k++);
      for (j=loc,i=loc+k;string[i];j++,i++) string[j]=string[i];
      string[j]=NULL;
    }
    return(string);
}

double minute_time(char y, char m, char d,char h, char mi,char se)
{
	double mid,dy,dm,dd,dh,dmi,dse;
	dy=y;dm=m;dd=d;dh=h;dmi=mi;dse=se;
	mid= ((dmi+(dh+(dd+(dm+dy*12.0)*31.0)*24.0)*60.0)*60.0)+dse;
	return(mid);
}
//exchange float to char
unsigned char f_t_c(float flt,int arrno)
{
  unsigned char *mid;
  mid= &flt;
  mid=mid+arrno;
  return (*mid);
}

//exchange char to float
float c_t_f(unsigned char *ch)
{
  float *mid;
  mid=ch;
  return (*mid);
}

//exchange integer to char
unsigned char i_t_c(int flt,int arrno)
{
  unsigned char *mid;
  mid=&flt;
  mid=mid+arrno;
  return (*mid);
}
//exchange char to integer
int c_t_i(unsigned char ch[1])
{
  int *mid;
  mid=ch;
  return *mid;
}

//add new record to backupram
void record_add(unsigned char pk,unsigned int what,float value,float flow,
		unsigned char y,unsigned char m,unsigned char d,
		unsigned char h,unsigned char mi,unsigned char s)
{
unsigned char mid_char_int[1];
unsigned char j;
unsigned int end_address;
//read end address
mid_char_int[0]=read_backup_ram(30000);
mid_char_int[1]=read_backup_ram(30001);
end_address=c_t_i(mid_char_int);
//deal with address
end_address+=17;
if (end_address==17000)
   {
     end_address=0;
     write_backup_ram(30002,0xAA);
   }
//save updata end address
write_backup_ram(30000,i_t_c(end_address,0));
write_backup_ram(30001,i_t_c(end_address,1));
//save record
write_backup_ram(end_address,pk);
write_backup_ram(end_address+1,i_t_c(what,0));
write_backup_ram(end_address+2,i_t_c(what,1));
write_backup_ram(end_address+3,f_t_c(value,0));
write_backup_ram(end_address+4,f_t_c(value,1));
write_backup_ram(end_address+5,f_t_c(value,2));
write_backup_ram(end_address+6,f_t_c(value,3));
write_backup_ram(end_address+7,f_t_c(flow,0));
write_backup_ram(end_address+8,f_t_c(flow,1));
write_backup_ram(end_address+9,f_t_c(flow,2));
write_backup_ram(end_address+10,f_t_c(flow,3));
write_backup_ram(end_address+11,y);
write_backup_ram(end_address+12,m);
write_backup_ram(end_address+13,d);
write_backup_ram(end_address+14,h);
write_backup_ram(end_address+15,mi);
write_backup_ram(end_address+16,s);
}

void cur_record(unsigned char *pk,unsigned int *what,float *value,float *flow,
		unsigned char *y,unsigned char *m,unsigned char *d,
		unsigned char *h,unsigned char *mi,unsigned char *s)
//read current record
{
unsigned int end_address;
unsigned char mid_char_int[1];
unsigned char mid_char_flt[3];
//read end address
mid_char_int[0]=read_backup_ram(30000);
mid_char_int[1]=read_backup_ram(30001);
end_address=c_t_i(mid_char_int);

//read  information
*pk=read_backup_ram(end_address);
mid_char_int[0]=read_backup_ram(end_address+1);
mid_char_int[1]=read_backup_ram(end_address+2);
*what=c_t_i(mid_char_int);
mid_char_flt[0]=read_backup_ram(end_address+3);
mid_char_flt[1]=read_backup_ram(end_address+4);
mid_char_flt[2]=read_backup_ram(end_address+5);
mid_char_flt[3]=read_backup_ram(end_address+6);
*value=c_t_f(&mid_char_flt);
mid_char_flt[0]=read_backup_ram(end_address+7);
mid_char_flt[1]=read_backup_ram(end_address+8);
mid_char_flt[2]=read_backup_ram(end_address+9);
mid_char_flt[3]=read_backup_ram(end_address+10);
*flow=c_t_f(&mid_char_flt);
*y=read_backup_ram(end_address+11);
*m=read_backup_ram(end_address+12);
*d=read_backup_ram(end_address+13);
*h=read_backup_ram(end_address+14);
*mi=read_backup_ram(end_address+15);
*s=read_backup_ram(end_address+16);
}

void del_new(void)
{
//read new address
unsigned int new_address;
unsigned char mid_char_int[1];
mid_char_int[0]=read_backup_ram(30003);
mid_char_int[1]=read_backup_ram(30004);
new_address=c_t_i(mid_char_int);
new_address=(new_address+17)%17000l;
write_backup_ram(30003,i_t_c(new_address,0));
write_backup_ram(30004,i_t_c(new_address,1));
}

int new_record(unsigned char *pk,unsigned int *what,float *value,float *flow,
		unsigned char *y,unsigned char *m,unsigned char *d,
		unsigned char *h,unsigned char *mi,unsigned char *s)
//read new record
{
unsigned int end_address;
unsigned int new_address;
unsigned char mid_char_int[1];
unsigned char mid_char_flt[3];
//read end address
mid_char_int[0]=read_backup_ram(30000);
mid_char_int[1]=read_backup_ram(30001);
end_address=c_t_i(mid_char_int);
//read new address
mid_char_int[0]=read_backup_ram(30003);
mid_char_int[1]=read_backup_ram(30004);
new_address=c_t_i(mid_char_int);
//printf("new address is %d and current address is %d\n",new_address,end_address);
if (new_address==end_address) return (0);
new_address+=17;
//read  information
*pk=read_backup_ram(new_address);
mid_char_int[0]=read_backup_ram(new_address+1);
mid_char_int[1]=read_backup_ram(new_address+2);
*what=c_t_i(mid_char_int);
mid_char_flt[0]=read_backup_ram(new_address+3);
mid_char_flt[1]=read_backup_ram(new_address+4);
mid_char_flt[2]=read_backup_ram(new_address+5);
mid_char_flt[3]=read_backup_ram(new_address+6);
*value=c_t_f(&mid_char_flt);
mid_char_flt[0]=read_backup_ram(new_address+7);
mid_char_flt[1]=read_backup_ram(new_address+8);
mid_char_flt[2]=read_backup_ram(new_address+9);
mid_char_flt[3]=read_backup_ram(new_address+10);
*flow=c_t_f(&mid_char_flt);
*y=read_backup_ram(new_address+11);
*m=read_backup_ram(new_address+12);
*d=read_backup_ram(new_address+13);
*h=read_backup_ram(new_address+14);
*mi=read_backup_ram(new_address+15);
*s=read_backup_ram(new_address+16);
return (1);
}

//seek fit record.if seek all,return 0,else return 1.
int seek_record(unsigned char *pk,unsigned int *what,float *value,float *flow,
		unsigned char *y,unsigned char *m,unsigned char *d,
		unsigned char *h,unsigned char *mi,unsigned char *s,
		char fy,char fm,char fd,char fh,char fmi,char fs,
		char ty,char tm,char td,char th,char tmi,char ts)
//find record
{
static unsigned int seek_address=0;
int mid_address;
double mid_time;
double f_time;
double t_time;
unsigned char mid_char_int[1];
unsigned char mid_char_flt[3];
printf("i am seeking\n");
while (seek_address++<1000)
  {
	WDT_clear();
	//read  information
	printf("seek %x\n",seek_address);
	mid_address=seek_address*17;
	*m=read_backup_ram(mid_address+12);
	//if ((*m)==0) continue;
	*y=read_backup_ram(mid_address+11);
	*d=read_backup_ram(mid_address+13);
	*h=read_backup_ram(mid_address+14);
	*mi=read_backup_ram(mid_address+15);
	*s=read_backup_ram(mid_address+16);
	//printf("midtime:    ");
	mid_time=minute_time(*y,*m,*d,*h,*mi,*s);
	//printf("fromtime:   ");
	f_time=minute_time(fy,fm,fd,fh,fmi,fs);
	//printf("totime:     ");
	t_time=minute_time(ty,tm,td,th,tmi,ts);
       //printf("from y:%x  mid y:%x  to y:%x\n",fy,*y,ty);
       //if (seek_address<11) printf("f:%e m:%e t:%e\n",f_time,mid_time,t_time);
	//find fit record
	if ((mid_time>=f_time) && (mid_time<=t_time))
	{
		//printf("find one\n");
		*pk=read_backup_ram(mid_address);
		mid_char_int[0]=read_backup_ram(mid_address+1);
		mid_char_int[1]=read_backup_ram(mid_address+2);
		*what=c_t_i(mid_char_int);
		mid_char_flt[0]=read_backup_ram(mid_address+3);
		mid_char_flt[1]=read_backup_ram(mid_address+4);
		mid_char_flt[2]=read_backup_ram(mid_address+5);
		mid_char_flt[3]=read_backup_ram(mid_address+6);
		*value=c_t_f(&mid_char_flt);
		mid_char_flt[0]=read_backup_ram(mid_address+7);
		mid_char_flt[1]=read_backup_ram(mid_address+8);
		mid_char_flt[2]=read_backup_ram(mid_address+9);
		mid_char_flt[3]=read_backup_ram(mid_address+10);
		*flow=c_t_f(&mid_char_flt);
		return (1);
	}
 }
seek_address=0;
return (0);
}

float readkeepflow(void)
{
	 unsigned char ch[3];
	 ch[0]=read_backup_ram(29996);
	 ch[1]=read_backup_ram(29997);
	 ch[2]=read_backup_ram(29998);
	 ch[3]=read_backup_ram(29999);
	 return(c_t_f(&ch));
}
float readdkflow(void)
{
unsigned char ch[3];
	 ch[0]=read_backup_ram(29992);
	 ch[1]=read_backup_ram(29993);
	 ch[2]=read_backup_ram(29994);
	 ch[3]=read_backup_ram(29995);
	 return(c_t_f(&ch));
}
void writekeepflow(float keepflow)
{
	 write_backup_ram(29996,f_t_c(keepflow,0));
	 write_backup_ram(29997,f_t_c(keepflow,1));
	 write_backup_ram(29998,f_t_c(keepflow,2));
	 write_backup_ram(29999,f_t_c(keepflow,3));
}
void writedkflow(float dkflow)
{
	 if ((dkflow<100000.0) && dkflow>=0)
	 {
	    write_backup_ram(29992,f_t_c(dkflow,0));
	    write_backup_ram(29993,f_t_c(dkflow,1));
	    write_backup_ram(29994,f_t_c(dkflow,2));
	    write_backup_ram(29995,f_t_c(dkflow,3));
	 }
}