TMRWatchNew/tmr/weight.c

#include <rtthread.h>
#include "buffer.h"
#include "button.h"
#include "ring_buffer.h"
#include "flash.h"
#include <stdlib.h>
#include "usart.h"
#include "plan.h"
#include "rtc.h"
#include "weight.h"
#include "ad.h"
#include "display.h"
#include "stm32f1xx_hal.h"
unsigned char  isWeight = 0;

static unsigned char WeightConst_RecFlag1 = 0;         //正在接收重量标志 0xF0处理完成
static unsigned char WeightConst_RecWeightPoint1 = 0;  //接收重量指针
static unsigned char WeightConst_RecWeightData1[250];  //接收重量临时表

static unsigned char WeightConst_Drop=0; //抛弃数据

static unsigned char WeightConst_WeightCount = 0;        //重量数
static signed short WeightConst_WeightMax = -32768;         //最大重量
static signed short WeightConst_WeightMin = 32767;     //最小重量

signed long WeightConst_WeightCurTem = 0;      //当前临时重量

unsigned char WeightConst_WeightCurTemZF = 1;     //当前临时重量正负,用TMRII
unsigned char WeightConst_WeightWS = 0;   //小数位数
unsigned char WeightConst_Weight_ZWS = 0;   //整数位数

signed short WeightConst_WeightLast;   //上次按键重量   1S一次

signed short WeightConst_WeightCur;   //当前重量   1S一次
signed short WeightConst_WeightOK;   //OK重量   1S一次
static unsigned char WeightConst_WeightCurCount = 0;        //重量计数，用于每15秒取一次重量

static signed short WeightConst_WeightCurTemLast = 0;      //上次临时重量
static unsigned short WeightConst_RecWeight_he1 = 0;  //校验重量准确性
static unsigned short WeightConst_RecWeight_he2 = 0;  //校验重量准确性
static unsigned short WeightConst_RecWeight_he3 = 0;  //校验重量准确性

static signed short WeightConst_WeightCur_last1=0;
static signed short WeightConst_WeightCur_last2=0;
static signed short WeightConst_WeightCur_last3=0;

static long WeightConst_WeightSum = 0;  //当前重量总和
unsigned char WeightConst_oksum = 0;     //符合目标重量数
unsigned char WeightConst_joksum = 0;     //符合目标重量数
unsigned char WeightConst_allsum = 0;    //总重量值数
static unsigned char WeightConst_uoksum = 0;
static unsigned char WeightConst_foksum = 0;
static unsigned char WeightConst_uallsum = 0;

unsigned char WeightConst_AutoSingleNSecondNum[30][3];    //自动跳转每秒值的数组
unsigned char WeightConst_AutoSingleNSecondPoint = 0;     //自动跳转的每秒的当前指针
static unsigned char WeightConst_WeightTargetTpo = 65;           //自动跳转的权重阀值固定为65%
static unsigned char WeightConst_autotpo = 0;                    //自动跳转的权重阀值

union timeweight_t  timeweight;
rt_sem_t weight_lock = RT_NULL;

unsigned long mypow(unsigned char x,unsigned char y) {
    unsigned long z;
    if (y==0) z=1;
    else  z=x;
    for (int i=1; i<y; i++)
        z = z*x;
    return z;
}

void weight_usart_Init(UART_HandleTypeDef* uartHandle)
{
	extern unsigned char WeightConst_TQ;
	extern unsigned char  iscowweight;
	if ((uartHandle->Instance==USART1) || 
		  (uartHandle->Instance==USART2 && (WeightConst_BLE==1 || WeightConst_BLE==3)))
	{
			if (WeightConst_TQ==1)
			{
				 uartHandle->Init.BaudRate = 9600;
			//	uartHandle->Init.StopBits    = UART_STOPBITS_2;	 //停止位1位		
			}
			else if (WeightConst_TQ==7)
			{
				 //RCC_PCLK2Config(RCC_HCLK_Div2);	
				 uartHandle->Init.BaudRate = 1200;
			}
			else if (WeightConst_TQ==4)			
				 uartHandle->Init.BaudRate = 19200;
			else if (WeightConst_TQ==8)
				 uartHandle->Init.BaudRate = 38400;
//			else if (WeightConst_TQ==9)
//				 uartHandle->Init.BaudRate = 1200;
			else if (WeightConst_TQ==9)
			{
					uartHandle->Init.BaudRate    = 9600;
					uartHandle->Init.Parity      = UART_PARITY_NONE;
					uartHandle->Init.WordLength  = UART_WORDLENGTH_8B; //8位数据
				//	uartHandle->Init.StopBits    = UART_STOPBITS_2;	 //停止位2位  海丰需要 
          uartHandle->Init.StopBits    = UART_STOPBITS_1;	 //停止位1位
			}
			else if (WeightConst_TQ==10)
			{
					uartHandle->Init.BaudRate    = 9600;
					uartHandle->Init.Parity      = UART_PARITY_NONE;
					uartHandle->Init.WordLength  = UART_WORDLENGTH_8B; //8位数据
					uartHandle->Init.StopBits    = UART_STOPBITS_1;	 //停止位1位		
			}
			else
				 uartHandle->Init.BaudRate = 9600;		
			if (iscowweight==1	){
					uartHandle->Init.BaudRate    = 19200;
					uartHandle->Init.Parity      = UART_PARITY_NONE;
					uartHandle->Init.WordLength  = UART_WORDLENGTH_9B; //8位数据
					uartHandle->Init.StopBits    = UART_STOPBITS_1;	 //停止位1位		
			}		
  }
	else if (uartHandle->Instance==UART5)
	{
		 uartHandle->Init.BaudRate = 9600;
	}
//	else if ((uartHandle->Instance==USART3) && (iscowweight==1))
//	{
//		 uartHandle->Init.BaudRate = 19200;
//		 uartHandle->Init.Parity = UART_PARITY_EVEN; 
//		 uartHandle->Init.WordLength  = UART_WORDLENGTH_9B; //8位数据
//		 uartHandle->Init.StopBits    = UART_STOPBITS_1;	 //停止位1位
//	}
}



static void setWeightSM() {  // 设定合计重量
    if 	((WeightConst_WeightCurTem > (WeightConst_WeightCurTemLast+1000) ||
            (WeightConst_WeightCurTem < (WeightConst_WeightCurTemLast - 1000) && WeightConst_WeightCurTem!=32768))
            && WeightConst_RecWeight_he3 < 3)
    {
        WeightConst_WeightCurTem = WeightConst_WeightCurTemLast;
        WeightConst_RecWeight_he3 ++;
    }
    else //if (WeightConst_WeightCurTem>-32768)
    {
        WeightConst_WeightCurTemLast = WeightConst_WeightCurTem;

        WeightConst_RecWeight_he3 = 0;
			
        rt_sem_take(weight_lock, RT_WAITING_FOREVER);
        if (WeightConst_WeightMax < WeightConst_WeightCurTem)	WeightConst_WeightMax = WeightConst_WeightCurTem; //修改最大重量
        if (WeightConst_WeightMin > WeightConst_WeightCurTem)	WeightConst_WeightMin = WeightConst_WeightCurTem; //修改最小重量
        WeightConst_WeightSum = WeightConst_WeightSum + WeightConst_WeightCurTem; //  重量和
        WeightConst_WeightCount++; // 重量采样数	
		   	WeightConst_allsum++;
		  	rt_sem_release(weight_lock);
				if (isTag==2)
				{
					get_modbusmsg(1,10,308,WeightConst_WeightCurTem);
				}
        //判断是否在范围内
        if(pf_comp.data.autosecond>0 &&  WeightConst_WeightHaveBegin==1 && WeightConst_Product_Run > 0) { //跳转时间大于0
            if ((WeightConst_WeightCurTem>WeightConst_WeightTargetAllowMin &&
                    WeightConst_WeightCurTem<WeightConst_WeightTargetAllowMax && WeightConst_ChanCheShu>1)
                    || (WeightConst_WeightCurTem>WeightConst_WeightTargetAllowMin && pf_comp.data.addorout==0 && WeightConst_ChanCheShu==1)) //大目标  为正，且当前值小于大目标
            {
                if ((WeightConst_SBType==4||WeightConst_SBType==6) && WeightConst_Stop==0 && isn==0) {
  									rt_event_send(&display_event, EVENT_Stop);
                    WeightConst_Stop=1;
                }

                WeightConst_oksum++;
                WeightConst_WeightOK=WeightConst_WeightCurTem;
            }
              
						if (WeightConst_WeightCurTem > WeightConst_WeightTargetAllowMax)
							 WeightConst_joksum++;
					
            //WeightConst_WeightTargetAllow
            if ((WeightConst_WeightCurTem>WeightConst_WeightTargetAllowMin && pf_comp.data.addorout==0)
                    ||(WeightConst_WeightCurTem<WeightConst_WeightTargetAllowMin && pf_comp.data.addorout==1))
            {
                alarm_on();
                //----------------------------if (WeightConst_SBType==5) ControlPlay(2, 1);

            }
            else if ((WeightConst_WeightCurTem < WeightConst_WeightTargetAllowMin && pf_comp.data.addorout == 0)
                     || (WeightConst_WeightCurTem > WeightConst_WeightTargetAllowMin && pf_comp.data.addorout == 1))
            {
                //----------------------------if (WeightConst_SBType==5) ControlPlay(2, 0);
               alarm_off();
            }
        }
        
    }
    HAL_GPIO_TogglePin(led_GPIO_Port, led_Pin);
}


