TMRWatchNew/tmr/flash.c

#include <flashdb.h>
#include <rtthread.h>
#include "plan.h"
#include "rtc.h"
#include "buffer.h"
#include "button.h"
#include "display.h"
#include <string.h>

uint8_t  isCC = 0 ;
uint8_t  isBLE =0;  //用蓝牙传输
uint8_t  isNsmall =1;  //新小屏
uint8_t  isnewBan =0;  //隔离主板
const uint8_t  isTag = 0 ; //是否含识读标签
unsigned char  isn = 0;  //是否新大屏
unsigned char  remote_sumweight = 0;  //远程是否包含重量
unsigned char  iscowweight = 0;  //是否奶牛秤
unsigned char eid[10];    //电子耳标，0为长度

uint8_t XbeeConst_DeviceAddress = 0x01;         
uint8_t XbeeConst_NetAddress = 0x00;
uint8_t XbeeConst_UseAPI = 0x00;
uint8_t WeightConst_TQ = 0x05;//0x05;
uint8_t WeightConst_BLE = 0;
uint8_t WeightConst_ChanCheShu = 0x02;
uint8_t WeightConst_SBType = 0x03;


int16_t WeightConst_WeightBegin = -3000;    //按键开始重量

uint8_t ad_Percent=  0x00;             //   7，    校正重量，1字节
unsigned int  ad_Maxval=   0x00007530;       //   8，    最大称量，4字节
uint8_t ad_FS=       0x04;             //  12，    滤波深度，1字节
uint8_t ad_Point=    0x00;             //  13，    小数点，  1字节
uint8_t ad_Inteval=  0x02;             //  14，    分度值，  1字节
float  ad_Spanz =   0.9;       //  15，    分度内码数， 4字节
unsigned int  ad_Zero =    0x00000000;       //  19，    真零内码，  4字节
unsigned int  ad_Tare =    0x00002320;       //  23，    皮零内码，  4字节  

static uint32_t read_key = 1;
static uint32_t read_plan = 1;
static uint32_t read_weight = 1;

//static uint16_t plan_lastframe = 0;

static struct fdb_default_kv_node default_kv_table[] = {       
    {"CH",                &XbeeConst_DeviceAddress, sizeof(XbeeConst_DeviceAddress)},     //  1,    车号，    1字节
    {"TQ",                &WeightConst_TQ,          sizeof(WeightConst_TQ)},              //  2,    提取方式，1字节
    {"PM",                &WeightConst_SBType,      sizeof(WeightConst_SBType)},          //  3,    屏幕类型，1字节     6、海安  7长屏铲车  8 新彩屏
    {"WL",                &XbeeConst_NetAddress,    sizeof(XbeeConst_NetAddress)},        //  4,    网络地址，1字节
    {"API",               &XbeeConst_UseAPI,        sizeof(XbeeConst_UseAPI)},            //  5,    使用API，1字节
    {"CC",                &WeightConst_ChanCheShu,  sizeof(WeightConst_ChanCheShu)},      //  6，   TMR数量，1字节
    {"BLE",               &WeightConst_BLE,         sizeof(WeightConst_BLE)},             //  27，    皮零内码，  4字节
///////////////////////////////////////////////////////////////////////////////////////
    {"ad_Percent",        &ad_Percent, sizeof(ad_Percent)},    //  7，    校正重量，1字节
    {"ad_Maxval",         &ad_Maxval,  sizeof(ad_Maxval)},      //  8， 最大称量，4字节
    {"ad_FS",             &ad_FS,      sizeof(ad_FS)},              //  12，   滤波深度，1字节
    {"ad_Point",          &ad_Point,   sizeof(ad_Point)},        //  13，    小数点，  1字节
    {"ad_Inteval",        &ad_Inteval, sizeof(ad_Inteval)},    //  14，    分度值，  1字节
    {"ad_Spanz",          &ad_Spanz,   sizeof(ad_Spanz)},        //  15，    分度内码数， 4字节
    {"ad_Zero",           &ad_Zero,    sizeof(ad_Zero)},          //  19，    真零内码，  4字节
    {"ad_Tare",           &ad_Tare,    sizeof(ad_Tare)},          //  23，    皮零内码，  4字节
		
	  {"read_key",          &read_key,    sizeof(read_key)},  
    {"read_plan",         &read_plan,   sizeof(read_plan)}, 
    {"read_weight",       &read_weight, sizeof(read_weight)}, 
		
    {"beginweight",       &WeightConst_WeightBegin, sizeof(WeightConst_WeightBegin)}, 
    {"begintime",         &TimeConst, sizeof(TimeConst)}, 
    {"completeorder",     &CompleteTarget_order, sizeof(CompleteTarget_order)}, 
		
    {"TimeConst",       &TimeConst, sizeof(TimeConst)}, 
};

#define FDB_LOG_TAG "[main]"

struct fdb_tsdb ts_keydb = { 0 };
struct fdb_tsdb ts_plandb = { 0 };
struct fdb_tsdb ts_weightdb = { 0 };
struct fdb_kvdb kvdb = { 0 };

