scale.c

一个基于C51开发的计价秤

/*********************************************/
// File Name: scale.c
// Author: henny
// Date: 2006/3/1
/*********************************************/
#include <SST89x5xxRD2.h>
#include <math.h>
#include "Public.h"

extern BOOL Cal_flag;
extern BOOL NEG_flag;
extern BOOL NET_flag;
extern BOOL STA_flag;
extern BOOL One_sec;
extern WORD Graduation_Grade;
extern BYTE Graduation1;
extern BYTE Graduation2;
extern WORD Max_Capacity;
extern INT8 Timeout3;
extern BYTE Err1_Timeout;
extern BYTE Initial_Zero_Setting_limit;
extern BYTE Zero_Setting_and_Zero_Tracking_limit; 
extern WORD Zero_Stable_count;
extern BYTE Zero_Stable_times;
extern WORD Weight_Stable_count;
extern BYTE Weight_Stable_times;
extern WORD Local_Height;
extern BYTE Local_Latitude;
extern WORD Destination_Height;
extern BYTE Destination_Latitude;
extern DWORD Cal_Zero_Upper_count;
extern DWORD Cal_Zero_Lower_count;
extern WORD Weight;
extern WORD Tare_Weight;
extern WORD Cal_Weight;
extern FLOAT One_count;
extern FLOAT Tare_count;
extern FLOAT Zero_count;
extern FLOAT Last_count;
extern FLOAT Cal_Zero_count;
extern FLOAT Initial_Zero_count;

extern VOID Set_STA_Icon();
extern VOID Cls_STA_Icon();
extern VOID Set_ZERO_Icon();
extern VOID Cls_ZERO_Icon();
extern VOID Set_NET_Icon();
extern VOID Cls_NET_Icon();
extern DWORD Get_AD_Convert_Data();

BOOL Cal_Zero_Count_Check()
{
	if(Cal_Zero_count<Cal_Zero_Lower_count||Cal_Zero_count>Cal_Zero_Upper_count)
		return FALSE;
	else
		return TRUE;
}

VOID Calculate_One_Count()
{
	INT8 data i;
	FLOAT cal_weight_count=0;
	for(i=0;i<5;i++)
		cal_weight_count+=Get_AD_Convert_Data();
	cal_weight_count=cal_weight_count/5;
	One_count=(cal_weight_count-Cal_Zero_count)/Cal_Weight;
}

VOID Monitor_Weigh_Scale_On_Calibration_Mode()
{
	BYTE digit;
	FLOAT current_count=0; 
	FLOAT temp_Weight;
	FLOAT int_part,frc_part;
	current_count=Get_AD_Convert_Data();
	temp_Weight=fabs(current_count-Cal_Zero_count)/One_count;
	frc_part=modf(temp_Weight,&int_part);
	frc_part=(int)(frc_part*100);
	digit=(int)frc_part%10;
	frc_part=frc_part/10;
	if(digit>4)
		frc_part+=1;
	digit=(int)frc_part%10;
	if(digit>4)
		int_part+=1;			
	Weight=int_part;		
}

BOOL Zero_Setting_When_Power_Up()
{
	INT8 data i;
	FLOAT current_count=0; 
	FLOAT Initial_Zero_Weight;
	FLOAT temp;
	temp=Max_Capacity*(Initial_Zero_Setting_limit*0.01);
	for(i=0;i<5;i++)
		Get_AD_Convert_Data();
	for(i=0;i<5;i++)
		current_count+=Get_AD_Convert_Data();
	current_count=current_count/5;
	Initial_Zero_Weight=fabs(current_count-Cal_Zero_count)/One_count;
	if(Initial_Zero_Weight<temp)
	{
		Tare_count=current_count;
		Zero_count=current_count;
		Last_count=current_count;
		Initial_Zero_count=current_count;
		return TRUE;
	}
	else
		return FALSE;	
}

VOID Zero_Setting_When_Zero_Key_Pressed()
{	
	INT8 data i;
	FLOAT current_count=0; 
	FLOAT Zero_Weight;
	FLOAT temp;
	temp=Max_Capacity*(Zero_Setting_and_Zero_Tracking_limit*0.01);
	for(i=0;i<5;i++)
		current_count+=Get_AD_Convert_Data();
	current_count=current_count/5;
	Zero_Weight=fabs(current_count-Initial_Zero_count)/One_count;
	if(Zero_Weight<temp)
	{
		NET_flag=FALSE;
		Tare_Weight=0;	
		Cls_NET_Icon();
		Tare_count=current_count;
		Zero_count=current_count;
		Last_count=current_count;
	}
}