void readnumber(unsigned char* weightbuf, unsigned char length, unsigned char idlelength,
                       unsigned char wlength, unsigned char zfpos,unsigned char fchar,unsigned char pointpos){
    signed long WeightCurTem_ = 0;
		unsigned char WeightCurTemZF = 0;
		unsigned char WeightWS = 0;
		unsigned char Weight_ZWS = 0;
		unsigned char curchar = 0;
    WeightCurTem_ = 0;
		for (int ReadWeight_i = 0; ReadWeight_i < wlength; ReadWeight_i++) {		
        curchar = weightbuf[length -idlelength - wlength +ReadWeight_i] ;			
				if (curchar >= 0x30 && curchar	<= 0x39) {
						WeightCurTem_ = WeightCurTem_ + (curchar - 0x30) * mypow(10, wlength - 1 - ReadWeight_i); //计算重量,无小数位的
						Weight_ZWS++;
				}
        else if (curchar == fchar && zfpos == 0xFF)
            WeightCurTemZF = 1;
				else if (curchar == 0x2E) {
            WeightWS = wlength - 1 - ReadWeight_i; //设置小数位数
            WeightCurTem_ = WeightCurTem_ / 10;
        }
		}
		
    if (pointpos < 0xFF && WeightWS==0 && weightbuf[length-pointpos]>0x30 && weightbuf[length-pointpos]<0x34){
		   	WeightWS = weightbuf[length-pointpos] - 0x30; //设置小数位数
		}
		
		if (zfpos < 0xFF && ((weightbuf[length-zfpos]&fchar) == fchar) && WeightCurTemZF == 0)
				WeightCurTemZF = 1;
		
		if (WeightCurTemZF == 1)	WeightCurTem_ = WeightCurTem_ * -1;
		
		WeightConst_WeightCurTem = WeightCurTem_;		
		WeightConst_WeightCurTemZF = WeightCurTemZF;
		WeightConst_WeightWS =  WeightWS;
		WeightConst_Weight_ZWS = Weight_ZWS;
		setWeightSM();
}

void sendWeight() {
    /* key0 协议 34字节(上报实时重量)：0x7E 0x20 0x01 0xF0 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x01     1位起始位 + 1位长度 + 1位源地址 + 1位命令 + 28位重量（四段） + 1帧编号 + 1校验
     */
    if (rb_full_count(RecWeightQueue) > 28) {
        unsigned char buf[34] ;
        unsigned char CRCNum=0;
        buf[0]= 0x7E;
        buf[1]= 0x20;
        buf[2]= XbeeConst_DeviceAddress;
        buf[3]= 0xF0;

        for (int i=0; i <28; i++) buf[i+4]= rb_remove(RecWeightQueue);

        buf[32] = XbeeConst_FrameNum ++;
			  HAL_RTCEx_BKUPWrite(&hrtc,RTC_BKP_DR3, buf[32]);	
        for (int i=0; i< 33; i++)  CRCNum+=buf[i];

        buf[33]= 0xff - CRCNum;

        for (int i=0; i <(int)(sizeof(buf)/sizeof(unsigned char)); i++)
            rb_push_insert(SendWeightQueue,buf[i]);
    }
}

void sendEIDWeight(unsigned char * eidbuf, signed short WeightCur) {
    /* key6 协议 34字节(上报电子称重)：0x7E 0x0D 0x01 0xF6 0x00 0x00 0x00 0x00 0x00 0x00 0x00   1位起始位 + 1位长度 + 1位源地址 + 1位命令 + 7位耳标 + 2位重量 + 1帧编号 + 1校验
     */
	 unsigned char buf[15] ;
        unsigned char CRCNum=0;
	  if( eidbuf[0] == 5 &&  WeightCur>20){		 
        buf[0]= 0x7E;
        buf[1]= 0x0D;
        buf[2]= XbeeConst_DeviceAddress;
        buf[3]= 0xF6;

        for (int i=0; i <7; i++) buf[i+4]= eidbuf[i+1];
        buf[11]= (WeightCur>>8) &0xFF;
			  buf[12]= WeightCur &0xFF;
        buf[13] = XbeeConst_FrameNum ++;
			  HAL_RTCEx_BKUPWrite(&hrtc,RTC_BKP_DR3, buf[13]);
        for (int i=0; i< 14; i++)  CRCNum+=buf[i];

        buf[14]= 0xff - CRCNum;
        for (int i=0; i <(int)(sizeof(buf)/sizeof(unsigned char)); i++)
            rb_push_insert(SendWeightQueue,buf[i]);
		}  
}