static uint32_t ts_keyTime = 0;
static uint32_t ts_planTime = 0;
static uint32_t ts_weightTime = 0;

rt_sem_t kv_db_lock;

static void lock(fdb_db_t db)
{
	 rt_sem_take(kv_db_lock, RT_WAITING_FOREVER);
	 __disable_irq();
}

static void unlock(fdb_db_t db)
{	 
	__enable_irq();
	rt_sem_release(kv_db_lock);
}

static fdb_time_t get_keydbtime(void)
{
    return ++ts_keyTime;
}

void write_Flash(const char *key, const void *value_buf, size_t buf_len)
{
		struct fdb_blob blob;
		fdb_kv_set_blob(&kvdb, key, fdb_blob_make(&blob, (void *)value_buf, buf_len));
}

void reset_read_ts(const char key)
{
		if (key == 'k'){ 				
					read_key = ts_keyTime+1;
					write_Flash("read_key", &read_key, sizeof(read_key));			
		}else if (key == 'p'){ 
					read_plan = ts_planTime+1;
					write_Flash("read_plan", &read_plan, sizeof(read_plan));
//          rt_kprintf("read_plan:%02X \n",read_plan);				
	  }else { 
					read_weight = ts_weightTime+1;
					write_Flash("read_weight", &read_weight, sizeof(read_weight));			
	  };
		
		
}

void init_allflash(void)
{
		//   fdb_kv_set_default(&kvdb);
		   fdb_tsl_clean(&ts_weightdb);
			 fdb_tsl_clean(&ts_plandb);
			 fdb_tsl_clean(&ts_keydb);
				ts_keyTime=0;
				ts_planTime=0;
				ts_weightTime=0;
				reset_read_ts('k');
				reset_read_ts('p');
				reset_read_ts('w');
}

static fdb_time_t get_plandbtime(void)
{
    return ++ts_planTime;
}

static fdb_time_t get_weightdbtime(void)
{
    return ++ts_weightTime;
}

uint32_t tsdb_recordcount(const char key)
{
		if (key== 'k'){ 
			 if (read_key > ts_keyTime || ts_keyTime == 0 ) return 0;
			 else
					return ts_keyTime-read_key+1;
		}
		else if (key== 'p'){ 
			if (read_plan > ts_planTime || ts_planTime == 0 ) return 0;
			 else
			 return ts_planTime-read_plan+1;
		}
		else if (read_weight > ts_weightTime || ts_weightTime == 0 ) return 0;
		else
		 return ts_weightTime-read_weight+1;
} 

	
static  uint8_t foundF8 = 0;

static bool query_f8_cb(fdb_tsl_t tsl, void *arg)
{
	if (tsl->status<10 && tsl->log_len<100) {
    struct fdb_blob blob;
	  unsigned char buf[tsl->log_len];
    fdb_tsdb_t db = arg;
	  rt_memset(buf, 0, tsl->log_len);
    fdb_blob_read((fdb_db_t) db, fdb_tsl_to_blob(tsl, fdb_blob_make(&blob, &buf, tsl->log_len)));
    if ((buf[3]==0xf8 || buf[3]==0xE8) && tsl->status==FDB_TSL_WRITE)
		{
			foundF8 = 1;
			return true;
		}
	}
		return false;
		//write_Flash("read_key", &ts_keyTime, sizeof(ts_keyTime)); 
}

void findF8(void)
{	 	
   fdb_tsl_iter_by_time(&ts_keydb, read_key, 0x7FFFFFFF, query_f8_cb, &ts_keydb);
}

static  uint8_t foundF4 = 0;
static bool query_f4_cb(fdb_tsl_t tsl, void *arg)
{
	if (tsl->status<10 && tsl->log_len<100) {
    struct fdb_blob blob;
	
	  unsigned char buf[tsl->log_len];
    fdb_tsdb_t db = arg;
	  
	  rt_memset(buf, 0, tsl->log_len);
    fdb_blob_read((fdb_db_t) db, fdb_tsl_to_blob(tsl, fdb_blob_make(&blob, &buf, tsl->log_len)));
    if ((buf[3]==0xf4 || buf[3]==0xE4) && tsl->status==FDB_TSL_WRITE)
		{
			foundF4 = 1;
			return true;
		}
	}
		return false;
		//write_Flash("read_key", &ts_keyTime, sizeof(ts_keyTime)); 
}

void findF4(void)
{	 	
   fdb_tsl_iter_by_time(&ts_keydb, read_key, 0x7FFFFFFF, query_f4_cb, &ts_keydb);
}