VOID Tare_Operation_When_Tare_Key_Pressed()
{
	INT8 data i;
	FLOAT current_count=0;
	if(STA_flag)
	{
		if((Weight+Tare_Weight)<=(Max_Capacity+9*Graduation2))
		{
			for(i=0;i<5;i++)
				current_count+=Get_AD_Convert_Data();
			current_count=current_count/5;
			if(current_count>(Zero_count+Zero_Stable_count))
			{
				NET_flag=~NET_flag;
				if(NET_flag)
				{
					Tare_count=current_count;
					Last_count=current_count;
					Tare_Weight=Weight;	
					Set_NET_Icon();
				}
				else
				{
					Tare_count=Zero_count;
					Tare_Weight=0;	
					Cls_NET_Icon();
				}
			}
		}
	}		
}

BOOL Maximum_Capacity_Check()
{
	if((Weight+Tare_Weight)>(Max_Capacity+9*Graduation2))
		return TRUE;
	else
		return FALSE;
}
					 
VOID Auto_Zero_Tracking_Device(FLOAT current_count)
{
	FLOAT Zero_Weight;
	FLOAT temp;
	temp=Max_Capacity*(Zero_Setting_and_Zero_Tracking_limit*0.01);
	Zero_Weight=fabs(current_count-Initial_Zero_count)/One_count;
	if(Zero_Weight<temp)
	{
		Zero_Weight=fabs(current_count-Zero_count)/One_count;
		if((Weight==0)&&STA_flag&&One_sec&&Zero_Weight<(Graduation1*0.5))
		{
			One_sec=FALSE;
			Tare_count=current_count;
			Zero_count=current_count;
		   	Last_count=current_count;
		}
	}
}

VOID Zero_Stable_Device(FLOAT current_count)
{
	static BYTE Stable_Count1=1;
	if(fabs(current_count-Zero_count)<Zero_Stable_count)
	{	if(Stable_Count1<255)
			++Stable_Count1;
	}
	else
		Stable_Count1=1;
	if(Stable_Count1>Zero_Stable_times)
		Set_ZERO_Icon();
	else
	{  	
		Cls_ZERO_Icon();
	}	
}

VOID Weight_Stable_Device(FLOAT current_count)
{
	static BYTE Stable_Count2=1;
	if(fabs(current_count-Last_count)<Weight_Stable_count)
	{	if(Stable_Count2<255)
			++Stable_Count2;
	}
	else
		Stable_Count2=1;
	if(Stable_Count2>Weight_Stable_times)
	{
		Last_count=current_count;
		STA_flag=TRUE;				  
		Set_STA_Icon();
		Timeout3=Err1_Timeout;	
	}
	else
	{
		Last_count=current_count;
		STA_flag=FALSE;
		Cls_STA_Icon();
	}
}

VOID Negative_Weight_Check(FLOAT current_count)
{
	if(current_count<(Tare_count-Weight_Stable_count))
		NEG_flag=TRUE;
	else
		NEG_flag=FALSE;
}

VOID Weight_Graduation_Process()
{
	BYTE digit;
	digit=Weight%10;
	if(Weight<=Graduation_Grade)
	{
	if(digit>7)
		Weight=Weight/10*10+10;
	if(digit>2&&digit<=7)
		Weight=Weight/10*10+5;
	if(digit<=2)
		Weight=Weight/10*10;	
	}
	if(Weight>Graduation_Grade)
	{
		if(digit>4)	
			Weight=Weight/10*10+10;
		else
			Weight=Weight/10*10;	
	}						
}

FLOAT Weight_Latitude_Calibrated(FLOAT temp_Weight)
{
	FLOAT g1,g2,x,y;
	x=Local_Latitude/180.0;
	y=Destination_Latitude/180.0;
	x=x*3.1415926;
	y=y*3.1415926;
	g1=9.780318*(1+0.005324*(sin(x)*sin(x))-0.0000059*(sin(2*x)*sin(2*x)))+(-0.3086*0.00005*Local_Height);
	g2=9.780318*(1+0.005324*(sin(y)*sin(y))-0.0000059*(sin(2*y)*sin(2*y)))+(-0.3086*0.00005*Destination_Height);
	return temp_Weight*(g2/g1);
}

VOID Monitor_Weigh_Scale()
{
	BYTE digit;
	FLOAT current_count=0; 
	FLOAT temp_Weight;
	FLOAT int_part,frc_part;
	current_count=Get_AD_Convert_Data();
	if(!Cal_flag)
		Auto_Zero_Tracking_Device(current_count);
	Weight_Stable_Device(current_count);
	Zero_Stable_Device(current_count);
	Negative_Weight_Check(current_count);
	temp_Weight=fabs(current_count-Tare_count)/One_count;
	temp_Weight=Weight_Latitude_Calibrated(temp_Weight);
	frc_part=modf(temp_Weight,&int_part);
	frc_part=(int)(frc_part*100);
	digit=(int)frc_part%10;
	frc_part=frc_part/10;
	if(digit>4)
		frc_part+=1;
	digit=(int)frc_part%10;
	if(digit>4)
		int_part+=1;			
	Weight=int_part;
	Weight_Graduation_Process();		
}