void CheckWeightthread(void) {

    while (1) {			
			if (WeightConst_DELAYON>0)        //搅拌延时
			{
					WeightConst_DELAYTIME ++;
				  HAL_RTCEx_BKUPWrite(&hrtc,RTC_BKP_DR5, WeightConst_DELAYTIME);	
					if (WeightConst_DELAYTIME >  (pf_comp.data.delaytime * 60))  //10 &&pf_comp.data.delaytime>0 )
					{
							write_Flash("begintime", &TimeConst, sizeof(TimeConst));											
							WeightConst_WeightBegin = WeightConst_WeightCur;					
              write_Flash("beginweight", &WeightConst_WeightBegin, sizeof(WeightConst_WeightBegin)); 
              
							pf_comp.data.delaytime = 0;
						  WeightConst_DELAYTIME = 0;
						  WeightConst_DELAYON = 0;
						
					  	HAL_RTCEx_BKUPWrite(&hrtc,RTC_BKP_DR4, 0);	
						  HAL_RTCEx_BKUPWrite(&hrtc,RTC_BKP_DR5, 0);	
						  HAL_RTCEx_BKUPWrite(&hrtc,RTC_BKP_DR6, 0);	
						  rt_sem_release(pop_product_sem);//弹出最新内容
					}
			}
		//	else {
		//		WeightConst_DELAYTIME = 0;
		 //  	WeightConst_DELAYON=0;
	//		}
			
			if ( WeightConst_allsum > 0) {
			  rt_sem_take(weight_lock, RT_WAITING_FOREVER);
        if (WeightConst_WeightCount>2) {
            WeightConst_WeightSum = WeightConst_WeightSum - WeightConst_WeightMin; //  重量和 减去最小值
            WeightConst_WeightSum = WeightConst_WeightSum - WeightConst_WeightMax; //  重量和 减去最大值
            WeightConst_WeightCount = WeightConst_WeightCount - 2;
        }
				if (WeightConst_WeightCount>0)
          WeightConst_WeightCur = WeightConst_WeightSum / WeightConst_WeightCount;
				else 
		  	  WeightConst_WeightCur = WeightConst_WeightCurTem;
				
				WeightConst_WeightSum = 0;
				WeightConst_WeightCount = 0;        //重量数
				WeightConst_WeightMax = -32768;         //最大重量
				WeightConst_WeightMin = 32767;     //最小重量
        if (WeightConst_WeightCurCount >= 0x0F) {  //15秒准备发送后台重
					  rt_sem_take(setTIME_lock, RT_WAITING_FOREVER);
					  timeweight.Buffer[3] =TimeConst.Buffer[0];
					  timeweight.Buffer[4] =TimeConst.Buffer[1];
					  timeweight.Buffer[5] =TimeConst.Buffer[2];
					  timeweight.Buffer[6] =TimeConst.Buffer[3];
					  rt_sem_release(setTIME_lock);
					  timeweight.data.Weight = WeightConst_WeightCur;
					  timeweight.data.WeightWS = WeightConst_WeightWS;
					  timeweight.data.WeightRun = WeightConst_Product_Run; 
				  	timeweight.data.reserved = 0;
						ts_pushArrary(&ts_weightdb, timeweight.Buffer, 7);
            WeightConst_WeightCur_last3 = WeightConst_WeightCur_last2;
            WeightConst_WeightCur_last2 = WeightConst_WeightCur_last1;
            WeightConst_WeightCur_last1 = WeightConst_WeightCur;

//            if (WeightConst_WeightCur<0)
//                rb_push_insert(RecWeightQueue, (0<<7) | (WeightConst_WeightWS<<6>>1));//这边有问题，需要修改
//            else
//                rb_push_insert(RecWeightQueue, (0<<7) | (WeightConst_WeightWS<<6>>1));//这边有问题，需要修改

            WeightConst_WeightCurCount=0;
        }
				rt_sem_release(weight_lock);
				if (WeightConst_Product_Run > 0) {
					if (WeightConst_AutoSingleNSecondPoint >= (pf_comp.data.autosecond * 3)  || WeightConst_AutoSingleNSecondPoint>=30)
							WeightConst_AutoSingleNSecondPoint = 0;

					WeightConst_AutoSingleNSecondNum[WeightConst_AutoSingleNSecondPoint][0] = WeightConst_oksum;
					WeightConst_AutoSingleNSecondNum[WeightConst_AutoSingleNSecondPoint][1] = WeightConst_allsum;
					WeightConst_AutoSingleNSecondNum[WeightConst_AutoSingleNSecondPoint][2] = WeightConst_joksum;		

					WeightConst_AutoSingleNSecondPoint++;

					WeightConst_uoksum = 0;
					WeightConst_uallsum = 0;
					WeightConst_foksum = 0;

					for (int CheckWeight_i = 0; CheckWeight_i < (pf_comp.data.autosecond * 3); CheckWeight_i++) {
							WeightConst_uoksum = WeightConst_uoksum + WeightConst_AutoSingleNSecondNum[CheckWeight_i][0];
							WeightConst_uallsum = WeightConst_uallsum + WeightConst_AutoSingleNSecondNum[CheckWeight_i][1];
							WeightConst_foksum = WeightConst_foksum + WeightConst_AutoSingleNSecondNum[CheckWeight_i][2];
					}

					if (WeightConst_uallsum == 0)
							WeightConst_uallsum = 100;   //如果没接称，allsum有可能为0，此处进行保护
					WeightConst_autotpo = WeightConst_uoksum * 100 / WeightConst_uallsum;  //合理停留秒数内接收到的符合跳转的数据占总接收数据的百分比

					if (WeightConst_autotpo > 100) WeightConst_autotpo = 0;     //对百分比进行保护

					if ((WeightConst_autotpo > WeightConst_WeightTargetTpo)
									|| ((WeightConst_foksum * 100 / WeightConst_uallsum)>WeightConst_WeightTargetTpo
														 && pf_comp.data.JMP)  
						 )       //触发自动按键
					{
							for (int CheckWeight_i = 0; CheckWeight_i < 30; CheckWeight_i++) {
									WeightConst_AutoSingleNSecondNum[CheckWeight_i][0]=0;
									WeightConst_AutoSingleNSecondNum[CheckWeight_i][1]=0;
									WeightConst_AutoSingleNSecondNum[CheckWeight_i][2]=0;
							}
							if (WeightConst_DELAYON == 0 && delayKeying == 0)
							{			
								rt_sem_release(delay_key_sem); 								
								sendkey1(0xF1, 0);
							}
							button_state.b1 = 1; //5秒内禁止按1键
					}

					WeightConst_oksum = 0;
					WeightConst_joksum = 0;
					WeightConst_allsum = 0;
					WeightConst_uoksum = 0;
					WeightConst_uallsum = 0;
					WeightConst_foksum = 0;
				 // sendWeight(); //检查是否需要保存实时重量

				}
		  }
			WeightConst_WeightCurCount++;
			
			
      if (WeightConst_Product_Run > 0)
		  {
				if (WeightConst_Nextfeed[0] == 0x20){
					if (findNextplan()>0) 
						rt_event_send(&display_event, EVENT_Next);
				}
						
				if (WeightConst_Product_Run_time < 65535 && WeightConst_Product_Run_time>0 && pf_comp.data.addorout==0)
						WeightConst_Product_Run_time++;		  
			//	else 
			//		WeightConst_Product_Run_time = 0;
				HAL_RTCEx_BKUPWrite(&hrtc,RTC_BKP_DR3, WeightConst_Product_Run_time);	
			}
			rt_thread_mdelay(1000);
    }
}

static void P_TDI200I() {
    //	02 20 2D 20 20 20 36 37 2E 30 6B 67 03   -67.0KG    300G0
    //  02 20 20 20 20 20 36 37 2E 36 6B 7F 03   300G0
    //  02 2B 30 30 30 30 30 30 33 03   300G0	
	
	  //	02 2D 20 20 20 36 37 2E 30 6B 67 03   -67.0KG     300G1
    //  02 20 20 20 20 32 2E 33 30 6B 67 03               300G1
	
	  //02 2B 30 30 30 30 30 30 33 03
    //02 +/-	十万 万 千 百 十 个	小数点位数	03   TDI200I
	
    if (WeightConst_RecWeightPoint1>39) WeightConst_RecWeightPoint1 = 0; //指针还原
	  WeightConst_RecWeightData1[WeightConst_RecWeightPoint1] = rb_remove(rb_usart1);
	  if (WeightConst_RecWeightData1[WeightConst_RecWeightPoint1] == 0x02) {
			WeightConst_RecWeightData1[0] = 0x02;
			WeightConst_RecWeightPoint1 = 0;			
		}

		if (WeightConst_RecWeightData1[WeightConst_RecWeightPoint1] == 0x03) 
		{
				if (WeightConst_RecWeightPoint1>11 && WeightConst_RecWeightData1[WeightConst_RecWeightPoint1-2] == 0x6B)
				{  						
					 readnumber(WeightConst_RecWeightData1,WeightConst_RecWeightPoint1, 2, 7, 0x0A, 0x2d, 0xFF);                
				}
				else if (WeightConst_RecWeightPoint1>10 && WeightConst_RecWeightData1[WeightConst_RecWeightPoint1-2] == 0x6B)
				{  						
					 readnumber(WeightConst_RecWeightData1,WeightConst_RecWeightPoint1, 2, 7, 0x0A,0x2d, 0xFF);                
				}
				else if (WeightConst_RecWeightPoint1==9)
				{
					  readnumber(WeightConst_RecWeightData1,WeightConst_RecWeightPoint1, 1, 6, 0x08,0x2d, 0x01);  
				}
				WeightConst_RecWeightPoint1 = 0; //指针还原
		} else {
				WeightConst_RecWeightPoint1++;
		}	
}