static bool query_f12_cb(fdb_tsl_t tsl, void *arg)
{
	if (tsl->status<10 && tsl->log_len<100) {
    struct fdb_blob blob;
	  unsigned char buf[tsl->log_len];
	  unsigned char len = 0;
    fdb_tsdb_t db = arg;
	  if (tsl->log_len>40) len=40;
	  else len=tsl->log_len;
		rt_memset(WeightConst_PlantempList, 0x20, tsl->log_len);
		fdb_blob_read((fdb_db_t) db, fdb_tsl_to_blob(tsl, fdb_blob_make(&blob, &buf, tsl->log_len)));
		rt_memcpy(WeightConst_PlantempList,buf, len);
		if (buf[3]==0x12 && tsl->status==FDB_TSL_WRITE)
		{
				WeightConst_Run = 1;
				rt_memset(WeightConst_product,0x20,40);				
				rt_memset(WeightConst_feed,0x20,40);				
				for (int i = 0; i <= buf[1]-10; i++) {
						WeightConst_product[i] = buf[i+4];   //产品名称
						if (WeightConst_SBType==1||WeightConst_SBType==6) 
								WeightConst_feed[i] = WeightConst_product[i];   //显示一秒牛舍
				}
				plan_comp.Buffer[0] = buf[buf[1]-5+1];   //产品名称
				plan_comp.Buffer[1] = buf[buf[1]-5];   //产品名称
				for (int i = 2; i < 6; i++) 
						plan_comp.Buffer[i] = buf[buf[1]-5+i];   //产品名称		       			
		}
	}
		return false;
}

void findF12(void)
{	 
   uint8_t	i = 0;
	 if (read_plan>50) i = read_plan-50;
	
   fdb_tsl_iter_by_time(&ts_plandb, i, read_plan, query_f12_cb, &ts_plandb);
}

static  uint32_t foundkey = 0;
static bool query_key_cb(fdb_tsl_t tsl, void *arg)
{
	if (tsl->status<10 && tsl->log_len<100) {
    struct fdb_blob blob;
	  //unsigned char buf[tsl->log_len];
    fdb_tsdb_t db = arg;
	  rt_memset(XbeeConst_FTxBuf0, 0, tsl->log_len);
    fdb_blob_read((fdb_db_t) db, fdb_tsl_to_blob(tsl, fdb_blob_make(&blob, &XbeeConst_FTxBuf0, tsl->log_len)));
	  for (int i=tsl->log_len; i>0; i--)
		{
			XbeeConst_FTxBuf0[i] = XbeeConst_FTxBuf0[i-1];
		}
		XbeeConst_FTxBuf0[0] = tsl->log_len;
    if (tsl->status==FDB_TSL_WRITE)
		{
			foundkey = tsl->time;
		//	
			return true;
		}
	}
		return false;
}

uint32_t findkey(uint8_t i)
{	 
	 foundkey = 0x7FFFFFFF;
   fdb_tsl_iter_by_time(&ts_keydb, read_key, 0x7FFFFFFF, query_key_cb, &ts_keydb);
	 if (i>0) read_key = foundkey;
	 return foundkey;
	//return 0xFFFFFFFF;
}

void save_read_ts(const char key)
{
	if (tsdb_recordcount(key)>0)
	{
		
		if (key == 'k'){ 	
        if (findkey(0)<0x7FFFFFFF){	
					if(XbeeConst_FrameNumLast == XbeeConst_FTxBuf0[XbeeConst_FTxBuf0[0]-1]){
						read_key++;			
						write_Flash("read_key", &read_key, sizeof(read_key));			
			   	}
				}
		}else if (key == 'p'){ 
					read_plan++;
					write_Flash("read_plan", &read_plan, sizeof(read_plan));			
//			    rt_kprintf("read_plan save_read_t:%02X \n",read_plan);			
	  }else { 
					read_weight++;
					write_Flash("read_weight", &read_weight, sizeof(read_weight));			
	  };
	}
}



void back_read_plan(void)
{
  if (read_plan>1)
	{
      read_plan = read_plan-2;
		  save_read_ts('p');
	}
}

static  uint32_t foundplan = 0;
static bool query_plan_cb(fdb_tsl_t tsl, void *arg)
{
	if (tsl->status<10 && tsl->log_len<100) {
    struct fdb_blob blob;
	  //unsigned char buf[tsl->log_len];
    fdb_tsdb_t db = arg;
	  rt_memset(WeightConst_PlantempList, 0, tsl->log_len);
    fdb_blob_read((fdb_db_t) db, fdb_tsl_to_blob(tsl, fdb_blob_make(&blob, &WeightConst_PlantempList, tsl->log_len)));
	
    if (tsl->status==FDB_TSL_WRITE)
		{
			foundplan = tsl->time;
			read_plan = tsl->time;
			return true;
		}
	}
		return false;
}

uint32_t findplan(void)
{	 
	 foundplan = 0;
//	 rt_kprintf("read_plan findplan:%02X \n",read_plan);			
   fdb_tsl_iter_by_time(&ts_plandb, read_plan, 0x7FFFFFFF, query_plan_cb, &ts_plandb);

	 return foundplan;
}

static  uint8_t foundlastplan = 0;
static bool query_lastplan_cb(fdb_tsl_t tsl, void *arg)
{
	if (tsl->status<10 && tsl->log_len<100) {
    struct fdb_blob blob;
	  //unsigned char buf[tsl->log_len];
    fdb_tsdb_t db = arg;
	  rt_memset(WeightConst_PlanLastList, 0, tsl->log_len);
    fdb_blob_read((fdb_db_t) db, fdb_tsl_to_blob(tsl, fdb_blob_make(&blob, &WeightConst_PlanLastList, tsl->log_len)));
	
    if (tsl->status==FDB_TSL_WRITE)
		{
			if (WeightConst_PlanLastList[3]==0x15)
			  foundlastplan = WeightConst_PlanLastList[WeightConst_PlanLastList[1]-1];
			
			return true;
		}
	}
		return false;
}

uint32_t findlastplan(void)
{	 
	 foundlastplan = 0xF0;
//	 rt_kprintf("read_plan findplan:%02X \n",read_plan);			
   fdb_tsl_iter_by_time(&ts_plandb, ts_planTime, 0x7FFFFFFF, query_lastplan_cb, &ts_plandb);
	 return foundlastplan;
}
static  uint32_t foundNextplan = 0;
static bool query_Nextplan_cb(fdb_tsl_t tsl, void *arg)
{
	if (tsl->status<10 && tsl->log_len<100) {
    struct fdb_blob blob;
    fdb_tsdb_t db = arg;
	  uint8_t Nextfeedlength = 0;
	  rt_memset(WeightConst_Nextfeed, 0x20, tsl->log_len);
    fdb_blob_read((fdb_db_t) db, fdb_tsl_to_blob(tsl, fdb_blob_make(&blob, &WeightConst_Nextfeed, tsl->log_len)));
	
    if (tsl->status==FDB_TSL_WRITE)
		{
			foundNextplan = tsl->time;
			if (WeightConst_Nextfeed[3]==0x15) {	
        Nextfeedlength = WeightConst_Nextfeed[1];		
				
				WeightConst_NextWeightTarget = WeightConst_Nextfeed[Nextfeedlength-6]<<8 ;         //目标总量
				WeightConst_NextWeightTarget = WeightConst_NextWeightTarget | WeightConst_Nextfeed[Nextfeedlength-5];
				for (int i = 0; i <= Nextfeedlength-11; i++)
						WeightConst_Nextfeed[i] = WeightConst_Nextfeed[i+4]; 
				for (int i = Nextfeedlength-11; i <= tsl->log_len; i++) 
						WeightConst_Nextfeed[i] = 0x20; 		
			}
			return true;
		}
	}
		return false;
}

uint32_t findNextplan(void)
{	 
	 foundNextplan = 0;
   fdb_tsl_iter_by_time(&ts_plandb, read_plan+1, 0x7FFFFFFF, query_Nextplan_cb, &ts_plandb);
	 return foundNextplan;
}


static  uint32_t foundweight = 0;
static  uint32_t read_weight_temp = 0;
static bool query_weight_cb(fdb_tsl_t tsl, void *arg)
{
	if (tsl->status<10 && tsl->log_len<100) {
    struct fdb_blob blob;
	  unsigned char buf[7];
    fdb_tsdb_t db = arg;
    fdb_blob_read((fdb_db_t) db, fdb_tsl_to_blob(tsl, fdb_blob_make(&blob, &buf, 7)));
	  for (int i=7; i>0; i--)
				XbeeConst_FTxBuf0[4+foundweight*7+i] = buf[7-i];

		read_weight_temp = tsl->time;
		foundweight++;

		return foundweight>3;
	}
	else return false;
}

uint32_t findweight(void)
{		
	 unsigned char CRCNum=0;
	 foundweight = 0;
	 read_weight_temp = read_weight;
	 rt_memset(XbeeConst_FTxBuf0, 0, 0x22);
  
   fdb_tsl_iter_by_time(&ts_weightdb, read_weight, 0x7FFFFFFF, query_weight_cb, &ts_weightdb);
	 if (foundweight>3){
		   XbeeConst_FTxBuf0[0] = 0x22;
			 XbeeConst_FTxBuf0[1] = 0x7E;
			 XbeeConst_FTxBuf0[2] = 0x20;
			 XbeeConst_FTxBuf0[3] = XbeeConst_DeviceAddress;
			 XbeeConst_FTxBuf0[4] = 0xF0;
			 XbeeConst_FTxBuf0[33] = XbeeConst_FrameNum ++;
		   HAL_RTCEx_BKUPWrite(&hrtc,RTC_BKP_DR3, XbeeConst_FTxBuf0[33]);
			 for (int i=1; i< 34; i++)  CRCNum+=XbeeConst_FTxBuf0[i];
			 XbeeConst_FTxBuf0[34] = 0xFF - CRCNum;
		   read_weight = read_weight_temp;
	 }
	 return foundweight;
}