static void P_XK3190_C8() {
    //兼容XK3118K9
    //02 2D 30 30 30 31 32 30 31 03
    //02 2D 30 30 30 31 32 30 31 31 46 03
    //02 +/- 0  1  2  3  4	5 点位数	 03
	
	  //02 47 20 20 20 37 37 30 36 20 20 2C 30 31 2D 30 31 2D 30 36 2C 30 30 3A 30 30 3A 34 31 03 04 1B
    if (WeightConst_RecWeightPoint1>39) WeightConst_RecWeightPoint1 = 0; //指针还原	
	  WeightConst_RecWeightData1[WeightConst_RecWeightPoint1] = rb_remove(rb_usart1);
	  if (WeightConst_RecWeightData1[WeightConst_RecWeightPoint1] == 0x02) {
			WeightConst_RecWeightData1[0] = 0x02;
			WeightConst_RecWeightPoint1 = 0;			
		}

		if (WeightConst_RecWeightData1[WeightConst_RecWeightPoint1] == 0x03) 
		{
			  if (WeightConst_RecWeightPoint1==29)
				{  //02 2D 30 30 30 31 32 30 31 03						
					 readnumber(WeightConst_RecWeightData1,WeightConst_RecWeightPoint1, 20, 6, 0xFF, 0x2d, 0xFF);                
				}
				else if (WeightConst_RecWeightPoint1>10 && WeightConst_RecWeightData1[WeightConst_RecWeightPoint1-2] == 0x6B)
				{ 	//02 2D 20 20 20 36 37 2E 31 6B 67 03 					
					 readnumber(WeightConst_RecWeightData1,WeightConst_RecWeightPoint1, 2, 6, 0x0A, 0x2d, 0x02);                
				}
				else if (WeightConst_RecWeightPoint1==9)
				{ //02 47 20 20 20 37 37 30 36 20 20 2C 30 31 2D 30 31 2D 30 36 2C 30 30 3A 30 30 3A 34 31 03 04 1B
					 readnumber(WeightConst_RecWeightData1,WeightConst_RecWeightPoint1, 0, 6, 0x08, 0x2d, 0x01);  
				}
				WeightConst_RecWeightPoint1 = 0; //指针还原
		} else {
				WeightConst_RecWeightPoint1++;
		}	
}

static void P_AWH_30_SA() {
    //展会   //53 54 2C 47 53 2C 2B 20 20 30 2E 38 37 36 6B 67 0d 0a
    if (WeightConst_RecWeightPoint1>39) WeightConst_RecWeightPoint1 = 0; //指针还原
	
	  WeightConst_RecWeightData1[WeightConst_RecWeightPoint1] = rb_remove(rb_usart1);
	  if (WeightConst_RecWeightData1[WeightConst_RecWeightPoint1] == 0x0A) 
		{
			  if (WeightConst_RecWeightPoint1==17)
				{  						
					 readnumber(WeightConst_RecWeightData1,WeightConst_RecWeightPoint1, 3, 7, 0x0B, 0x2d, 0xFF);                
				}
		    WeightConst_RecWeightPoint1 = 0; //指针还原
		} else {
				WeightConst_RecWeightPoint1++;
		}			
}

static void P_digi() {
		//2E 44 30 2D 20 20 2D 33 36 30 30 30 39 09 
		//2E 44 30 2D 20 33 39 32 32 30 30 30 42 09 
		//2E 44 30 74 54 6F 74 61 6C 20 57 65 69 67 68 74 20 38 09 
    if (WeightConst_RecWeightPoint1>140) WeightConst_RecWeightPoint1 = 0; //指针还原
    WeightConst_RecWeightData1[WeightConst_RecWeightPoint1] = rb_remove(rb_usart1);
	  if (WeightConst_RecWeightData1[WeightConst_RecWeightPoint1] == 0x2E) {
			WeightConst_RecWeightData1[0] = 0x2E;
			WeightConst_RecWeightPoint1 = 0;			
		}
    if (WeightConst_RecWeightData1[WeightConst_RecWeightPoint1] == 0x09) 
		{
			  if (WeightConst_RecWeightPoint1 == 13 && WeightConst_RecWeightData1[WeightConst_RecWeightPoint1-10] == 0x2D)
				{  						
					 readnumber(WeightConst_RecWeightData1,WeightConst_RecWeightPoint1, 4, 5, 0x0A, 0x2d, 0xFF);                
				} 
		    WeightConst_RecWeightPoint1 = 0; //指针还原
		} else {
				WeightConst_RecWeightPoint1++;
		}	
}

static void P_AWT_ZM303() {
    //展会   //20 20 20 20 20 31 37 34 20 6B 67 20 47 0D 0A
            //3D 2D 30 30 30 30 36 34 28 6B 67 29 0D 0A
    if (WeightConst_RecWeightPoint1>50) WeightConst_RecWeightPoint1 = 0; //指针还原
    WeightConst_RecWeightData1[WeightConst_RecWeightPoint1] = rb_remove(rb_usart1);	
	  if (WeightConst_RecWeightData1[WeightConst_RecWeightPoint1] == 0x0A) 
		{
			  if (WeightConst_RecWeightPoint1 == 13 && WeightConst_RecWeightData1[0] == 0x3D) {
           //3D 2D 30 30 30 30 36 34 28 6B 67 29 0D 0A				
					 readnumber(WeightConst_RecWeightData1,WeightConst_RecWeightPoint1, 5, 6, 0x0C, 0x2d, 0xFF);                
				} 
				else if (WeightConst_RecWeightPoint1 == 14 && WeightConst_RecWeightData1[WeightConst_RecWeightPoint1-5]==0x6B ) {
          //20 20 20 20 20 31 37 34 20 6B 67 20 47 0D 0A
				  //20 20 20 20 20 2D 31 38 20 6B 67 20 47 0D 0A
					 readnumber(WeightConst_RecWeightData1,WeightConst_RecWeightPoint1, 6, 6, 0xFF, 0x2d, 0xFF);   							 
				}

				else if (WeightConst_RecWeightPoint1 == 43 && WeightConst_RecWeightData1[0] == 0x31) {
           //	31 2C 53 54 2C 20 20 20 20 20 20 20 2D 32 35 2C 20 20 20 20 20 20 20 20 20 20 20 30 2C 20 20 20 20 20 20 20 20 20 30 2C 6B 67 0D 0A
				   readnumber(WeightConst_RecWeightData1,WeightConst_RecWeightPoint1, 28, 6, 0xFF, 0x2d, 0xFF);   	
				}

		    WeightConst_RecWeightPoint1 = 0; //指针还原
		} else if (WeightConst_RecWeightData1[WeightConst_RecWeightPoint1] == 0x09) 
				{
          if (WeightConst_RecWeightData1[WeightConst_RecWeightPoint1-10] == 0x2D) {
          //	 2E 44 30 2D 20 20 2D 33 36 30 30 30 39 09 
				    readnumber(WeightConst_RecWeightData1,WeightConst_RecWeightPoint1, 4, 5, 0xFF, 0x2d, 0xFF);    
					}
          WeightConst_RecWeightPoint1 = 0; //指针还原					
				}
		else {
				WeightConst_RecWeightPoint1++;
		}		
}

static void P_T_2000() {
//    55 53 2C 47 53 20 20 20 20 32 2E 37 32 6B 67 0D 0A 2.72  不稳定
//    53 54 2C 47 53 20 20 20 20 32 2E 34 33 6B 67 0D 0A 2.43  稳定
//    55 53 2C 47 53 2D 20 20 20 30 2E 33 38 6B 67 0D 0A -0.38  不稳定
//             77 6E 30 30 30 30 38 33 33 35 6B 67 0D 0A 
    if (WeightConst_RecWeightPoint1>40) WeightConst_RecWeightPoint1 = 0; //指针还原
    WeightConst_RecWeightData1[WeightConst_RecWeightPoint1] = rb_remove(rb_usart1);

    if (WeightConst_RecWeightData1[WeightConst_RecWeightPoint1] == 0x0A) 
		{
			  if (WeightConst_RecWeightPoint1 == 12) {					
					 readnumber(WeightConst_RecWeightData1, WeightConst_RecWeightPoint1, 3, 6, 0xFF, 0x2d, 0xFF);                
				}
				else if (WeightConst_RecWeightPoint1>=13) {
				   readnumber(WeightConst_RecWeightData1, WeightConst_RecWeightPoint1, 3, 7, 11, 0x2d, 0xFF);  
				}
		    WeightConst_RecWeightPoint1 = 0; //指针还原
		} else {
				WeightConst_RecWeightPoint1++;
		}	
}


static void P_HF() {
//    01 10 00 01 00 02 04 00 00 17 9C 3D FA 01 10 00 01 00 02 10 08
//    02 10 00 01 00 02 04 08 00 00 A2 BE FE 02 10 00 01 00 02 10 3B
//    03 10 00 01 00 02 04 08 00 00 A4 3A 00 03 10 00 01 00 02 10 3B
    signed long WeightCurTem_ = 0;
	
    if (WeightConst_RecWeightPoint1>140) WeightConst_RecWeightPoint1 = 0; //指针还原
    WeightConst_RecWeightData1[WeightConst_RecWeightPoint1] = rb_remove(rb_usart1);
		
    if (WeightConst_RecFlag1 != 0xF0) //上一条完整数据没有处理完
    {
        if ((WeightConst_RecWeightData1[WeightConst_RecWeightPoint1]&0xf0) == 0x10 &&
                WeightConst_RecWeightData1[WeightConst_RecWeightPoint1-1] == 0x02 &&
                WeightConst_RecWeightData1[WeightConst_RecWeightPoint1-2] == 0x00 &&
                WeightConst_RecWeightData1[WeightConst_RecWeightPoint1-3] == 0x01 &&
                WeightConst_RecWeightData1[WeightConst_RecWeightPoint1-4] == 0x00 &&
                WeightConst_RecWeightData1[WeightConst_RecWeightPoint1-5] == 0x10 &&
                WeightConst_RecWeightData1[WeightConst_RecWeightPoint1-6] == XbeeConst_DeviceAddress) //英展电子秤
        {
            if (WeightConst_RecWeightData1[WeightConst_RecWeightPoint1-19] == XbeeConst_DeviceAddress)
            {
							  WeightCurTem_ = 0;

                WeightCurTem_ = ((WeightConst_RecWeightData1[WeightConst_RecWeightPoint1-11]<<16)
                                            |
                                            (WeightConst_RecWeightData1[WeightConst_RecWeightPoint1-10]<<8)
                                            |
                                            WeightConst_RecWeightData1[WeightConst_RecWeightPoint1-9]);

                if ((WeightConst_RecWeightData1[WeightConst_RecWeightPoint1-12]&0x08) == 0x08){
                    WeightCurTem_ = WeightCurTem_ * -1;
                    WeightConst_WeightCurTemZF = 1;									
								}
                WeightConst_WeightCurTem = WeightCurTem_;
		            WeightConst_WeightWS =  0;
		            WeightConst_Weight_ZWS = 0;
                setWeightSM();
                WeightConst_RecFlag1 = 0x00;

                WeightConst_Drop = 0; //开始抛弃数据
            }
            WeightConst_RecWeightPoint1 = 0; //指针还原
        } else {
            WeightConst_RecWeightPoint1++;
        }
    }
    else
    {
        WeightConst_RecWeightPoint1++;
    }
}

static void P_E_2000() {
//  3D 30 30 30 30 31 30 30 0D 0A
//  3D 2D 30 30 30 31 30 30 0D 0A
    if (WeightConst_RecWeightPoint1>40) WeightConst_RecWeightPoint1 = 0; //指针还原
    WeightConst_RecWeightData1[WeightConst_RecWeightPoint1] = rb_remove(rb_usart1);

    if (WeightConst_RecWeightData1[WeightConst_RecWeightPoint1] == 0x0A) 
		{
			  if (WeightConst_RecWeightPoint1 == 9) {					
					 readnumber(WeightConst_RecWeightData1, WeightConst_RecWeightPoint1, 1, 6, 8, 0x2d, 0xFF);                
				}
		    WeightConst_RecWeightPoint1 = 0; //指针还原
		} else {
				WeightConst_RecWeightPoint1++;
		}			
}

static void P_TMI_II() {
    //23 03 BD 18 00 2D 34 37 39 38 0A 00 0D 00 00 00 00 00 00 00 00 00 00 00 AF BA 04    -   4  7  9  8   //波特率19200

    //23 03 02 18 00 20 2D 31 38 32 0A 00 0D 00 00 00 00 00 00 00 00 00 00 00 7D FE 04
    //23 03 03 18 00 20 2D 31 38 32 0A 00 0D 00 00 00 00 00 00 00 00 00	00 00 D4 A3 04
    //23 03 04 18 00 20 2D 31 38 32 0A 00 0D 00 00 00 00 00 00 00 00 00 00 00 92 03 04           -182

    if (WeightConst_RecWeightPoint1>53) WeightConst_RecWeightPoint1 = 0; //指针还原

		WeightConst_RecWeightData1[WeightConst_RecWeightPoint1] = rb_remove(rb_usart1);
    if (WeightConst_RecWeightData1[WeightConst_RecWeightPoint1] == 0x23){
			WeightConst_RecWeightData1[0] = 0x23;
			WeightConst_RecWeightPoint1 = 0;
		}
		if (WeightConst_RecWeightData1[WeightConst_RecWeightPoint1] == 0x0D) //英展电子秤
		{
				if (WeightConst_RecWeightPoint1>11 && WeightConst_RecWeightData1[WeightConst_RecWeightPoint1-2] == 0x0A &&
								WeightConst_RecWeightData1[WeightConst_RecWeightPoint1-12] == 0x23 )
				{  						
					 readnumber(WeightConst_RecWeightData1,WeightConst_RecWeightPoint1, 2, 5,0xFF,0x2d, 0xFF);                
				}
				WeightConst_RecWeightPoint1 = 0; //指针还原
		} else {
				WeightConst_RecWeightPoint1++;
		}	   
}

static void P_TMI_III() {
    //0x20 0x2d 0x31 0x34 0x32 0x0d  -142
    //2D 33 36 35 34 0D    
    if (WeightConst_RecWeightPoint1>17) WeightConst_RecWeightPoint1 = 0; //指针还原

		WeightConst_RecWeightData1[WeightConst_RecWeightPoint1] = rb_remove(rb_usart1);

		if (WeightConst_RecWeightData1[WeightConst_RecWeightPoint1] == 0x0D) //英展电子秤
		{
				if (WeightConst_RecWeightPoint1>10 && WeightConst_RecWeightData1[WeightConst_RecWeightPoint1-1] == 0x29 &&
								WeightConst_RecWeightData1[WeightConst_RecWeightPoint1-4] == 0x28 )
				{  //3D 30 30 30 30 30 30 36 28 6B 67 29 0D 0A
					 //3D 2D 30 30 30 30 36 34 28 6B 67 29 0D 0A							
					 readnumber(WeightConst_RecWeightData1,WeightConst_RecWeightPoint1,4, 5,11,0x2d, 0xFF);                
				}
        else if (WeightConst_RecWeightPoint1>10 && WeightConst_RecWeightData1[WeightConst_RecWeightPoint1-1] == 0x67 &&
            WeightConst_RecWeightData1[WeightConst_RecWeightPoint1-2] == 0x6B )
        {
           //77 6E 2D 30 30 30 30 30 35 31 6B 67 0D 0A
					 readnumber(WeightConst_RecWeightData1,WeightConst_RecWeightPoint1,2, 5,10,0x2d, 0xFF);    
				}
				else if (WeightConst_RecWeightPoint1>4 && WeightConst_RecWeightData1[WeightConst_RecWeightPoint1-1] != 0x20) {
					 //2D 33 36 35 34 0D
					 readnumber(WeightConst_RecWeightData1,WeightConst_RecWeightPoint1,0, 5, 0xff,0x2d, 0xFF);                
				}
				WeightConst_RecWeightPoint1 = 0; //指针还原
		} else {
				WeightConst_RecWeightPoint1++;
		}
}