uint8_t ts_pushArrary(fdb_tsdb_t db, uint8_t *buf, uint8_t length)  
{
		struct fdb_blob blob;	
		fdb_err_t result = FDB_NO_ERR;
		foundF8 = 0;
	  foundF4 = 0;
		if (strcmp(((fdb_db_t)db)->name, "key") == 0 && (buf[3] == 0xF8 || buf[3] == 0xE8))
			findF8();
		
    if (strcmp(((fdb_db_t)db)->name, "key") == 0 && (buf[3] == 0xF4 || buf[3] == 0xE4))
			findF4();
		
		if (foundF8==0 && foundF4==0){
			 while (fdb_tsl_append(db, fdb_blob_make(&blob, buf, length))!= FDB_NO_ERR){
			   rt_thread_mdelay(10);
			 }
				//result = fdb_tsl_append(db, fdb_blob_make(&blob, buf, length));	
			//	if (result != FDB_NO_ERR)
				//{	 
//					rt_kprintf("ts_pushArrary:%02X \n", ts_planTime);		
				//	return 0;
			//	}
		}		
	
		return 1;
}

extern uint8_t  isNsmall;
void read_Flash(void)
{
		struct fdb_blob blob;
	
		fdb_kv_get_blob(&kvdb, "CH", fdb_blob_make(&blob, &XbeeConst_DeviceAddress, sizeof(XbeeConst_DeviceAddress)));
		fdb_kv_get_blob(&kvdb, "TQ", fdb_blob_make(&blob, &WeightConst_TQ, sizeof(WeightConst_TQ)));
		fdb_kv_get_blob(&kvdb, "PM", fdb_blob_make(&blob, &WeightConst_SBType, sizeof(WeightConst_SBType)));
		fdb_kv_get_blob(&kvdb, "WL", fdb_blob_make(&blob, &XbeeConst_NetAddress, sizeof(XbeeConst_NetAddress)));
		fdb_kv_get_blob(&kvdb, "API", fdb_blob_make(&blob, &XbeeConst_UseAPI, sizeof(XbeeConst_UseAPI)));
		fdb_kv_get_blob(&kvdb, "CC", fdb_blob_make(&blob, &WeightConst_ChanCheShu, sizeof(WeightConst_ChanCheShu)));
		fdb_kv_get_blob(&kvdb, "BLE", fdb_blob_make(&blob, &WeightConst_BLE, sizeof(WeightConst_BLE)));
    if (WeightConst_BLE>1) isCC=1;
	
		fdb_kv_get_blob(&kvdb, "ad_Percent", fdb_blob_make(&blob, &ad_Percent, sizeof(ad_Percent)));
		fdb_kv_get_blob(&kvdb, "ad_Maxval", fdb_blob_make(&blob, &ad_Maxval, sizeof(ad_Maxval)));
		fdb_kv_get_blob(&kvdb, "ad_FS", fdb_blob_make(&blob, &ad_FS, sizeof(ad_FS)));
		fdb_kv_get_blob(&kvdb, "ad_Point", fdb_blob_make(&blob, &ad_Point, sizeof(ad_Point)));
		fdb_kv_get_blob(&kvdb, "ad_Inteval", fdb_blob_make(&blob, &ad_Inteval, sizeof(ad_Inteval)));
		fdb_kv_get_blob(&kvdb, "ad_Spanz", fdb_blob_make(&blob, &ad_Spanz, sizeof(ad_Spanz)));
		fdb_kv_get_blob(&kvdb, "ad_Zero", fdb_blob_make(&blob, &ad_Zero, sizeof(ad_Zero)));
		fdb_kv_get_blob(&kvdb, "ad_Tare", fdb_blob_make(&blob, &ad_Tare, sizeof(ad_Tare)));
	
	  fdb_kv_get_blob(&kvdb, "read_key", fdb_blob_make(&blob, &read_key, sizeof(read_key)));
	  fdb_kv_get_blob(&kvdb, "read_plan", fdb_blob_make(&blob, &read_plan, sizeof(read_plan)));
	  fdb_kv_get_blob(&kvdb, "read_weight", fdb_blob_make(&blob, &read_weight, sizeof(read_weight)));
		
		fdb_kv_get_blob(&kvdb, "beginweight", fdb_blob_make(&blob, &WeightConst_WeightBegin, sizeof(WeightConst_WeightBegin)));
		fdb_kv_get_blob(&kvdb, "begintime", fdb_blob_make(&blob, &TimeConst, sizeof(TimeConst)));
	  fdb_kv_get_blob(&kvdb, "completeorder", fdb_blob_make(&blob, &CompleteTarget_order, sizeof(CompleteTarget_order)));
		
	  fdb_kv_get_blob(&kvdb, "TimeConst", fdb_blob_make(&blob, &TimeConst, sizeof(TimeConst)));
		
    if (isNsmall){
			WeightConst_SBType = 3;
		}
}