static void P_EZ4300() {
    //82 2D A0 A0 A0 B1 39 8D   库恩表头出来是7位数据，8位是校验位，将数据的高位去掉，则得到下面正确的数据
    //02 2D 20 20 20 31 39 0D
	
	  //02 47 20 20 20 37 37 30 36 20 20 2C 30 31 2D 30 31 2D 30 36 2C 30 30 3A 30 30 3A 34 31 03 04 1B 
	  //02 47 20 20 20 37 37 30 36 20 20 2C 30 31 2D 30 31 2D 30 36 2C 30 30 3A 30 30 3A 34 31 03 04 1B
    if (WeightConst_RecWeightPoint1>10) WeightConst_RecWeightPoint1 = 0; //指针还原
    WeightConst_RecWeightData1[WeightConst_RecWeightPoint1] = rb_remove(rb_usart1) & 0x7F;
	
	  if (WeightConst_RecWeightData1[WeightConst_RecWeightPoint1] == 0x02) {
			WeightConst_RecWeightData1[0] = 0x02;
			WeightConst_RecWeightPoint1 = 0;			
		}
    if (WeightConst_RecWeightData1[WeightConst_RecWeightPoint1] == 0x0D) 
		{
			  if (WeightConst_RecWeightPoint1 == 7)
				{  						
					 readnumber(WeightConst_RecWeightData1,WeightConst_RecWeightPoint1, 0, 5, 6, 0x2d, 0xFF);                
				} 
		    WeightConst_RecWeightPoint1 = 0; //指针还原
		} else {
				WeightConst_RecWeightPoint1++;
		}
}

static void P_TQ() {
//	7E 7E F0 10 55 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 AB FE
//  7E 7E F0 10 00 00 00 00 00 00 00 03 04 00 00 00 00 00 03 04 F2 FE
//  7E 7E F0 10 01 00 00 00 00 00 00 06 08 80 00 00 00 00 06 08 63 FE
//  7E 7E FF 10 01 00 00 00 00 00 00 06 08 80 00 00 00 00 06 08 54 FE
    if (WeightConst_RecWeightPoint1>43) WeightConst_RecWeightPoint1 = 0; //指针还原
    WeightConst_RecWeightData1[WeightConst_RecWeightPoint1] = rb_remove(rb_usart1);
    if (WeightConst_RecWeightData1[WeightConst_RecWeightPoint1] == 0xFE) 
		{
			  if (WeightConst_RecWeightPoint1 >= 21 && WeightConst_RecWeightData1[WeightConst_RecWeightPoint1-21]==0x7E
                    && WeightConst_RecWeightData1[WeightConst_RecWeightPoint1-20]==0x7E
                    && (WeightConst_RecWeightData1[WeightConst_RecWeightPoint1-19]==0xF0 || WeightConst_RecWeightData1[WeightConst_RecWeightPoint1-19]==0xFF)
                    && WeightConst_RecWeightData1[WeightConst_RecWeightPoint1-17]!=0x55)
				{  						
					 readnumber(WeightConst_RecWeightData1,WeightConst_RecWeightPoint1, 1, 6, 8, 0x80, 0xFF);                
				} 
		    WeightConst_RecWeightPoint1 = 0; //指针还原
		} else {
				WeightConst_RecWeightPoint1++;
		}		
}

static void P_XL10000() {
//	02 2A 30 20 30 30 30 32 32 30 30 30 30 30 30 30 0D 33
    if (WeightConst_RecWeightPoint1>38) WeightConst_RecWeightPoint1 = 0; //指针还原

    WeightConst_RecWeightData1[WeightConst_RecWeightPoint1] = rb_remove(rb_usart1) & 0x7F;

    if (WeightConst_RecWeightData1[WeightConst_RecWeightPoint1] == 0x02) {
			 WeightConst_RecWeightData1[0] = 0x02;
			 WeightConst_RecWeightPoint1 = 0;			
		}
    if (WeightConst_RecWeightData1[WeightConst_RecWeightPoint1] == 0x0D) 
		{
			  if (WeightConst_RecWeightPoint1 == 16)
				{  						
					 readnumber(WeightConst_RecWeightData1,WeightConst_RecWeightPoint1, 5, 6, 14, 0x02, 0xFF);                
				} 
		    WeightConst_RecWeightPoint1 = 0; //指针还原
		} else {
				WeightConst_RecWeightPoint1++;
		}

}

static void P_XK3190_A27E() {
//	77 6E 30 30 30 30 30 36 31 35 6B 67 0D 0A   615  boudrate=1200
//  77 6E 2D 30 30 30 30 30 36 35 6B 67 0D 0A   -65
    //  77 6E 2D 30 30 30 31 32 20 6B 67 0D 0A
    //  77 6E 30 30 30 30 31 2E 32 6B 67 0D 0A
    if (WeightConst_RecWeightPoint1>37) WeightConst_RecWeightPoint1 = 0; //指针还原

    WeightConst_RecWeightData1[WeightConst_RecWeightPoint1] = rb_remove(rb_usart1);
	  if (WeightConst_RecWeightData1[WeightConst_RecWeightPoint1] == 0x77) {
			 WeightConst_RecWeightData1[0] = 0x77;
			 WeightConst_RecWeightPoint1 = 0;			
		}
    if (WeightConst_RecWeightData1[WeightConst_RecWeightPoint1] == 0x0A) 
		{
			  if (WeightConst_RecWeightPoint1 == 13) {					
					 readnumber(WeightConst_RecWeightData1, WeightConst_RecWeightPoint1, 4, 6, 11, 0x2d, 0xFF);                
				}
				else if (WeightConst_RecWeightPoint1 == 12) {					
					 readnumber(WeightConst_RecWeightData1, WeightConst_RecWeightPoint1, 3, 6, 10, 0x2d, 0xFF);                
				}
		    WeightConst_RecWeightPoint1 = 0; //指针还原
		} else {
				WeightConst_RecWeightPoint1++;
		}	
}



static void P_NEWLabel() {
//	57 20 FC 01 29 00 04 00 00 00 00 00 00 00 00 00 00 00 00 00 00 44 C4 00 88 00 80 00 00 00 00 00 08 40 44 8C 00
    //  20 20 20 20 20 20 20 4E 45 54 20 57 45 49 47 48 54 20 20 20 20 20 20 20 54 
	  //4F 54 41 4C 20 57 45 49 47 48 54 3A 20 20 20 20 20 20 20 20 31 35 20 58 80 5C
    //4F 54 41 4C 20 57 45 49 47 48 54 3A 20 20 20 20 20 20 20 20 31 35 20
    // 16 17 18 19 20 21
//波特率  115200
    if (WeightConst_RecWeightPoint1>60) WeightConst_RecWeightPoint1 = 0; //指针还原

    WeightConst_RecWeightData1[WeightConst_RecWeightPoint1] = rb_remove(rb_usart1);
    if (WeightConst_RecWeightData1[WeightConst_RecWeightPoint1] == 0x4F) {
			 WeightConst_RecWeightData1[0] = 0x4F;
			 WeightConst_RecWeightPoint1 = 0;			
		}
    if (WeightConst_RecWeightPoint1 == 21)                
		{		
       if (WeightConst_RecWeightData1[0] == 0x4F && WeightConst_RecWeightData1[1] == 0x54 && WeightConst_RecWeightData1[2] == 0x41)	  	
					readnumber(WeightConst_RecWeightData1, WeightConst_RecWeightPoint1, 0, 7, 0xFF, 0x2d, 0xFF);  
		   WeightConst_RecWeightPoint1 = 0; //指针还原
		} else {
			 WeightConst_RecWeightPoint1++;
		}	    
}