void onbordflash_init(void)
{
		fdb_err_t result;
	  struct fdb_default_kv default_kv;
	
	  kv_db_lock = rt_sem_create("kv_db_lock", 1, RT_IPC_FLAG_FIFO);
    default_kv.kvs = default_kv_table;
    default_kv.num = sizeof(default_kv_table) / sizeof(default_kv_table[0]);		
	
	  fdb_kvdb_control(&kvdb, FDB_KVDB_CTRL_SET_LOCK, lock);
    fdb_kvdb_control(&kvdb, FDB_KVDB_CTRL_SET_UNLOCK, unlock);
	
	  result = fdb_kvdb_init(&kvdb, "env", "kv", &default_kv, NULL);

    if (result != FDB_NO_ERR) {
      return ;
		}			
		/////////////
		fdb_tsdb_control(&ts_keydb, FDB_TSDB_CTRL_SET_LOCK, lock);
		fdb_tsdb_control(&ts_keydb, FDB_TSDB_CTRL_SET_UNLOCK, unlock);
	
		result = fdb_tsdb_init(&ts_keydb, "key", "ts_key", get_keydbtime, 48, NULL);
	
	  if (result != FDB_NO_ERR) {
          return ;
		}
		/* read last saved time for simulated timestamp */
		fdb_tsdb_control(&ts_keydb, FDB_TSDB_CTRL_GET_LAST_TIME, &ts_keyTime);
		/////////////////		
		
		/////////////
		fdb_tsdb_control(&ts_plandb, FDB_TSDB_CTRL_SET_LOCK, lock);
		fdb_tsdb_control(&ts_plandb, FDB_TSDB_CTRL_SET_UNLOCK, unlock);
	
		result = fdb_tsdb_init(&ts_plandb, "plan", "ts_plan", get_plandbtime, 48, NULL);
	
	  if (result != FDB_NO_ERR) {
          return ;
		}
		/* read last saved time for simulated timestamp */
		fdb_tsdb_control(&ts_plandb, FDB_TSDB_CTRL_GET_LAST_TIME, &ts_planTime);
		/////////////////		
		/////////////
		fdb_tsdb_control(&ts_weightdb, FDB_TSDB_CTRL_SET_LOCK, lock);
		fdb_tsdb_control(&ts_weightdb, FDB_TSDB_CTRL_SET_UNLOCK, unlock);
	
		result = fdb_tsdb_init(&ts_weightdb, "weight", "ts_weight", get_weightdbtime, 7, NULL);
	
	  if (result != FDB_NO_ERR) {
          return ;
		}
		/* read last saved time for simulated timestamp */
		fdb_tsdb_control(&ts_weightdb, FDB_TSDB_CTRL_GET_LAST_TIME, &ts_weightTime);
		/////////////////
		read_Flash();
}

void saveApi(rt_sem_t lock_sem,UART_HandleTypeDef *huart, uint8_t *pData)
{	
		//保存命令
		pData[0] = 0x41;
		pData[1] = 0x54;
		pData[2] = 0x57;
		pData[3] = 0x52;
		pData[4] = 0x0D;
		HAL_UART_Transmit_DMA(huart, pData, 5);
		if (rt_sem_take(lock_sem, 2000) == RT_EOK) {
			 //退出命令
				pData[0] = 0x41;
				pData[1] = 0x54;
				pData[2] = 0x43;
				pData[3] = 0x4E;
				pData[4] = 0x0D;
				HAL_UART_Transmit_DMA(huart, pData, 5);	
				if (rt_sem_take(lock_sem, 2000) != RT_EOK)
					rt_sem_release(lock_sem);
				else rt_sem_release(lock_sem);									
		} else rt_sem_release(lock_sem);
}

void enterApi(rt_sem_t lock_sem, UART_HandleTypeDef *huart, uint8_t *pData)
{
    unsigned char i;
		for (i = 0; i < 3; i++)
				pData[i] = 0x2B;
		rt_sem_take(lock_sem, RT_WAITING_FOREVER);
		HAL_UART_Transmit_DMA(huart, pData, 3);
}

void setAPI(void)
{
    if (!XbeeConst_UseAPI && iscowweight<1)
    {
        enterApi(uart3_lock, &huart3, usart3_send_data);
		  	if (rt_sem_take(uart3_lock, 2000) == RT_EOK) {
				  usart3_send_data[0] = 0x41;
					usart3_send_data[1] = 0x54;
					usart3_send_data[2] = 0x41;
					usart3_send_data[3] = 0x50;
					usart3_send_data[4] = 0x30;
					usart3_send_data[5] = 0x0D;
					
					HAL_UART_Transmit_DMA(&huart3, usart3_send_data, 6);
					if (rt_sem_take(uart3_lock, 2000) == RT_EOK) {
							saveApi(uart3_lock, &huart3, usart3_send_data);
					 } else rt_sem_release(uart3_lock);					
				} else rt_sem_release(uart3_lock);
    }
		
		enterApi(uart2_lock, &huart2, usart2_send_data);
		if (rt_sem_take(uart2_lock, 2000) == RT_EOK) {
			//设置API Enable =2
			usart2_send_data[0] = 0x41;
			usart2_send_data[1] = 0x54;
			usart2_send_data[2] = 0x41;
			usart2_send_data[3] = 0x50;
			if (XbeeConst_UseAPI>0)
					usart2_send_data[4] = 0x32;
			else
					usart2_send_data[4] = 0x30;
			usart2_send_data[5] = 0x0D;
			
			HAL_UART_Transmit_DMA(&huart2, usart2_send_data, 6);
			if (rt_sem_take(uart2_lock, 2000) == RT_EOK) {
					saveApi(uart2_lock, &huart2, usart2_send_data);
				  beep();
				  rt_thread_mdelay(500);
				  beep();
				  return;
			} else rt_sem_release(uart2_lock);					
		} else rt_sem_release(uart2_lock);
		beep();
}


void setNetAddress(void)
{
		if (!XbeeConst_UseAPI && iscowweight<1)
    {
        enterApi(uart3_lock, &huart3, usart3_send_data);
		  	if (rt_sem_take(uart3_lock, 2000) == RT_EOK) {
					usart3_send_data[0] = 0x41;
					usart3_send_data[1] = 0x54;
					usart3_send_data[2] = 0x49;
					usart3_send_data[3] = 0x44;
					usart3_send_data[4] = 0x37;
					usart3_send_data[5] = 0x46;
					usart3_send_data[6] = 0x46;
					usart3_send_data[7] = 0x45;
					usart3_send_data[8] = 0x0D;
					
					HAL_UART_Transmit_DMA(&huart3, usart3_send_data, 9);
					if (rt_sem_take(uart3_lock, 2000) == RT_EOK) {
							saveApi(uart3_lock, &huart3, usart3_send_data);
					 } else rt_sem_release(uart3_lock);					
				} else rt_sem_release(uart3_lock);
    }
		
		enterApi(uart2_lock, &huart2, usart2_send_data);
		if (rt_sem_take(uart2_lock, 2000) == RT_EOK) {
			//设置API Enable =2
			usart2_send_data[0] = 0x41;
			usart2_send_data[1] = 0x54;
			usart2_send_data[2] = 0x49;
			usart2_send_data[3] = 0x44;
			usart2_send_data[4] = 0x37;
			usart2_send_data[5] = 0x46;
			usart2_send_data[6] = 0x46;
			if(XbeeConst_NetAddress>0)
			{
					if (XbeeConst_NetAddress>9)	usart2_send_data[7] = (XbeeConst_NetAddress-10)+0x41;
					else	 usart2_send_data[7] = XbeeConst_NetAddress+0x30;
			}
			else	usart2_send_data[7] = 0x46;
			usart2_send_data[8] = 0x0D;
			
			HAL_UART_Transmit_DMA(&huart2, usart2_send_data, 9);
			if (rt_sem_take(uart2_lock, 2000) == RT_EOK) {
					saveApi(uart2_lock, &huart2, usart2_send_data);
				  beep();
				  rt_thread_mdelay(500);
				  beep();
				  return;
			} else rt_sem_release(uart2_lock);					
		} else rt_sem_release(uart2_lock);
		beep();
}
/*
void setBT(void)
{
    //进入命令
    // WeightConst_Weight_display[7] = 0x20;WeightConst_Weight_display[6] = 0x20;
    //	WeightConst_Weight_display[5] = 0x20;WeightConst_Weight_display[4] = 0x20;
    unsigned char sendCount=0,i;
    for (int SendDisplay_i = 0; SendDisplay_i < 8; SendDisplay_i++)   //显示重量
        WeightConst_Weight_display[SendDisplay_i]=0x20;
    USART3_Configuration(0);
    sendCount = 0;
    while(sendCount<2)
    {
        setBT_timer = 1;
        //AT+CLRBAND   AT+HOSTEN1
        usart3_send_data[0] = 0x41;
        usart3_send_data[1] = 0x54;
        usart3_send_data[2] = 0x2B;
        usart3_send_data[3] = 0x43;
        usart3_send_data[4] = 0x4C;
        usart3_send_data[5] = 0x52;
        usart3_send_data[6] = 0x42;
        usart3_send_data[7] = 0x41;
        usart3_send_data[8] = 0x4E;
        usart3_send_data[9] = 0x44;
        USART_Send_DMA(remoteSerial, 0x0A);

        while(setBT_timer>0 && setBT_timer<500);
        if (setBT_timer>=500)
            sendCount++;
        else if(setBT_timer==0)
            sendCount=4;
    }


    sendCount = 0;
    while(sendCount<2)
    {
        setBT_timer = 1;
        //41 54 2B 48 4F 53 54 45 4E 31   AT+HOSTEN1
        usart3_send_data[0] = 0x41;
        usart3_send_data[1] = 0x54;
        usart3_send_data[2] = 0x2B;
        usart3_send_data[3] = 0x48;
        usart3_send_data[4] = 0x4F;
        usart3_send_data[5] = 0x53;
        usart3_send_data[6] = 0x54;
        usart3_send_data[7] = 0x45;
        usart3_send_data[8] = 0x4E;
        usart3_send_data[9] = 0x31;
        USART_Send_DMA(remoteSerial, 0x0A);

        while(setBT_timer>0 && setBT_timer<500);
        if (setBT_timer>=500)
            sendCount++;
        else if(setBT_timer==0)
            sendCount=4;
    }

    sendCount = 0;
    while(sendCount<2)
    {
        setBT_timer = 1;
        //AT+RST
        usart3_send_data[0] = 0x41;
        usart3_send_data[1] = 0x54;
        usart3_send_data[2] = 0x2B;
        usart3_send_data[3] = 0x52;
        usart3_send_data[4] = 0x53;
        usart3_send_data[5] = 0x54;
        USART_Send_DMA(remoteSerial, 0x06);

        while(setBT_timer>0 && setBT_timer<500);
        if (setBT_timer>=500)
            sendCount++;
        else if(setBT_timer==0)
        {
            setBT_timer=1;
            while(setBT_timer>0 && setBT_timer<1000);
            sendCount=4;
        }
    }

    sendCount = 0;
    //  while(sendCount<2)
    {
        setBT_timer = 1;
        //AT+SCAN1
        usart3_send_data[0] = 0x41;
        usart3_send_data[1] = 0x54;
        usart3_send_data[2] = 0x2B;
        usart3_send_data[3] = 0x53;
        usart3_send_data[4] = 0x43;
        usart3_send_data[5] = 0x41;
        usart3_send_data[6] = 0x4E;
        usart3_send_data[7] = 0x31;
        USART_Send_DMA(remoteSerial, 0x08);

        while(setBT_timer>0 && setBT_timer<500);
        if (setBT_timer>=500)
            sendCount++;
        else if(setBT_timer==0)
        {
            setBT_timer=1;
            while(setBT_timer>0 && setBT_timer<5000);
            if (setBT_timer>=5000)
            {
                WeightConst_Weight_display[7] = 0xCA;
                WeightConst_Weight_display[6] = 0xA7;
                WeightConst_Weight_display[5] = 0xB0;
                WeightConst_Weight_display[4] = 0xDC;
                sendCount=4;
                WeightConst_BLE = 0;
                TMRWatchConst[Const_BLE].Data = WeightConst_BLE;
                EE_WriteVariable(TMRWatchConst_EEPROM_START_ADDRESS, TMRWatchConst[Const_BLE].VirtAddress,
                                 TMRWatchConst, &TMRWatchConst_CurWrAddress);

            }	//失败CAA7 B0DC   //失败
            else
            {
                setBT_timer = 1;
                //AT+BAND0
                usart3_send_data[0] = 0x41;
                usart3_send_data[1] = 0x54;
                usart3_send_data[2] = 0x2B;
                usart3_send_data[3] = 0x42;
                usart3_send_data[4] = 0x41;
                usart3_send_data[5] = 0x4E;
                usart3_send_data[6] = 0x44;
                usart3_send_data[7] = 0x30;
                USART_Send_DMA(remoteSerial, 0x08);

                while(setBT_timer>0 && setBT_timer<500);
                if (setBT_timer>=500)
                {
                    WeightConst_Weight_display[7] = 0xCA;
                    WeightConst_Weight_display[6] = 0xA7;
                    WeightConst_Weight_display[5] = 0xB0;
                    WeightConst_Weight_display[4] = 0xDC;
                    WeightConst_BLE = 0;
                    TMRWatchConst[Const_BLE].Data = WeightConst_BLE;
                    EE_WriteVariable(TMRWatchConst_EEPROM_START_ADDRESS, TMRWatchConst[Const_BLE].VirtAddress,
                                     TMRWatchConst, &TMRWatchConst_CurWrAddress);

                }	//失败CAA7 B0DC
                else if(setBT_timer==0)
                {
                    WeightConst_Weight_display[7] = 0xB3;
                    WeightConst_Weight_display[6] = 0xC9;
                    WeightConst_Weight_display[5] = 0xB9;
                    WeightConst_Weight_display[4] = 0xA6;
                    WeightConst_BLE = 1;
                    TMRWatchConst[Const_BLE].Data = WeightConst_BLE;
                    EE_WriteVariable(TMRWatchConst_EEPROM_START_ADDRESS, TMRWatchConst[Const_BLE].VirtAddress,
                                     TMRWatchConst, &TMRWatchConst_CurWrAddress);
                }		//成功B3C9 B9A6
            }
        }
    }

    USART3_Configuration(1);
}

void setNetAddress_byapi(u8 netid)
{   //7E 00 06 08 01 49 44 7F FE EC
    unsigned char sendCount=0,i;
    usart2_send_data[0] = 0x7E;
    usart2_send_data[1] = 0x00;
    usart2_send_data[2] = 0x06; 
    usart2_send_data[3] = 0x08;
    usart2_send_data[4] = 0x01;
    usart2_send_data[5] = 0x49;
    usart2_send_data[6] = 0x44;
    usart2_send_data[7] = 0x7F;
    if(netid)
        usart2_send_data[8] = 0xF0 + netid;
    else	usart2_send_data[8] = 0xFF;
    for (i = 3; i < 9; i++)
        sendCount = sendCount + usart2_send_data[i];
    usart2_send_data[9] = 0xFF-sendCount;
    USART_Send_DMA(xbeeSerial, 0x0A);
}
*/