static void P_PTM() {
//	02 30 30 54 4F 54 41 4C 20 57 45 49 47 48 54 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 4B 67 20 20 20 20 20 38 54 20 80 81 81 38 3E 03
//波特率  38400
    if (WeightConst_RecWeightPoint1>68) WeightConst_RecWeightPoint1 = 0; //指针还原

    WeightConst_RecWeightData1[WeightConst_RecWeightPoint1] = rb_remove(rb_usart1);

    if (WeightConst_RecWeightData1[WeightConst_RecWeightPoint1] == 0x02) {
			 WeightConst_RecWeightData1[0] = 0x02;
			 WeightConst_RecWeightPoint1 = 0;			
		}
    if (WeightConst_RecWeightData1[WeightConst_RecWeightPoint1] == 0x03) 
		{
			  if (WeightConst_RecWeightPoint1 == 48 ) 					
					 readnumber(WeightConst_RecWeightData1, WeightConst_RecWeightPoint1, 7, 6, 11, 0x2d, 0xFF);        
		    WeightConst_RecWeightPoint1 = 0; //指针还原
		} else {
				WeightConst_RecWeightPoint1++;
		}	 		
}

static void P_XDNZ_BC02() {
//	02 22 32 20 30 30 30 30 30 33 30 30 30 30 30 30 0D   -3
//  02 22 30 20 30 30 30 30 34 38 30 30 30 30 30 30 0D   48
//  02 22 30 20 30 30 30 30 36 34 30 30 30 30 30 30 0D   64

    if (WeightConst_RecWeightPoint1>33) WeightConst_RecWeightPoint1 = 0; //指针还原

    WeightConst_RecWeightData1[WeightConst_RecWeightPoint1] = rb_remove(rb_usart1) & 0x7F;

    if (WeightConst_RecWeightData1[WeightConst_RecWeightPoint1] == 0x02) {
			 WeightConst_RecWeightData1[0] = 0x02;
			 WeightConst_RecWeightPoint1 = 0;			
		}
    if (WeightConst_RecWeightData1[WeightConst_RecWeightPoint1] == 0x0D) 
		{  //  02 22 30 20 30 30 30 30 34 38 30 30 30 30 30 30 0D   48
			  if (WeightConst_RecWeightPoint1 == 16) 					
					 readnumber(WeightConst_RecWeightData1, WeightConst_RecWeightPoint1, 6, 6, 14, 0x32, 0xFF);        
		    WeightConst_RecWeightPoint1 = 0; //指针还原
		}
		else if (WeightConst_RecWeightData1[WeightConst_RecWeightPoint1] == 0x04){
		   //1B 4F 6D 30 32 02 2D 31 33 32 30 36 04 1B 4F 61 40 40 41 40 40 45 04 1B 4F 75 30 36 04 1A 04
			 if (WeightConst_RecWeightPoint1 == 7) 					
					 readnumber(WeightConst_RecWeightData1, WeightConst_RecWeightPoint1, 0, 6, 0xFF, 0x2D, 0xFF);        
		    WeightConst_RecWeightPoint1 = 0; //指针还原
		}
		else {
				WeightConst_RecWeightPoint1++;
		}	 
}

static void P_ID511() {
//	02 3A 50 70 30 30 30 30 30 35 30 30 30 30 30 30 0D
//  02 22 30 20 30 30 30 30 34 38 30 30 30 30 30 30 0D
    if (WeightConst_RecWeightPoint1>33) WeightConst_RecWeightPoint1 = 0; //指针还原

    WeightConst_RecWeightData1[WeightConst_RecWeightPoint1] = rb_remove(rb_usart1);
    if (WeightConst_RecWeightData1[WeightConst_RecWeightPoint1] == 0x02) {
			 WeightConst_RecWeightData1[0] = 0x02;
			 WeightConst_RecWeightPoint1 = 0;			
		}
    if (WeightConst_RecWeightData1[WeightConst_RecWeightPoint1] == 0x0D) 
		{
			 if (WeightConst_RecWeightPoint1 == 16) 					
				 readnumber(WeightConst_RecWeightData1, WeightConst_RecWeightPoint1, 6, 6, 15, 0x62, 0xFF);        
		   WeightConst_RecWeightPoint1 = 0; //指针还原
		} else {
			 WeightConst_RecWeightPoint1++;
		}			  
}

static void P_AD250() {
//	C9 20 20 20 20 33 38 3B 34 D9   38
//  C9 20 20 C4 31 32 38 36 38 D9   -128
//  C9 30 20 20 31 33 32 3C 3F D9   132
    if (WeightConst_RecWeightPoint1>33) WeightConst_RecWeightPoint1 = 0; //指针还原

    WeightConst_RecWeightData1[WeightConst_RecWeightPoint1] = rb_remove(rb_usart1);
	
    if (WeightConst_RecWeightData1[WeightConst_RecWeightPoint1] == 0xC9) {
			 WeightConst_RecWeightData1[0] = 0xC9;
			 WeightConst_RecWeightPoint1 = 0;			
		}
    if (WeightConst_RecWeightData1[WeightConst_RecWeightPoint1] == 0xD9) 
		{
			 if (WeightConst_RecWeightPoint1 == 9) 					
				 readnumber(WeightConst_RecWeightData1, WeightConst_RecWeightPoint1, 2, 6, 0xFF, 0xC4, 0xFF);        
		   WeightConst_RecWeightPoint1 = 0; //指针还原
		} else {
			 WeightConst_RecWeightPoint1++;
		}		    
}

extern unsigned char eid[10];
unsigned long long curEID = 0;      //当前临时耳标
unsigned long long lastEID = 0;      //上次临时耳标
static void ReadEID() {
	
 // 02 03 00 16 00 0a 24 3a  
 // 02 03 14 ff 57 83 e7 00 6b 96 1d 5d 00 ff 10 43 e6 1c be 99 1a 15 df 5d 31
	
    if (WeightConst_RecWeightPoint1>33) WeightConst_RecWeightPoint1 = 0; //指针还原

    WeightConst_RecWeightData1[WeightConst_RecWeightPoint1] = rb_remove(rb_usart1);

    if (WeightConst_RecWeightData1[WeightConst_RecWeightPoint1]==0x02) {
        WeightConst_RecWeightData1[0] = 0x02;
        WeightConst_RecWeightPoint1 = 0; //指针还原
        WeightConst_RecFlag1 = 0x00;
        WeightConst_Drop = 0;
    }

    if (WeightConst_RecFlag1 != 0xF0 && WeightConst_Drop==0) //上一条完整数据没有处理完
    {
        if (WeightConst_RecWeightPoint1<34) {
            if (WeightConst_RecWeightPoint1 >= 3 
                    && (WeightConst_RecWeightPoint1 >= WeightConst_RecWeightData1[2]+2)) {
                 // 02 03 14 ff 57 83 e7 00 6b 96 1d 5d 00 ff 10 43 e6 1c be 99 1a 15 df 5d 31
								eid[0]=5;
											
                for (int ReadWeight_i = 0; ReadWeight_i < 5; ReadWeight_i++) 
                   eid[ReadWeight_i+1] = WeightConst_RecWeightData1[ReadWeight_i+7];
											
                eid[eid[0]+1]= WeightConst_RecWeightData1[3];
							  eid[eid[0]+2]= WeightConst_RecWeightData1[4];				
							//	eid[1]=0x00;eid[2]=0x0C;eid[3]=0x12;eid[4]=0x63;eid[5]=0xE0;
								if (eid[eid[0]+1] ==0xFF){
									WeightConst_feed[0]=0xCE;
									WeightConst_feed[1]=0xDE;
									WeightConst_feed[2]=0xB6;
									WeightConst_feed[3]=0xFA;
									WeightConst_feed[4]=0xB1;
									WeightConst_feed[5]=0xEA;
									WeightConst_feed[6]=0x20;
									WeightConst_feed[7]=0x20;
								}
								else
								{
									curEID = 0;
									for (int i = 0; i < eid[0]; i++) {
										curEID = curEID << 8;										
										curEID = curEID | eid[i+1];										  
									}
									if (WeightConst_WeightCur>30 && lastEID != curEID)
									{	
										sendEIDWeight(eid, WeightConst_WeightCur);
									  lastEID = curEID;
									}
									rt_memset(WeightConst_feed, 0x20, 40);
									for (int SendDisplay_i = 0; SendDisplay_i < 8; SendDisplay_i++) {
										if (SendDisplay_i>0)	curEID=curEID/10;

										if (abs(curEID)>0)	WeightConst_feed[7-SendDisplay_i] = abs(curEID%10)+'0';
										else break;
						      }									
								}
								
                WeightConst_RecFlag1 = 0x00;
                WeightConst_Drop = 1; //开始抛弃数据
                WeightConst_RecWeightPoint1 = 0; //指针还原
            } else
                WeightConst_RecWeightPoint1++;
        }
        else WeightConst_RecWeightPoint1 = 0; //指针还原
    }
    else
    {
        WeightConst_RecWeightPoint1++;
    }
}

void ReadWeight(void)
{
	  rt_sem_take(display_lock, RT_WAITING_FOREVER);
		if (WeightConst_TQ==0)
				P_XDNZ_BC02();
		else if (WeightConst_TQ==1)
				//P_300G0();
				 P_XDNZ_BC02();
				//P_NEWLabel();
		else if (WeightConst_TQ==2)
				//P_300G1();
				P_AWT_ZM303();
		else if (WeightConst_TQ==3)
				P_XK3190_A27E();
		else if (WeightConst_TQ==4)
				P_TMI_II();
		else if (WeightConst_TQ==5)
				P_TMI_III();
		else if (WeightConst_TQ==6)
				P_EZ4300();
		else if (WeightConst_TQ==7)
				//P_TQ();
				P_AD250();
		else if (WeightConst_TQ==8)
				P_PTM();
		else if (WeightConst_TQ==9)
				 P_T_2000();
				//P_HF();
		else if (WeightConst_TQ==10)
				P_XL10000();
		else if (WeightConst_TQ==11)
				P_XK3190_C8();
		else if (WeightConst_TQ==12)
				P_TDI200I();
		//P_E_2000();
		else if (WeightConst_TQ==13)
				P_ID511();
		else  if (WeightConst_TQ==14) {
			 if (iscowweight==1) {
			   ReadEID();
			 }
			 else {
				 while (rb_full_count(rb_usart1) > 0) {
						rb_remove(rb_usart1);
					 }	
			 }	  
		}
		rt_sem_release(display_lock);
}

uint16_t tempWeight;
uint16_t tempWeighttime = 0;
void ReadWeightthread(void) {
	  WeightConst_WeightCurTem = HAL_RTCEx_BKUPRead(&hrtc, RTC_BKP_DR7);
		while(1)
		{			  
				if (WeightConst_TQ==14 );// && CanButton== 0x01);
				{
									
						tempWeight = get_weight();	
					
					  rt_sem_take(display_lock, RT_WAITING_FOREVER);
           
					  if (nag)	WeightConst_WeightCurTem = (signed long)(tempWeight*-1);
					  else WeightConst_WeightCurTem = (signed long)(tempWeight);
					  HAL_RTCEx_BKUPWrite(&hrtc,RTC_BKP_DR7, WeightConst_WeightCurTem);	
						WeightConst_WeightWS = ad_Point;
						setWeightSM();	
						rt_sem_release(display_lock);
				}
			  
				rt_thread_mdelay(125);
		}
}


union timekeyweight_t getTimeWeight(int i) {
    if ((i==0xF1) && (WeightConst_WeightOK > -32768)) {
        WeightConst_WeightLast = WeightConst_WeightOK;  //保存按键时的重量
        WeightConst_WeightOK = -32760;
    }
    else {
				rt_sem_take(weight_lock, RT_WAITING_FOREVER);
        WeightConst_WeightLast = WeightConst_WeightCur;  //保存按键时的重量
				rt_sem_release(weight_lock);
    }
		union timekeyweight_t timekeyweight;
		rt_sem_take(setTIME_lock, RT_WAITING_FOREVER);
		timekeyweight.data.datetime.year = TimeConst.data.year;
		timekeyweight.data.datetime.month = TimeConst.data.month;
		timekeyweight.data.datetime.date = TimeConst.data.date;
		timekeyweight.data.datetime.hh = TimeConst.data.hh;
		timekeyweight.data.datetime.mm = TimeConst.data.mm;
		timekeyweight.data.datetime.ss = TimeConst.data.ss;
		rt_sem_release(setTIME_lock);
		timekeyweight.data.WeightBegin = WeightConst_WeightBegin;
		timekeyweight.data.WeightLast = WeightConst_WeightLast;
	  timekeyweight.data.WeightWS = WeightConst_WeightWS;
		timekeyweight.data.WeightZF =  0;		
		timekeyweight.data.reserved =  0;
		timekeyweight.data.WeightRun = 1;

//    if (WeightConst_WeightLast < 0)
//        s[8] = (0<<7) | (WeightConst_WeightWS<<6>>1);
//    else
//        s[8] = (0<<7) | (WeightConst_WeightWS<<6>>1);
      return timekeyweight;
}


static rt_thread_t checkweight_tid = RT_NULL;

static rt_thread_t readweight_tid = RT_NULL;


void ReadWeight_thread(void)
{	
	  if (WeightConst_TQ==14 )
		{
				readweight_tid = rt_thread_create("ReadWeight",
																ReadWeightthread, RT_NULL,
																0x800,
																4, 5);

		/* 如果获得线程控制块，启动这个线程 */
				if (readweight_tid != RT_NULL) rt_thread_startup(readweight_tid);
		}
}


void CheckWeight_thread(void)
{	
		checkweight_tid = rt_thread_create("CheckWeight",
                            CheckWeightthread, RT_NULL,
                            0x400,
                            4, 5);

		/* 如果获得线程控制块，启动这个线程 */
		if (checkweight_tid != RT_NULL) rt_thread_startup(checkweight_tid);  	
}

void ReadEIDthread(void) {
    while (1) {			
			rt_sem_take(uart1_lock, RT_WAITING_FOREVER);
		//	02 03 00 16 00 05 64 3E  
		//	02 03 00 16 00 0a 24 3a
			usart1_send_data[0] = 0x02;		
			usart1_send_data[1] = 0x03;
			usart1_send_data[2] = 0x00;
			usart1_send_data[3] = 0x16;
			usart1_send_data[4] = 0x00;
			usart1_send_data[5] = 0x05;
			usart1_send_data[6] = 0x64;	
			usart1_send_data[7] = 0x3e;				

			HAL_UART_Transmit_DMA(&huart1, usart1_send_data, 8); //remoteSerial
			rt_thread_mdelay(50);
			rt_sem_release(uart1_lock);
		
			rt_thread_mdelay(1000);
    }
}

static rt_thread_t readEID_tid = RT_NULL;
void ReadEID_thread(void)
{	
	extern unsigned char  iscowweight;
	  if (iscowweight==1 )
		{
				readEID_tid = rt_thread_create("ReadEID",
																ReadEIDthread, RT_NULL,
																0x200,
																4, 5);

		/* 如果获得线程控制块，启动这个线程 */
				if (readEID_tid != RT_NULL) rt_thread_startup(readEID_tid);
		}
}