智能门锁

#include  "dorlock_user_mgr.h"
#include  "dr_lock_cmd.h"


#include  "cmd_packet.h"
#include  "app_error.h"
#include  "sk_flash.h"
#include  "fds.h"
#include  "nrf_log.h"
#include  "lock_cmd_def.h"
#include  "dorlock_cmd_rsp.h"
#include  "timer_modif.h"
#include  "ble_nus.h"
#include  "user_cipher_mgr.h"




uint8_t   *TimelineUserTab[PRESCRIP_USER_SIZE] =
{
"Hgyj",
"Tvbh",
"Jxdi",
"Hvkr",
"Jxce",
"Tabg",
"Dqyh",
"Ased",
"Gyxt",
"Kcel"
};










enum  
{
TIME_SLOT_USE = 1,
   TIME_NODE_USE,
   TIME_FASTEN_USE
};












LockUartCmd_t  LockUartCmdHandle;
   


static  uint8_t   UserMgrBuf[sizeof(UserMgrFlashOpera_t)];
static  uint8_t   UserCrtBuf[12];
UserMgrFlashOpera_t   UserMgrFlashOpera;


static SystemUserMgr_t   SystemUserMgr;










void  GetSystemUserMgrAdd(SystemUserMgr_t *UserMgr)
{
*UserMgr  =  SystemUserMgr;
}




void  GetUserMgrCmdHandleAdd(LockUartCmd_t *UartCmd)
{
*UartCmd  = LockUartCmdHandle;
}




//ÓÃÓÚÉϵç¶ÁÈ¡flash²»´¿Ôھͳõʼ»¯Ò»´Î
void   InitSystemUserNoneCreat(void)
{
uint8_t   i;

   for(i = 0; i < sizeof(SystemUserMgr.UserCreatRecordTab)/sizeof(SystemUserMgr.UserCreatRecordTab[0]); i++)
   {
SystemUserMgr.UserCreatRecordTab[i] = USER_NONE_CREAT_FLAG;
}
}






//ÓÃÓÚÉϵç¶ÁÈ¡flash²»´¿Ôھͳõʼ»¯Ò»´Î
void   InitUserMgrFlashOpera(void)
{
UserMgrFlashOpera.UserCipherAddDelateFlag  = 0x0000;  //ÓÃλ±íʾ¶ÔӦʱЧÃÜÂëΪ¿Õ
   memset(UserMgrFlashOpera.UserCipherLiveTime, 0, sizeof(UserMgrFlashOpera.UserCipherLiveTime));
//    memset(UserMgrFlashOpera.UserIdCreatFlashBuf, USER_NONE_CREAT_FLAG, sizeof(UserMgrFlashOpera.UserIdCreatFlashBuf));
   for(uint8_t i = 0; i < 11; i++)
   {
UserMgrFlashOpera.UserIdCreatFlashBuf[i]  =  USER_NONE_CREAT_FLAG;
}
   memset(UserMgrFlashOpera.UserCipherNumList, 0, sizeof(UserMgrFlashOpera.UserCipherNumList));
   memset(UserMgrFlashOpera.UserCipherLenList, 0, sizeof(UserMgrFlashOpera.UserCipherLenList));
   memset(UserMgrFlashOpera.CipherUseTimeSta, 0, sizeof(UserMgrFlashOpera.CipherUseTimeSta));
//    memset(IsUserCreat, 0, sizeof(IsUserCreat));
}




/*
void  InitUserMgr(void)
{
memset(SystemUserMgr.UserCreatRecordTab, USER_NONE_CREAT_FLAG, sizeof(UserMgrFlashOpera.UserIdCreatFlashBuf));
}
*/




uint32_t  LockUserMgrFlashAccess(UserMgrFlashOpera_t *p_UserMgr, es_flash_access_t access_type)
{
flash_access_params_t params =
   {
.record_key  =  RECORD_KEY_USER_MGR,
   .file_id     =  FILE_ID_USER_MGR_FLASH,
   .p_data_buf  =  UserMgrBuf,
   .p_data      =  (uint8_t *)p_UserMgr,
   .size_bytes  =  sizeof(UserMgrFlashOpera_t),
   .access_type =  access_type
};

return access_flash_data(&params);
}




uint32_t  LockUserCreatFlashAccess(uint8_t *UserFlag, es_flash_access_t access_type)
{
flash_access_params_t params =
   {
.record_key  =  RECORD_KEY_USER_CREAT,
   .file_id     =  FILE_ID_USER_CREAT,
   .p_data_buf  =  UserCrtBuf,
   .p_data      =  (uint8_t *)UserFlag,
   .size_bytes  =  12,
   .access_type =  access_type
};

return access_flash_data(&params);
}


//Éϵç³õʼ»¯µ÷ÓÃ
void  UserMgrPowerOnInit(void)
{
uint32_t  Error;

   Error  =  LockUserMgrFlashAccess(&UserMgrFlashOpera, ES_FLASH_ACCESS_READ);

   if(Error ==  FDS_ERR_NOT_FOUND)
{
InitUserMgrFlashOpera();
   Error  =  LockUserMgrFlashAccess(&UserMgrFlashOpera, ES_FLASH_ACCESS_WRITE);
   APP_ERROR_CHECK(Error);
}
else
{
APP_ERROR_CHECK(Error);
}
/*
Error  =  LockUserCreatFlashAccess(IsUserCreat, ES_FLASH_ACCESS_READ);

if(Error ==  FDS_ERR_NOT_FOUND)
{
Error  =  LockUserCreatFlashAccess(IsUserCreat, ES_FLASH_ACCESS_WRITE);
   APP_ERROR_CHECK(Error);
}
else
{
APP_ERROR_CHECK(Error);
}
*/
}






/*
void   SaveUserCreatFlag(void)
{
uint32_t  Error;
   Error  =  LockUserCreatFlashAccess(IsUserCreat, ES_FLASH_ACCESS_WRITE);
 APP_ERROR_CHECK(Error);
}
*/




void  UserMgrFlashUpdata(void)
{
uint8_t  i;
   uint32_t  Error;

   UserMgrFlashOpera_t  UserMgrStore;

   UserMgrStore.UserCipherAddDelateFlag  = SystemUserMgr.UserCipherMgrFlag;
   UserMgrStore.TemporCipherId  =  SystemUserMgr.TemporUserMgr.CipherId;
   memcpy(UserMgrStore.UserIdCreatFlashBuf, SystemUserMgr.UserCreatRecordTab, sizeof(SystemUserMgr.UserCreatRecordTab));
   memcpy(UserMgrStore.IsUserCreat, SystemUserMgr.IsUserCreat, sizeof(SystemUserMgr.IsUserCreat));
   for(i = 0; i< sizeof(UserMgrStore.UserCipherLiveTime)/sizeof(UserMgrStore.UserCipherLiveTime[0]); i++)
   {
if(i == SystemUserMgr.TemporUserIdRecordIndex)
{
UserMgrStore.UserCipherLiveTime[i].UserCipherStartUseTime  = SystemUserMgr.TemporUserMgr.CipherValidStartTime;
   UserMgrStore.UserCipherLiveTime[i].UserCipherEndUseTime  = SystemUserMgr.TemporUserMgr.CipherValidEndTime; 
   UserMgrStore.CipherUseTimeSta[i]  = SystemUserMgr.TemporUserMgr.DorLockUseTimeSchedul;
}
else
{
UserMgrStore.UserCipherLiveTime[i].UserCipherStartUseTime  =  SystemUserMgr.NormalUserMgr[i].CipherValidStartTime;
   UserMgrStore.UserCipherLiveTime[i].UserCipherEndUseTime  =  SystemUserMgr.NormalUserMgr[i].CipherValidEndTime;
   UserMgrStore.CipherUseTimeSta[i]  =  SystemUserMgr.NormalUserMgr[i].DorLockUseTimeSchedul;
}
}
for(i = 0; i < sizeof(UserMgrFlashOpera.UserCipherLenList)/sizeof(UserMgrFlashOpera.UserCipherLenList[0]); i++)
{
if(i == SystemUserMgr.TemporUserIdRecordIndex)
{
UserMgrStore.UserCipherLenList[i]  = SystemUserMgr.TemporUserMgr.CipherLenth;
   memcpy(&UserMgrStore.UserCipherNumList[i*PASSWORD_SIZE], SystemUserMgr.TemporUserMgr.DorLockOperaCipher, PASSWORD_SIZE);
}
else if(i == SystemUserMgr.MasterIdRecordIndex)
{
UserMgrStore.UserCipherLenList[i]  =  SystemUserMgr.MasterMgr.CipherLenth;
   memcpy(&UserMgrStore.UserCipherNumList[i*PASSWORD_SIZE], SystemUserMgr.MasterMgr.DorLockOperaCipher, PASSWORD_SIZE);
}
else
{
UserMgrStore.UserCipherLenList[i]  =  SystemUserMgr.NormalUserMgr[i].CipherLenth;
   memcpy(&UserMgrStore.UserCipherNumList[i*PASSWORD_SIZE], SystemUserMgr.NormalUserMgr[i].DorLockOperaCipher, PASSWORD_SIZE);
}
}


Error  =  LockUserMgrFlashAccess(&UserMgrStore, ES_FLASH_ACCESS_WRITE);
APP_ERROR_CHECK(Error);
}








//µ÷ÓÃUserMgrPowerOnInit(void)ºóµ÷ÓÃ
void  SystemUserMgrConfig(void)
{
   uint8_t  i;
   SystemUserMgr.TemporUserIdRecordIndex  = TEMPOR_ID_SIGN_POS;
   SystemUserMgr.MasterIdRecordIndex  = MASTER_ID_SIGN_POS;
SystemUserMgr.UserCipherMgrFlag  =  UserMgrFlashOpera.UserCipherAddDelateFlag;
   memcpy(SystemUserMgr.UserCreatRecordTab, UserMgrFlashOpera.UserIdCreatFlashBuf, sizeof(SystemUserMgr.UserCreatRecordTab));
   SystemUserMgr.TemporUserMgr.CipherId  =  UserMgrFlashOpera.TemporCipherId;
   memcpy(SystemUserMgr.IsUserCreat, UserMgrFlashOpera.IsUserCreat, sizeof(SystemUserMgr.IsUserCreat));
   for(i = 0; i< sizeof(UserMgrFlashOpera.UserCipherLiveTime)/sizeof(UserMgrFlashOpera.UserCipherLiveTime[0]); i++)
   {
if(i == SystemUserMgr.TemporUserIdRecordIndex)
{
SystemUserMgr.TemporUserMgr.CipherValidStartTime  =  UserMgrFlashOpera.UserCipherLiveTime[i].UserCipherStartUseTime;
   SystemUserMgr.TemporUserMgr.CipherValidEndTime  =  UserMgrFlashOpera.UserCipherLiveTime[i].UserCipherEndUseTime;
   SystemUserMgr.TemporUserMgr.DorLockUseTimeSchedul  =  UserMgrFlashOpera.CipherUseTimeSta[i];
}
else
{
SystemUserMgr.NormalUserMgr[i].CipherValidStartTime  =  UserMgrFlashOpera.UserCipherLiveTime[i].UserCipherStartUseTime;
   SystemUserMgr.NormalUserMgr[i].CipherValidEndTime  = UserMgrFlashOpera.UserCipherLiveTime[i].UserCipherEndUseTime;
   SystemUserMgr.NormalUserMgr[i].DorLockUseTimeSchedul  =  UserMgrFlashOpera.CipherUseTimeSta[i];
}
}

for(i = 0; i < sizeof(UserMgrFlashOpera.UserCipherLenList)/sizeof(UserMgrFlashOpera.UserCipherLenList[0]); i++)
{
if(i == SystemUserMgr.TemporUserIdRecordIndex)
{
SystemUserMgr.TemporUserMgr.CipherLenth  = UserMgrFlashOpera.UserCipherLenList[i];
                  memcpy(SystemUserMgr.TemporUserMgr.DorLockOperaCipher, &UserMgrFlashOpera.UserCipherNumList[PASSWORD_SIZE*i],PASSWORD_SIZE);
}
else if(i == SystemUserMgr.MasterIdRecordIndex)
{
SystemUserMgr.MasterMgr.CipherLenth  = UserMgrFlashOpera.UserCipherLenList[i];
   memcpy(SystemUserMgr.MasterMgr.DorLockOperaCipher, &UserMgrFlashOpera.UserCipherNumList[PASSWORD_SIZE*i], PASSWORD_SIZE);
}
else
{
SystemUserMgr.NormalUserMgr[i].CipherLenth  =  UserMgrFlashOpera.UserCipherLenList[i];
   memcpy(SystemUserMgr.NormalUserMgr[i].DorLockOperaCipher, &UserMgrFlashOpera.UserCipherNumList[PASSWORD_SIZE*i], PASSWORD_SIZE);
}
}
}






void   FillAllDorLockUserId(void)
{
   uint8_t   i;
   SystemUserMgr.MasterIdRecordIndex  = MASTER_ID_SIGN_POS;
   SystemUserMgr.TemporUserIdRecordIndex  = TEMPOR_ID_SIGN_POS;
for(i = 0; i < sizeof(SystemUserMgr.UserCreatRecordTab)/sizeof(SystemUserMgr.UserCreatRecordTab[0]); i++)
{
if(i == SystemUserMgr.MasterIdRecordIndex)
{
SystemUserMgr.MasterMgr.DorLockUserId  =  SystemUserMgr.UserCreatRecordTab[i];
}
else if(i == SystemUserMgr.TemporUserIdRecordIndex)
{
SystemUserMgr.TemporUserMgr.DorLockUserId  = SystemUserMgr.UserCreatRecordTab[i];
}
else
{
SystemUserMgr.NormalUserMgr[i].DorLockUserId =  SystemUserMgr.UserCreatRecordTab[i];
}
}
}






#if  0
bool   IsThisNormalUserCreat(uint8_t  id)
{
if(SystemUserMgr.NormalUserMgr[id].DorLockUserId  < USER_NONE_CREAT_FLAG-1)
{
return  true;
}

return  false;
}






bool  IsTemporUserCreat(void)
{
if(SystemUserMgr.TemporUserMgr.DorLockUserId < USER_NONE_CREAT_FLAG-1)
{
return  true;
}

return  false;
}
#endif




#if   DOR_LOCK_RESET_USER_CREAT_ENABLE


void   AddOneNormalUserCipher(uint8_t UserIndex, RealTime_t *TimeStart, RealTime_t *TimeEnd, uint8_t *Cipher,uint8_t CipherSize)
{
   uint16_t  UserCipherMgrMask;
//    ret_code_t err_code;  

   UserCipherMgrMask  =  0x0001 << UserIndex;
if((SystemUserMgr.UserCipherMgrFlag & UserCipherMgrMask) ==  0)
{
// SystemUserMgr.UserCipherMgrFlag  |=  UserCipherMgrMask;

   SystemUserMgr.NormalUserMgr[UserIndex].CipherValidStartTime  = *TimeStart;
   SystemUserMgr.NormalUserMgr[UserIndex].CipherValidEndTime = *TimeEnd;
//    memcpy(SystemUserMgr.NormalUserMgr[UserIndex].DorLockOperaCipher, Cipher, sizeof(Cipher)/sizeof(Cipher[0]));
   memcpy(SystemUserMgr.NormalUserMgr[UserIndex].DorLockOperaCipher, Cipher, CipherSize);
   SystemUserMgr.NormalUserMgr[UserIndex].CipherLenth  = CipherSize;
   SystemUserMgr.NormalUserMgr[UserIndex].DorLockUseTimeSchedul  = BEFORE_TIME_USING;
   UserMgrFlashUpdata();
   
//    if((SystemUserMgr.UserCreatRecordTab[UserIndex] == USER_NONE_CREAT_FLAG))
//    if(SystemUserMgr.IsUserCreat[UserIndex] == 0)
//    if(Sockets.IsRtcSetting[UserIndex] == 0)
{
//                  SystemUserMgr.IsUserCreat[UserIndex]  = 1;
//    UserMgrFlashUpdata();
//    SaveUserCreatFlag();
//    Sockets.IsRtcSetting[UserIndex]  = 1;
//    err_code = sk_flash_access_sockets(&Sockets, ES_FLASH_ACCESS_WRITE);
//    APP_ERROR_CHECK(err_code);
   SetCurDorLockUartCmdExe(DOR_LOCK_USER_MGR_CMD, DOOR_LOCK_CMD_ADD_USER , ETMARS_CMD_EXE_TRIGGER, UserIndex);
   SystemUserMgr.NormalUserMgr[UserIndex].DorLockUserName  =  TimelineUserTab[UserIndex];
LockUartCmdHandle.CmdHeader  =  DOOR_LOCK_CMD_HEAD;
   LockUartCmdHandle.FunCode    =  DOOR_LOCK_CMD_ADD_USER;
   LockUartCmdHandle.CurUartExeCmd  =  DOOR_LOCK_CMD_ADD_USER;
   LockUartCmdHandle.CurCmdExeHandle  =  UserIndex;
   LockUartCmdHandle.lenth      =  sizeof(SystemUserMgr.NormalUserMgr[UserIndex].DorLockUserName) +1;
   memcpy(LockUartCmdHandle.Content, SystemUserMgr.NormalUserMgr[UserIndex].DorLockUserName, sizeof(SystemUserMgr.NormalUserMgr[UserIndex].DorLockUserName));
   CalculaLockCmdPacketLrc(&LockUartCmdHandle);
   LockCmdPacketStringToUart(&LockUartCmdHandle);
//    UartCmdRspProceStart(RSP_WAIT_SINGLE_TIME);
}
//      else
{
#if   0
LockUartCmdHandle.CurUartExeCmd  =  LOCK_CMD_ADD_CIPHER;
LockUartCmdHandle.CmdHeader  =  DOOR_LOCK_CMD_HEAD;
LockUartCmdHandle.FunCode    =  LOCK_CMD_ADD_CIPHER;
   LockUartCmdHandle.CurCmdExeHandle  =  UserIndex;
   PacketAddUserCipherCmdContent(&LockUartCmdHandle, NORMAL_USER, &SystemUserMgr);
   CalculaLockCmdPacketLrc(&LockUartCmdHandle);
   LockCmdPacketStringToUart(&LockUartCmdHandle);
#endif
}
}
}




#else    
void   AddOneNormalUserCipher(uint8_t UserIndex, RealTime_t *TimeStart, RealTime_t *TimeEnd, uint8_t *Cipher,uint8_t CipherSize)
{
   uint16_t  UserCipherMgrMask;
   ret_code_t err_code;  

   UserCipherMgrMask  =  0x0001 << UserIndex;
if((SystemUserMgr.UserCipherMgrFlag & UserCipherMgrMask) ==  0)
{
SystemUserMgr.UserCipherMgrFlag  |=  UserCipherMgrMask;

   SystemUserMgr.NormalUserMgr[UserIndex].CipherValidStartTime  = *TimeStart;
   SystemUserMgr.NormalUserMgr[UserIndex].CipherValidEndTime = *TimeEnd;
//    memcpy(SystemUserMgr.NormalUserMgr[UserIndex].DorLockOperaCipher, Cipher, sizeof(Cipher)/sizeof(Cipher[0]));
   memcpy(SystemUserMgr.NormalUserMgr[UserIndex].DorLockOperaCipher, Cipher, CipherSize);
   SystemUserMgr.NormalUserMgr[UserIndex].CipherLenth  = CipherSize;
   SystemUserMgr.NormalUserMgr[UserIndex].DorLockUseTimeSchedul  = BEFORE_TIME_USING;
   UserMgrFlashUpdata();
   
//    if((SystemUserMgr.UserCreatRecordTab[UserIndex] == USER_NONE_CREAT_FLAG))
//    if(SystemUserMgr.IsUserCreat[UserIndex] == 0)
   if(Sockets.IsRtcSetting[UserIndex] == 0)
{
//                  SystemUserMgr.IsUserCreat[UserIndex]  = 1;
//    UserMgrFlashUpdata();
//    SaveUserCreatFlag();
   Sockets.IsRtcSetting[UserIndex]  = 1;
   err_code = sk_flash_access_sockets(&Sockets, ES_FLASH_ACCESS_WRITE);
   APP_ERROR_CHECK(err_code);
   SetCurDorLockUartCmdExe(DOR_LOCK_USER_MGR_CMD, DOOR_LOCK_CMD_ADD_USER , ETMARS_CMD_EXE_TRIGGER, UserIndex);
   SystemUserMgr.NormalUserMgr[UserIndex].DorLockUserName  =  TimelineUserTab[UserIndex];
LockUartCmdHandle.CmdHeader  =  DOOR_LOCK_CMD_HEAD;
   LockUartCmdHandle.FunCode    =  DOOR_LOCK_CMD_ADD_USER;
   LockUartCmdHandle.CurUartExeCmd  =  DOOR_LOCK_CMD_ADD_USER;
   LockUartCmdHandle.CurCmdExeHandle  =  UserIndex;
   LockUartCmdHandle.lenth      =  sizeof(SystemUserMgr.NormalUserMgr[UserIndex].DorLockUserName) +1;
   memcpy(LockUartCmdHandle.Content, SystemUserMgr.NormalUserMgr[UserIndex].DorLockUserName, sizeof(SystemUserMgr.NormalUserMgr[UserIndex].DorLockUserName));
   CalculaLockCmdPacketLrc(&LockUartCmdHandle);
   LockCmdPacketStringToUart(&LockUartCmdHandle);
//    UartCmdRspProceStart(RSP_WAIT_SINGLE_TIME);
}
     else
{
#if   0
LockUartCmdHandle.CurUartExeCmd  =  LOCK_CMD_ADD_CIPHER;
LockUartCmdHandle.CmdHeader  =  DOOR_LOCK_CMD_HEAD;
LockUartCmdHandle.FunCode    =  LOCK_CMD_ADD_CIPHER;
   LockUartCmdHandle.CurCmdExeHandle  =  UserIndex;
   PacketAddUserCipherCmdContent(&LockUartCmdHandle, NORMAL_USER, &SystemUserMgr);
   CalculaLockCmdPacketLrc(&LockUartCmdHandle);
   LockCmdPacketStringToUart(&LockUartCmdHandle);
#endif
}
}
}
#endif




void   CreatTemporUserSuccess(uint8_t UserIndex)
{
uint16_t  UserCipherMgrMask;
   UserCipherMgrMask  =  0x0001 << UserIndex;

   SystemUserMgr.UserCipherMgrFlag  |=  UserCipherMgrMask;
}




#if   DOR_LOCK_RESET_USER_CREAT_ENABLE
void   CreatTemporUserCipher(RealTime_t *TimeEnd, uint8_t *Cipher, uint8_t UserIndex, uint8_t CipherSize)
{
uint16_t  UserCipherMgrMask;
//    ret_code_t err_code;
   UserCipherMgrMask  =  0x0001 << UserIndex;

   if((SystemUserMgr.UserCipherMgrFlag & UserCipherMgrMask) ==  0)
{
// SystemUserMgr.UserCipherMgrFlag  |=  UserCipherMgrMask;

   SystemUserMgr.TemporUserMgr.CipherValidEndTime = *TimeEnd;
//    memcpy(SystemUserMgr.TemporUserMgr.DorLockOperaCipher, Cipher, sizeof(Cipher)/sizeof(Cipher[0])); 
   memcpy(SystemUserMgr.TemporUserMgr.DorLockOperaCipher, Cipher, CipherSize); 
   SystemUserMgr.TemporUserMgr.CipherLenth  =  CipherSize;
   SystemUserMgr.TemporUserMgr.DorLockUseTimeSchedul  =  TIME_IN_USING;

   UserMgrFlashUpdata();
    NRF_LOG_DEBUG("start creat Tempor User Cipher.");
// NRF_LOG_INFO("USER ID----  %x ", SystemUserMgr.UserCreatRecordTab[UserIndex]);
//    if((SystemUserMgr.UserCreatRecordTab[UserIndex] == USER_NONE_CREAT_FLAG))
//    if(SystemUserMgr.IsUserCreat[UserIndex] == 0)
//    if(Sockets.IsRtcSetting[UserIndex] == 0)
{
//    IsUserCreat[UserIndex] = 1;
//    SaveUserCreatFlag();
//    SystemUserMgr.IsUserCreat[UserIndex]  = 1;
//    UserMgrFlashUpdata();
//    Sockets.IsRtcSetting[UserIndex]  = 1;
//    err_code = sk_flash_access_sockets(&Sockets, ES_FLASH_ACCESS_WRITE);
//    APP_ERROR_CHECK(err_code);
//    NRF_LOG_DEBUG("start creat user.");
   SetCurDorLockUartCmdExe(DOR_LOCK_USER_MGR_CMD, DOOR_LOCK_CMD_ADD_USER, ETMARS_CMD_EXE_TRIGGER, UserIndex);
SystemUserMgr.TemporUserMgr.DorLockUserName  =  TEMPOR_USER_NAME;
   LockUartCmdHandle.CmdHeader  =  DOOR_LOCK_CMD_HEAD;
   LockUartCmdHandle.FunCode  = DOOR_LOCK_CMD_ADD_USER;
                  LockUartCmdHandle.CurUartExeCmd  =  DOOR_LOCK_CMD_ADD_USER;
   LockUartCmdHandle.CurCmdExeHandle  =  UserIndex;
                  LockUartCmdHandle.lenth  =  sizeof(SystemUserMgr.TemporUserMgr.DorLockUserName) + 1;
                  memcpy(LockUartCmdHandle.Content, SystemUserMgr.TemporUserMgr.DorLockUserName, sizeof(SystemUserMgr.TemporUserMgr.DorLockUserName));
CalculaLockCmdPacketLrc(&LockUartCmdHandle);
   LockCmdPacketStringToUart(&LockUartCmdHandle);
//    UartCmdRspProceStart(RSP_WAIT_SINGLE_TIME);
}
// else
{
 #if  0
   SetCurDorLockUartCmdExe(DOR_LOCK_USER_MGR_CMD, LOCK_CMD_ADD_CIPHER, ETMARS_CMD_EXE_TRIGGER, UserIndex);
LockUartCmdHandle.CurUartExeCmd  =  LOCK_CMD_ADD_CIPHER;
LockUartCmdHandle.CmdHeader  =  DOOR_LOCK_CMD_HEAD;
LockUartCmdHandle.FunCode    =  LOCK_CMD_ADD_CIPHER;
   LockUartCmdHandle.CurCmdExeHandle  =  UserIndex;
   PacketAddUserCipherCmdContent(&LockUartCmdHandle, TEMPOR_USER, &SystemUserMgr);
   CalculaLockCmdPacketLrc(&LockUartCmdHandle);
   LockCmdPacketStringToUart(&LockUartCmdHandle);
 #endif
//    UartCmdRspProceStart(RSP_WAIT_SINGLE_TIME);
}
}
}


#else
void   CreatTemporUserCipher(RealTime_t *TimeEnd, uint8_t *Cipher, uint8_t UserIndex, uint8_t CipherSize)
{
uint16_t  UserCipherMgrMask;
   ret_code_t err_code;
   UserCipherMgrMask  =  0x0001 << UserIndex;

   if((SystemUserMgr.UserCipherMgrFlag & UserCipherMgrMask) ==  0)
{
SystemUserMgr.UserCipherMgrFlag  |=  UserCipherMgrMask;

   SystemUserMgr.TemporUserMgr.CipherValidEndTime = *TimeEnd;
//    memcpy(SystemUserMgr.TemporUserMgr.DorLockOperaCipher, Cipher, sizeof(Cipher)/sizeof(Cipher[0])); 
   memcpy(SystemUserMgr.TemporUserMgr.DorLockOperaCipher, Cipher, CipherSize); 
   SystemUserMgr.TemporUserMgr.CipherLenth  =  CipherSize;
   SystemUserMgr.TemporUserMgr.DorLockUseTimeSchedul  =  TIME_IN_USING;

   UserMgrFlashUpdata();
NRF_LOG_DEBUG("start creat userppppppppp.");
NRF_LOG_INFO("USER ID----  %x ", SystemUserMgr.UserCreatRecordTab[UserIndex]);
//    if((SystemUserMgr.UserCreatRecordTab[UserIndex] == USER_NONE_CREAT_FLAG))
//    if(SystemUserMgr.IsUserCreat[UserIndex] == 0)
   if(Sockets.IsRtcSetting[UserIndex] == 0)
{
//    IsUserCreat[UserIndex] = 1;
//    SaveUserCreatFlag();
//    SystemUserMgr.IsUserCreat[UserIndex]  = 1;
//    UserMgrFlashUpdata();
   Sockets.IsRtcSetting[UserIndex]  = 1;
   err_code = sk_flash_access_sockets(&Sockets, ES_FLASH_ACCESS_WRITE);
   APP_ERROR_CHECK(err_code);
   NRF_LOG_DEBUG("start creat user.");
   SetCurDorLockUartCmdExe(DOR_LOCK_USER_MGR_CMD, DOOR_LOCK_CMD_ADD_USER, ETMARS_CMD_EXE_TRIGGER, UserIndex);
SystemUserMgr.TemporUserMgr.DorLockUserName  =  TEMPOR_USER_NAME;
   LockUartCmdHandle.CmdHeader  =  DOOR_LOCK_CMD_HEAD;
   LockUartCmdHandle.FunCode  = DOOR_LOCK_CMD_ADD_USER;
                  LockUartCmdHandle.CurUartExeCmd  =  DOOR_LOCK_CMD_ADD_USER;
   LockUartCmdHandle.CurCmdExeHandle  =  UserIndex;
                  LockUartCmdHandle.lenth  =  sizeof(SystemUserMgr.TemporUserMgr.DorLockUserName) + 1;
                  memcpy(LockUartCmdHandle.Content, SystemUserMgr.TemporUserMgr.DorLockUserName, sizeof(SystemUserMgr.TemporUserMgr.DorLockUserName));
CalculaLockCmdPacketLrc(&LockUartCmdHandle);
   LockCmdPacketStringToUart(&LockUartCmdHandle);
//    UartCmdRspProceStart(RSP_WAIT_SINGLE_TIME);
}
else
{
   SetCurDorLockUartCmdExe(DOR_LOCK_USER_MGR_CMD, LOCK_CMD_ADD_CIPHER, ETMARS_CMD_EXE_TRIGGER, UserIndex);
LockUartCmdHandle.CurUartExeCmd  =  LOCK_CMD_ADD_CIPHER;
LockUartCmdHandle.CmdHeader  =  DOOR_LOCK_CMD_HEAD;
LockUartCmdHandle.FunCode    =  LOCK_CMD_ADD_CIPHER;
   LockUartCmdHandle.CurCmdExeHandle  =  UserIndex;
   PacketAddUserCipherCmdContent(&LockUartCmdHandle, TEMPOR_USER, &SystemUserMgr);
   CalculaLockCmdPacketLrc(&LockUartCmdHandle);
   LockCmdPacketStringToUart(&LockUartCmdHandle);
//    UartCmdRspProceStart(RSP_WAIT_SINGLE_TIME);
}
}
}
#endif








bool   DelateOneNormalUserCipher(uint8_t UserIndex, uint8_t CmdTrigType)
{
//      SystemUserMgr.UserCipherMgrFlag  &=  ~(0x0001 << UserIndex);

//    UserMgrFlashUpdata();
   bool  DelateOneNormalFlag;
   if(SystemUserMgr.NormalUserMgr[UserIndex].DorLockUseTimeSchedul == TIME_IN_USING)
{
 NRF_LOG_INFO("cmd del  NormalUserPass----%x", UserIndex);
SetCurDorLockUartCmdExe(DOR_LOCK_USER_MGR_CMD, DOOR_LOCK_CMD_DEL_CIPHER, CmdTrigType, UserIndex);
LockUartCmdHandle.CurUartExeCmd  =  DOOR_LOCK_CMD_DEL_CIPHER;
LockUartCmdHandle.CmdHeader  =  DOOR_LOCK_CMD_HEAD;
LockUartCmdHandle.FunCode  =  DOOR_LOCK_CMD_DEL_CIPHER;
LockUartCmdHandle.CurCmdExeHandle  =  UserIndex;
PacketDelUserCipherCmdContent(&LockUartCmdHandle, NORMAL_USER, &SystemUserMgr);
CalculaLockCmdPacketLrc(&LockUartCmdHandle);
LockCmdPacketStringToUart(&LockUartCmdHandle);
 DelateOneNormalFlag  =  false;
}
else if(SystemUserMgr.NormalUserMgr[UserIndex].DorLockUseTimeSchedul  ==  BEFORE_TIME_USING)
{
 NRF_LOG_INFO("clr mgr del  NormalUserPass----%x", UserIndex);
SystemUserMgr.UserCipherMgrFlag  &=  ~(0x0001 << UserIndex);
 UserMgrFlashUpdata();
 APP_SendData[0] = APP_ReceiveData[0];
APP_SendData[1] = APP_ReceiveData[1];
APP_SendData[2] = 0x01;
ProxReporter_SetParameter(&Tx_Rx_Nux, APP_SendData, &SocketReplyLength);
 DelateOneNormalFlag  =  true;
//  UartCmdTestStop();
}
//    UartCmdRspProceStart(RSP_WAIT_SINGLE_TIME);

return  DelateOneNormalFlag;
}








void   CancelTemporUserCipher(uint8_t UserIndex, uint8_t CmdTrigType)
{
// SystemUserMgr.UserCipherMgrFlag  &=  ~(0x0001 << UserIndex);
//    UserMgrFlashUpdata();
   
   if(SystemUserMgr.TemporUserMgr.DorLockUseTimeSchedul == TIME_IN_USING)
{
SetCurDorLockUartCmdExe(DOR_LOCK_USER_MGR_CMD, DOOR_LOCK_CMD_DEL_CIPHER, CmdTrigType, UserIndex);
LockUartCmdHandle.CurUartExeCmd  =  DOOR_LOCK_CMD_DEL_CIPHER;
LockUartCmdHandle.CmdHeader  =  DOOR_LOCK_CMD_HEAD;
LockUartCmdHandle.FunCode  =  DOOR_LOCK_CMD_DEL_CIPHER;
LockUartCmdHandle.CurCmdExeHandle  =  UserIndex;
PacketDelUserCipherCmdContent(&LockUartCmdHandle, TEMPOR_USER, &SystemUserMgr);
CalculaLockCmdPacketLrc(&LockUartCmdHandle);
LockCmdPacketStringToUart(&LockUartCmdHandle);
}
//    UartCmdRspProceStart(RSP_WAIT_SINGLE_TIME);
}








void  TimeForPermitNormalUserCipher(uint8_t UserIndex)
{
   SetCurDorLockUartCmdExe(DOR_LOCK_USER_MGR_CMD, LOCK_CMD_ADD_CIPHER, INTERNAL_TIME_ARRIVE_CMD_EXE_TRIGGER, UserIndex);
LockUartCmdHandle.CurUartExeCmd  =  LOCK_CMD_ADD_CIPHER;
LockUartCmdHandle.CmdHeader  =  DOOR_LOCK_CMD_HEAD;
LockUartCmdHandle.FunCode    =  LOCK_CMD_ADD_CIPHER;
LockUartCmdHandle.CurCmdExeHandle  =  UserIndex;
PacketAddUserCipherCmdContent(&LockUartCmdHandle, NORMAL_USER, &SystemUserMgr);
CalculaLockCmdPacketLrc(&LockUartCmdHandle);
LockCmdPacketStringToUart(&LockUartCmdHandle);
//    UartCmdRspProceStart(RSP_WAIT_SINGLE_TIME);
}






void  SetNormalUserCipherTimeSta(uint8_t UserIndex, uint8_t CipherTimeSta)
{
SystemUserMgr.NormalUserMgr[UserIndex].DorLockUseTimeSchedul  = CipherTimeSta;
}






void  SetTemporUserCipherTimeSta(uint8_t CipherTimeSta)
{
SystemUserMgr.TemporUserMgr.DorLockUseTimeSchedul  = CipherTimeSta;
}




void  LockUartUserMgrReply(uint8_t *CmdLine, uint8_t CmdSize)
{
    uint16_t  UserId;
    uint8_t   UserSelect;
    uint16_t  CmdReturnVal;
     uint8_t  CipherLenth = 0;
uint8_t   i = 8;
switch(LockUartCmdHandle.CurUartExeCmd)
{
case  DOOR_LOCK_CMD_ADD_USER:
       if(CmdLine[4] == ADD_USER_FAIL)
{
NRF_LOG_DEBUG("creat user fail.");
   LockUartCmdHandle.CurUartExeCmd  = DOOR_LOCK_CMD_IDLE;
}
else if(CmdLine[4] == ADD_USER_SUCCESS)
{
NRF_LOG_DEBUG("creat user ok.");
   
   UserId  =  (((uint16_t)CmdLine[7]) << 8) | ((uint16_t)CmdLine[8]);
   if(LockUartCmdHandle.CurCmdExeHandle  == TEMPOR_USER_CMD_HANDLE)
{
   if((CmdLine[7] < 0x20)&&(CmdLine[8] == 0))
{
SystemUserMgr.UserCreatRecordTab[10] = UserId;
}
NRF_LOG_INFO("Creat TEMPOR user id[i]   ----%x  %x  %x",LockUartCmdHandle.CurCmdExeHandle, CmdLine[7], CmdLine[8]);
   UserSelect  =  TEMPOR_USER;
}
else if(LockUartCmdHandle.CurCmdExeHandle == MASTER_CMD_HANDLE)
{
   if((CmdLine[7] < 0x20)&&(CmdLine[8] == 0))
{
SystemUserMgr.UserCreatRecordTab[11] = UserId;
}
   UserSelect  =  MASTER_USER;
}
else
{
   if((CmdLine[7] < 0x20)&&(CmdLine[8] == 0))
{
SystemUserMgr.UserCreatRecordTab[LockUartCmdHandle.CurCmdExeHandle] = UserId;
}
SystemUserMgr.UserCipherMgrFlag  |=  (0x0001 << LockUartCmdHandle.CurCmdExeHandle);
UartCmdTestStop();
APP_SendData[0] = APP_ReceiveData[0];
APP_SendData[1] = APP_ReceiveData[1];
APP_SendData[2] = 0x01;
ProxReporter_SetParameter(&Tx_Rx_Nux, APP_SendData, &SocketReplyLength);
   NRF_LOG_INFO("Creat NORMAL user id[i]   ----%x  %x  %x",LockUartCmdHandle.CurCmdExeHandle, CmdLine[7], CmdLine[8]);
   UserSelect  =  NORMAL_USER;
}

UserMgrFlashUpdata();




                              if((UserSelect == TEMPOR_USER) || (UserSelect == MASTER_USER))
{
LockUartCmdHandle.CurUartExeCmd  =  LOCK_CMD_ADD_CIPHER;
LockUartCmdHandle.CmdHeader  =  DOOR_LOCK_CMD_HEAD;
LockUartCmdHandle.FunCode  =  LOCK_CMD_ADD_CIPHER;
 PacketAddUserCipherCmdContent(&LockUartCmdHandle, UserSelect, &SystemUserMgr);
CalculaLockCmdPacketLrc(&LockUartCmdHandle);
LockCmdPacketStringToUart(&LockUartCmdHandle);
}
else if(UserSelect == NORMAL_USER)
{
LockUartCmdHandle.CurUartExeCmd  = DOOR_LOCK_CMD_IDLE;
}

}
break;

case   LOCK_CMD_ADD_CIPHER:
       if(CmdLine[4] == 0x00)
{
NRF_LOG_DEBUG("add passcode ok. -- id %x ",  LockUartCmdHandle.CurCmdExeHandle);
   if(LockUartCmdHandle.CurCmdExeHandle  == TEMPOR_USER_CMD_HANDLE)
{
SystemUserMgr.UserCipherMgrFlag  |=  (0x0001 << TEMPOR_USER_CMD_HANDLE);
   UserMgrFlashUpdata();
   UartCmdTestStop();
   APP_SendData[0] = APP_ReceiveData[0];
                         APP_SendData[1] = 0x01;
                         ProxReporter_SetParameter(&Tx_Rx_Nux, APP_SendData, &SocketReplyLength);
}
else if(LockUartCmdHandle.CurCmdExeHandle != TEMPOR_USER_CMD_HANDLE)
{
   AddCipherTestStop();
}
}
else if(CmdLine[4] == 0x02)
{
NRF_LOG_DEBUG("add passcode error user nor in.");
}
else if(CmdLine[4] == 0x01)
{
NRF_LOG_DEBUG("add passcode jiaoyan error .");
}
else if(CmdLine[4] == 0x03)
{
NRF_LOG_DEBUG("add passcode full error .");
}
else if(CmdLine[4] == 0x04)
{
NRF_LOG_DEBUG("add  passcode  have in.");
}
else if(CmdLine[4] == 0x05)
{
NRF_LOG_DEBUG("add  passcode  time  out.");
}
NRF_LOG_INFO("LOCK_CMD_ADD_CIPHER  return %x ", CmdLine[4]);
LockUartCmdHandle.CurUartExeCmd  = DOOR_LOCK_CMD_IDLE;
break;

case   DOOR_LOCK_CMD_DEL_CIPHER:
       CmdReturnVal  =  (((uint16_t)CmdLine[5]) << 8) | ((uint16_t)CmdLine[6]);
       
         if(CmdReturnVal < 0xFFFD)
{
 NRF_LOG_DEBUG("DEL  passcode  success.");
   //×îºÃÔÚÕâÀïÏòÊÖ»úApp·µ»ØÃÜÂëɾ³ý³É¹¦£¬¸ù¾Ýµ÷ÊÔ½á¹û°ì°É
   if(LockUartCmdHandle.CurCmdExeHandle != TEMPOR_USER_CMD_HANDLE)
{
 SystemUserMgr.UserCipherMgrFlag  &=  ~(0x0001 << LockUartCmdHandle.CurCmdExeHandle);
                         UserMgrFlashUpdata();
                         APP_SendData[0] = APP_ReceiveData[0];
                       APP_SendData[1] = APP_ReceiveData[1];
                       APP_SendData[2] = 0x01;
                       ProxReporter_SetParameter(&Tx_Rx_Nux, APP_SendData, &SocketReplyLength);
 UartCmdTestStop();
 DelCipherTestStop();
}
else if(LockUartCmdHandle.CurCmdExeHandle == TEMPOR_USER_CMD_HANDLE)
{
SystemUserMgr.UserCipherMgrFlag  &=  ~(0x0001 << TEMPOR_USER_CMD_HANDLE);
                         UserMgrFlashUpdata();
 APP_SendData[0] = APP_ReceiveData[0];
                       APP_SendData[1] = 0x01;
                       ProxReporter_SetParameter(&Tx_Rx_Nux, APP_SendData, &SocketReplyLength);
 UartCmdTestStop();
}
}
else
{
NRF_LOG_DEBUG("DEL  passcode  fail.");
}
LockUartCmdHandle.CurUartExeCmd  = DOOR_LOCK_CMD_IDLE;
break;

case   LOCK_CMD_MODIFY_RTC:
       if(CmdLine[4]  ==  0x00)
           {
NRF_LOG_DEBUG("Modify  time  success.");
}
           LockUartCmdHandle.CurUartExeCmd  = DOOR_LOCK_CMD_IDLE;
       break;

case   LOCK_CMD_QUERY_CIPHER:
      
       if(CmdLine[7] == 1)
{
 while(CmdLine[i] != 0)
{
CipherLenth++;
   i++;
}

if(APP_ReceiveData[0] == 0x01)
{
 NRF_LOG_INFO("lock  master0  Password----  %x   %x    %x", CmdLine[8],CmdLine[9], CmdLine[10]);
                         NRF_LOG_INFO("lock  master0  Password----  %x   %x    %x", CmdLine[11],CmdLine[12], CmdLine[13]);
                         NRF_LOG_INFO("lock  master0  Password----  %x   %x    %x", CmdLine[14],CmdLine[15], CmdLine[16]);
 NRF_LOG_INFO("lock  master0  Password----  %x   %x    %x", CmdLine[17],CmdLine[18], CmdLine[19]);
if(memcmp(&CmdLine[8], &APP_ReceiveData[2], CipherLenth) == 0)
{
   NRF_LOG_INFO("lock  master0  open success");
APP_SendData[0]  = 0x01;
   APP_SendData[1]  = 1;
   ProxReporter_SetParameter(&Tx_Rx_Nux, APP_SendData, &SocketReplyLength);
   DoorLockNormalOpen();
}
else
{
APP_SendData[0]  = 0x01;
   APP_SendData[1]  = 0;
   ProxReporter_SetParameter(&Tx_Rx_Nux, APP_SendData, &SocketReplyLength);
   LockUartCmdHandle.CurUartExeCmd  = DOOR_LOCK_CMD_IDLE;
}
}
else if(APP_ReceiveData[0] == 0x3a)
{
 APP_SendData[0] = 0x3a;
 APP_SendData[1] = CipherLenth;
memcpy(&APP_SendData[2], &CmdLine[8], CipherLenth);
 ProxReporter_SetParameter(&Tx_Rx_Nux, APP_SendData, &SocketReplyLength);
}
}

if((APP_ReceiveData[0] == 0x3a) || (CmdLine[7] != 1))
{
LockUartCmdHandle.CurUartExeCmd  = DOOR_LOCK_CMD_IDLE;
}
break;

case  LOCK_CMD_OPEN_CLOSE:
       if(CmdLine[4] == LOCK_CMD_OPEN_CLOSE)
{
if(CmdLine[5] == 0x00)
{
NRF_LOG_DEBUG("Lock  open  success.");
}
}
LockUartCmdHandle.CurUartExeCmd  = DOOR_LOCK_CMD_IDLE;
break;

case   LOCK_CMD_CIPHER_UPDATA:
       if((CmdLine[5] == 0xFF)&&(CmdLine[6] == 0xFE))
{
NRF_LOG_DEBUG("UPDATA USER CIPHER  success.");
}
LockUartCmdHandle.CurUartExeCmd  = DOOR_LOCK_CMD_IDLE;
break;
}
}








void  DoorLockNormalOpen(void)
{
LockUartCmdHandle.CmdHeader  =  DOOR_LOCK_CMD_HEAD;
   LockUartCmdHandle.CurUartExeCmd  =  LOCK_CMD_OPEN_CLOSE;
   LockUartCmdHandle.FunCode  =  LOCK_CMD_OPEN_CLOSE;
   LockUartCmdHandle.lenth    =  2;
   LockUartCmdHandle.Content[0] =  NORMAL_OPEN_LOCK;
   CalculaLockCmdPacketLrc(&LockUartCmdHandle);
   LockCmdPacketStringToUart(&LockUartCmdHandle);
}






void    SetLockUartCmdHandle(LockUartCmd_t  *LockUartCmd)
{
LockUartCmdHandle.CurUartExeCmd  =  LockUartCmd->CurUartExeCmd;
   LockUartCmdHandle.CmdHeader  =  LockUartCmd->CmdHeader;
   LockUartCmdHandle.FunCode    =  LockUartCmd->FunCode;
   LockUartCmdHandle.CurCmdExeHandle  = LockUartCmd->CurCmdExeHandle;
}






void  SetCurUartExeCmd(uint8_t  UartExeCmd)
{
LockUartCmdHandle.CurUartExeCmd  = UartExeCmd; 
}






void  FillInNewUserIdCode(uint8_t  CmdExeHandle, uint16_t  UserId)
{
SystemUserMgr.UserCreatRecordTab[CmdExeHandle] = UserId;
}




void  FillInTemporCipherIdCode(uint16_t  CipherId)
{
SystemUserMgr.TemporUserMgr.CipherId  = CipherId;
}




void   AddUserPassCodeOperation(uint8_t  UserType, uint8_t UserHandle)
{
LockUartCmdHandle.CurUartExeCmd  =  LOCK_CMD_ADD_CIPHER;
LockUartCmdHandle.CmdHeader  =  DOOR_LOCK_CMD_HEAD;
LockUartCmdHandle.FunCode  =  LOCK_CMD_ADD_CIPHER;
   LockUartCmdHandle.CurCmdExeHandle  = UserHandle;
PacketAddUserCipherCmdContent(&LockUartCmdHandle, UserType, &SystemUserMgr);
CalculaLockCmdPacketLrc(&LockUartCmdHandle);
LockCmdPacketStringToUart(&LockUartCmdHandle);
}








void   MasterCipherQuery(void)
{
   uint16_t  CipherSerial;

   CipherSerial  =  0;

   LockUartCmdHandle.CurUartExeCmd  =  LOCK_CMD_QUERY_CIPHER;
   LockUartCmdHandle.CmdHeader  =  DOOR_LOCK_CMD_HEAD;
   LockUartCmdHandle.FunCode  =  LOCK_CMD_QUERY_CIPHER;
   PacketCipherQueryCmdContent(CIPHER_USER_ID_QUERY, CipherSerial, &LockUartCmdHandle, MASTER_USER);
   CalculaLockCmdPacketLrc(&LockUartCmdHandle);
   LockCmdPacketStringToUart(&LockUartCmdHandle);
}








void  ModifyMasterPassCode(uint8_t PassCodeSize, uint8_t *PassCodeContent)
{
LockUartCmdHandle.CurUartExeCmd  = LOCK_CMD_CIPHER_UPDATA;
   LockUartCmdHandle.CmdHeader  =  DOOR_LOCK_CMD_HEAD;
   LockUartCmdHandle.FunCode  = LOCK_CMD_CIPHER_UPDATA;
   LockUartCmdHandle.lenth  = 5+PassCodeSize+1;
   LockUartCmdHandle.Content[0]  = 1;
   LockUartCmdHandle.Content[1]  = 0;
   LockUartCmdHandle.Content[2]  = 0;
   LockUartCmdHandle.Content[3]  = 1;
   memcpy(&LockUartCmdHandle.Content[4],PassCodeContent,PassCodeSize);
   LockUartCmdHandle.Content[PassCodeSize+4] = 0x00;
   CalculaLockCmdPacketLrc(&LockUartCmdHandle);
   LockCmdPacketStringToUart(&LockUartCmdHandle);
}






uint8_t GetCurUartExeCmd(void)
{
return  LockUartCmdHandle.CurUartExeCmd;

}

#include  "cmd_packet.h"
#include  "dr_lock_cmd.h"
#include  "nrf_log.h"
#include  "lock_cmd_def.h"




#define  CMD_STR_SIZE   150






void CalculaLockCmdPacketLrc(LockUartCmd_t *LockUartCmd)
{
   uint8_t  i;
LockUartCmd->Lcr = 0x0000;
   LockUartCmd->Lcr +=  LockUartCmd->lenth;
   LockUartCmd->Lcr +=  LockUartCmd->FunCode;

   for(i = 0; i < LockUartCmd->lenth-1; i++)
   {
LockUartCmd->Lcr += LockUartCmd->Content[i];
}
}








void LockCmdPacketStringToUart(LockUartCmd_t *LockUartCmd)
{
uint8_t  LockCmdStrData[CMD_STR_SIZE];
   uint8_t  i;

   LockCmdStrData[0]  =  LockUartCmd->CmdHeader;
      LockCmdStrData[1]  =  (uint8_t)((LockUartCmd->Lcr >> 8) & 0x000000FF);
      LockCmdStrData[2] =  (uint8_t)(LockUartCmd->Lcr & 0x000000FF);
   LockCmdStrData[3]  =  LockUartCmd->lenth;
   LockCmdStrData[4]  =  LockUartCmd->FunCode;

   for(i = 0; i < LockUartCmd->lenth-1; i++)
   {
LockCmdStrData[i+5] =  LockUartCmd->Content[i];
}
NRF_LOG_INFO("lock----  %x   %x    %x", LockCmdStrData[0],LockCmdStrData[1], LockCmdStrData[2]);
NRF_LOG_INFO("lock----  %x   %x    %x", LockCmdStrData[3],LockCmdStrData[4], LockCmdStrData[5]);
NRF_LOG_INFO("lock----  %x   %x    %x", LockCmdStrData[6],LockCmdStrData[7], LockCmdStrData[8]);


// UartSendBytesToDorLock(LockCmdStrData, LockUartCmd->lenth+4);
send_data_to_boad(LockCmdStrData, LockUartCmd->lenth+4);
}








void  PacketAddUserCipherCmdContent(LockUartCmd_t *LockUartCmdHandle, uint8_t UserType, SystemUserMgr_t *SystemUserMgr)
{
   uint8_t  UserHandle;
   uint8_t  PassCodeSize;
switch(UserType)
{
case  NORMAL_USER:
     UserHandle   =  LockUartCmdHandle->CurCmdExeHandle;
PassCodeSize =  SystemUserMgr->NormalUserMgr[UserHandle].CipherLenth;
     memset(LockUartCmdHandle->Content, 0, sizeof(LockUartCmdHandle->Content));
     LockUartCmdHandle->Content[0] = 0xFF;
       LockUartCmdHandle->Content[1] = 0XFF;
       LockUartCmdHandle->Content[2] = (uint8_t)(SystemUserMgr->UserCreatRecordTab[UserHandle] >> 8);
       LockUartCmdHandle->Content[3] = (uint8_t)(SystemUserMgr->UserCreatRecordTab[UserHandle]);
       NRF_LOG_INFO("use NORMAL user id[i]   ----%x  %x  %x",LockUartCmdHandle->CurCmdExeHandle, LockUartCmdHandle->Content[2], LockUartCmdHandle->Content[3]);
//        memcpy(&LockUartCmdHandle->Content[0],TimelineUserTab[UserHandle],sizeof(TimelineUserTab[UserHandle])-1);
LockUartCmdHandle->Content[9] = 0x01;
memcpy(&LockUartCmdHandle->Content[10], SystemUserMgr->NormalUserMgr[UserHandle].DorLockOperaCipher,PassCodeSize);
       LockUartCmdHandle->Content[10+PassCodeSize] = 0x00;
       LockUartCmdHandle->lenth  =  1+9+1+PassCodeSize+1;
//        LockUartCmdHandle->Content[10+PassCodeSize] = 0x00;
//        LockUartCmdHandle->lenth  =  1+9+1+6+1;
break;

case  TEMPOR_USER:
     UserHandle   =  LockUartCmdHandle->CurCmdExeHandle;
       PassCodeSize =  SystemUserMgr->TemporUserMgr.CipherLenth;
memset(LockUartCmdHandle->Content, 0, sizeof(LockUartCmdHandle->Content));
       LockUartCmdHandle->Content[0] = 0xFF;
       LockUartCmdHandle->Content[1] = 0XFF;
       LockUartCmdHandle->Content[2] = (uint8_t)(SystemUserMgr->UserCreatRecordTab[UserHandle] >> 8);
       LockUartCmdHandle->Content[3] = (uint8_t)(SystemUserMgr->UserCreatRecordTab[UserHandle]);
       NRF_LOG_INFO("use TEMPOR user id[i]   ----%x  %x  %x",LockUartCmdHandle->CurCmdExeHandle, LockUartCmdHandle->Content[2], LockUartCmdHandle->Content[3]);
       LockUartCmdHandle->Content[9] = 0x01;
memcpy(&LockUartCmdHandle->Content[10], SystemUserMgr->TemporUserMgr.DorLockOperaCipher, PassCodeSize);
       LockUartCmdHandle->Content[10+PassCodeSize] = 0x00;
LockUartCmdHandle->lenth  =  1+9+1+PassCodeSize+1;
break;

case  MASTER_USER:
break;
}
}








void  PacketDelUserCipherCmdContent(LockUartCmd_t *LockUartCmdHandle, uint8_t UserType, SystemUserMgr_t *SystemUserMgr)
{
uint8_t  UserHandle;
   uint8_t  PassCodeSize;
if(UserType  == NORMAL_USER)
{
    UserHandle   =  LockUartCmdHandle->CurCmdExeHandle;
    PassCodeSize =  SystemUserMgr->NormalUserMgr[UserHandle].CipherLenth;
    memset(LockUartCmdHandle->Content, 0, sizeof(LockUartCmdHandle->Content));
      LockUartCmdHandle->Content[0] = 0xFF;
    LockUartCmdHandle->Content[1] = 0XFF;
    LockUartCmdHandle->Content[2] = (uint8_t)(SystemUserMgr->UserCreatRecordTab[UserHandle] >> 8);
    LockUartCmdHandle->Content[3] = (uint8_t)(SystemUserMgr->UserCreatRecordTab[UserHandle]);
    
    LockUartCmdHandle->Content[9] = 0x01;
    memcpy(&LockUartCmdHandle->Content[10], SystemUserMgr->NormalUserMgr[UserHandle].DorLockOperaCipher, PassCodeSize);
    LockUartCmdHandle->Content[10+PassCodeSize] = 0x00;
    LockUartCmdHandle->lenth  =  1+9+1+PassCodeSize+1;
}
else if(UserType  == TEMPOR_USER)
{
UserHandle   =  LockUartCmdHandle->CurCmdExeHandle;
    PassCodeSize =  SystemUserMgr->TemporUserMgr.CipherLenth;
memset(LockUartCmdHandle->Content, 0, sizeof(LockUartCmdHandle->Content));
    LockUartCmdHandle->Content[0] = 0xFF;
    LockUartCmdHandle->Content[1] = 0XFF;
    LockUartCmdHandle->Content[2] = (uint8_t)(SystemUserMgr->UserCreatRecordTab[UserHandle] >> 8);
    LockUartCmdHandle->Content[3] = (uint8_t)(SystemUserMgr->UserCreatRecordTab[UserHandle]);
    LockUartCmdHandle->Content[9] = 0x01;
    memcpy(&LockUartCmdHandle->Content[10], SystemUserMgr->TemporUserMgr.DorLockOperaCipher, PassCodeSize);
    LockUartCmdHandle->Content[10+PassCodeSize] = 0x00;
LockUartCmdHandle->lenth  =  1+9+1+PassCodeSize+1;
}
}










void  PacketCipherQueryCmdContent(uint8_t  CipherQueryType, uint16_t  CipherSerial, LockUartCmd_t *LockUartCmdHandle, uint8_t UserType)
{
if(CipherQueryType  ==  CIPHER_USER_ID_QUERY)
{
LockUartCmdHandle->Content[0] =  (uint8_t)CipherSerial;
   LockUartCmdHandle->Content[1] =  (uint8_t)(CipherSerial >> 8);
   if(UserType == MASTER_USER)
{
LockUartCmdHandle->Content[2] = 0xFF;
   LockUartCmdHandle->Content[3] = 0xFF;
   LockUartCmdHandle->Content[4] = 0x00;
   LockUartCmdHandle->Content[5] = 0x00;
}

LockUartCmdHandle->lenth  =  7;
}
}








#include  "app_timer.h"
#include  "dorlock_user_mgr.h"
#include  "dr_lock_cmd.h"
#include  "nrf_log.h"
#include  "cmd_packet.h"
#include  "bd_wall_clock_timer.h"
#include  "lock_cmd_def.h"
#include  "dorlock_cmd_rsp.h"
#include  "user_cipher_mgr.h"


#define   CIPHER_TIME_USE_MGR_NUM     (PRESCRIP_USER_SIZE+1)
#define   TEMPOR_USER_PASSCODE_MGR_HANDLE    TEMPOR_ID_SIGN_POS




#define   CIPHER_MGR_SHORT_DELAY_TIME    20
#define   CIPHER_MGR_LONG_DELAY_TIME     3000


APP_TIMER_DEF(CipherMgrClk);







LockUartCmd_t   RtcExeCmd;




void  CipherMgrHandle(void * p_context);
//bool  UserPassCodeTimeMgr(uint8_t UserHandle, uint8_t UseTimePeriod, RealTime_t *Mts, RealTime_t *Mte, RealTime_t *LocalTime, uint16_t CipherExsitFlag);








void    CreatCipherMgrEvt(void)
{
uint32_t  error;

   error   =  app_timer_create(&CipherMgrClk, APP_TIMER_MODE_SINGLE_SHOT, CipherMgrHandle);
   APP_ERROR_CHECK(error);
}






void  CipherMgrTaskStart(uint16_t  TaskDelay)
{
   uint32_t  error;
error = app_timer_start(CipherMgrClk, APP_TIMER_TICKS(TaskDelay), NULL);
APP_ERROR_CHECK(error);
}






void  CipherMgrTaskStop(void)
{
uint32_t  error;
  error = app_timer_stop(CipherMgrClk);
APP_ERROR_CHECK(error);
}






#if   0
void  CipherMgrHandle(void * p_context)
{
  LockUartCmd_t  LockUartCmd;
  GetUserMgrCmdHandleAdd(&LockUartCmd);
//   (LockUartCmd.CurUartExeCmd ==  DOOR_LOCK_CMD_IDLE)&&
  if((RtcExeCmd.CurUartExeCmd == DOOR_LOCK_CMD_IDLE))
{
RtcExeCmd.CmdHeader  =  DOOR_LOCK_CMD_HEAD;
RtcExeCmd.FunCode    =  LOCK_CMD_READ_RTC;
RtcExeCmd.CurUartExeCmd  =  LOCK_CMD_READ_RTC;
RtcExeCmd.lenth   = 1;
CalculaLockCmdPacketLrc(&RtcExeCmd);
LockCmdPacketStringToUart(&RtcExeCmd);
  
}
else
{
CipherMgrTaskStart(CIPHER_MGR_SHORT_DELAY_TIME);
}
}
#endif






void  CipherMgrHandle(void * p_context)
{
static  uint8_t  UserScanIndex = 0;
   SystemUserMgr_t  UserLockUseMgr;
   uint8_t   TimeModifyFlag;
   UTCTimeStruct *time;
   uint8_t   Yearl;
   uint8_t   month;
   uint8_t   day;
   uint8_t   hour;
   uint8_t   minute;
   uint16_t  year;

   time  =  get_wall_clock_time();
   GetSystemUserMgrAdd(&UserLockUseMgr);

  

   NRF_LOG_INFO("lock time----  %d   %d    %d", time->day,time->hour, time->minutes);

   if(UserScanIndex  ==  TEMPOR_USER_PASSCODE_MGR_HANDLE)
{
if(UserLockUseMgr.UserCipherMgrFlag & (0x0001 << UserScanIndex))
{
if(UserLockUseMgr.TemporUserMgr.DorLockUseTimeSchedul == TIME_IN_USING)
{

 TimeModifyFlag   = 0x00;
 
 Yearl  =  UserLockUseMgr.TemporUserMgr.CipherValidEndTime.Yearl;
 month =  UserLockUseMgr.TemporUserMgr.CipherValidEndTime.Month;
 day   =  UserLockUseMgr.TemporUserMgr.CipherValidEndTime.Day;
 hour  =  UserLockUseMgr.TemporUserMgr.CipherValidEndTime.Hour;
 minute = UserLockUseMgr.TemporUserMgr.CipherValidEndTime.Minute;

 Yearl  =  (Yearl>>4)*10+ (Yearl&0x0f);
  year  =  2000 + Yearl;
   month =  (month>>4)*10+ (month&0x0f);
   day =  (day>>4)*10+ (day&0x0f);
   hour =  (hour>>4)*10+ (hour&0x0f);
   minute =  (minute>>4)*10+ (minute&0x0f);

   if(year  ==  time->year) 
{
TimeModifyFlag |= 0x01;
//    NRF_LOG_INFO("tempor user end time year  user[i]----  %d  %d", year, UserScanIndex);
}

if(month ==  time->month)
{
TimeModifyFlag |= 0x02;
//   NRF_LOG_INFO("tempor user end time month  user[i]----  %d  %d", month, UserScanIndex);
}

if(day ==  time->day)
{
TimeModifyFlag |= 0x04;
//    NRF_LOG_INFO("tempor user end time day  user[i]----  %d  %d", day, UserScanIndex);

}

if(hour < time->hour)
{
TimeModifyFlag |= 0x08;
//    NRF_LOG_INFO("tempor user end time hour  user[i]----  %d  %d", hour, UserScanIndex);
}
else if(hour == time->hour)
{
if(minute <= time->minutes)
{
TimeModifyFlag |= 0x08;
}
}


 //NRF_LOG_INFO("tempor user end time Hour ----  %d %d", hour, UserScanIndex);
//NRF_LOG_INFO("tempor user end time Minute ----  %d %d", minute, UserScanIndex);
if(TimeModifyFlag == 0x0F)
{
 if(!MonitorUartBusyExe())
{
 CancelTemporUserCipher(UserScanIndex, INTERNAL_TIME_ARRIVE_CMD_EXE_TRIGGER);
 #if  0
 SetTemporUserCipherTimeSta(AFTER_TIME_USING);
 #endif
 UserScanIndex = 0;
                          }  
   }
else
{
UserScanIndex = 0;
}

CipherMgrTaskStart(CIPHER_MGR_LONG_DELAY_TIME);
}
}
else
{
UserScanIndex = 0;
   CipherMgrTaskStart(CIPHER_MGR_LONG_DELAY_TIME);
}
}
else
{

for(uint8_t i = 0; i < 10; i++) {

if((UserLockUseMgr.UserCipherMgrFlag & (0x0001 << i))&&(UserLockUseMgr.NormalUserMgr[i].DorLockUseTimeSchedul  == BEFORE_TIME_USING)) {
     UserScanIndex = i;
   break;
}
}

if(UserLockUseMgr.UserCipherMgrFlag & (0x0001 << UserScanIndex))
{
#if   0
   NRF_LOG_INFO("normal user  pwd  index ----  %x", UserScanIndex);
   NRF_LOG_INFO("normal user  pwd0 ----  %x", UserLockUseMgr.NormalUserMgr[UserScanIndex].DorLockOperaCipher[0]);
   NRF_LOG_INFO("normal user  pwd1 ----  %x", UserLockUseMgr.NormalUserMgr[UserScanIndex].DorLockOperaCipher[1]);
   NRF_LOG_INFO("normal user  pwd2 ----  %x", UserLockUseMgr.NormalUserMgr[UserScanIndex].DorLockOperaCipher[2]);
   NRF_LOG_INFO("normal user  pwd3 ----  %x", UserLockUseMgr.NormalUserMgr[UserScanIndex].DorLockOperaCipher[3]);
   NRF_LOG_INFO("normal user  pwd4 ----  %x", UserLockUseMgr.NormalUserMgr[UserScanIndex].DorLockOperaCipher[4]);
   NRF_LOG_INFO("normal user  pwd5 ----  %x", UserLockUseMgr.NormalUserMgr[UserScanIndex].DorLockOperaCipher[5]);
 #endif
   TimeModifyFlag   = 0x00;
if(UserLockUseMgr.NormalUserMgr[UserScanIndex].DorLockUseTimeSchedul  == BEFORE_TIME_USING)
{
Yearl  =  UserLockUseMgr.NormalUserMgr[UserScanIndex].CipherValidStartTime.Yearl;
   month =  UserLockUseMgr.NormalUserMgr[UserScanIndex].CipherValidStartTime.Month;
   day   =  UserLockUseMgr.NormalUserMgr[UserScanIndex].CipherValidStartTime.Day;
   hour  =  UserLockUseMgr.NormalUserMgr[UserScanIndex].CipherValidStartTime.Hour;
   minute = UserLockUseMgr.NormalUserMgr[UserScanIndex].CipherValidStartTime.Minute;

   Yearl  =  (Yearl>>4)*10+ (Yearl&0x0f);
   year  =  2000 + Yearl;
   month =  (month>>4)*10+ (month&0x0f);
   day =  (day>>4)*10+ (day&0x0f);
   hour =  (hour>>4)*10+ (hour&0x0f);
   minute =  (minute>>4)*10+ (minute&0x0f);

   if(year  ==  time->year) 
{
TimeModifyFlag |= 0x01;
//  NRF_LOG_INFO("notmal user start time year  user[i]----  %d  %d", year, UserScanIndex);
}

if(month ==  time->month)
{
TimeModifyFlag |= 0x02;
//   NRF_LOG_INFO("notmal user start time month  user[i]----  %d  %d", month, UserScanIndex);
}

if(day ==  time->day)
{
TimeModifyFlag |= 0x04;
//   NRF_LOG_INFO("notmal user start time day  user[i]----  %d  %d", day, UserScanIndex);

}

if(hour < time->hour)
{
TimeModifyFlag |= 0x08;
 //  NRF_LOG_INFO("notmal user start time hour  user[i]----  %d  %d", hour, UserScanIndex);
}
else if(hour == time->hour)
{
if(minute <= time->minutes)
{
TimeModifyFlag |= 0x08;
}
}
//NRF_LOG_INFO("notmal user start time Hour ----  %d  %d", hour, UserScanIndex);
// NRF_LOG_INFO("notmal user start time Minute ----  %d %d", minute, UserScanIndex);

if(TimeModifyFlag == 0x0F)
{
 if(!MonitorUartBusyExe())
{
TimeForPermitNormalUserCipher(UserScanIndex);
SetNormalUserCipherTimeSta(UserScanIndex, TIME_IN_USING);
#if  1
 AddCipherTestStart(700);
 SetAddCipherFailHandle(UserScanIndex);
#endif
 NRF_LOG_INFO("pwd creat id  ----  %d %d",UserScanIndex);
 UserScanIndex++;
}
}
else
{
UserScanIndex++;
}
CipherMgrTaskStart(CIPHER_MGR_LONG_DELAY_TIME);
}
else if(UserLockUseMgr.NormalUserMgr[UserScanIndex].DorLockUseTimeSchedul == TIME_IN_USING)
{
Yearl  =  UserLockUseMgr.NormalUserMgr[UserScanIndex].CipherValidEndTime.Yearl;
   month =  UserLockUseMgr.NormalUserMgr[UserScanIndex].CipherValidEndTime.Month;
   day   =  UserLockUseMgr.NormalUserMgr[UserScanIndex].CipherValidEndTime.Day;
   hour  =  UserLockUseMgr.NormalUserMgr[UserScanIndex].CipherValidEndTime.Hour;
   minute = UserLockUseMgr.NormalUserMgr[UserScanIndex].CipherValidEndTime.Minute;

   Yearl  =  (Yearl>>4)*10+ (Yearl&0x0f);
   year  =  2000 + Yearl;
   month =  (month>>4)*10+ (month&0x0f);
   day =  (day>>4)*10+ (day&0x0f);
   hour =  (hour>>4)*10+ (hour&0x0f);
   minute =  (minute>>4)*10+ (minute&0x0f);

   if(year  ==  time->year) 
{
TimeModifyFlag |= 0x01;
   //NRF_LOG_INFO("notmal  user  end time year  user[i]----  %d  %d", year, UserScanIndex);
}

if(month ==  time->month)
{
TimeModifyFlag |= 0x02;
  // NRF_LOG_INFO("notmal user  end time month  user[i]----  %d  %d", month, UserScanIndex);
}

if(day ==  time->day)
{
TimeModifyFlag |= 0x04;
  // NRF_LOG_INFO("notmal user  end time day  user[i]----  %d  %d", day, UserScanIndex);

}

if(hour < time->hour)
{
TimeModifyFlag |= 0x08;
 //  NRF_LOG_INFO("notmal user  end  time hour  user[i]----  %d  %d", hour, UserScanIndex);
}
else if(hour == time->hour)
{
if(minute <= time->minutes)
{
TimeModifyFlag |= 0x08;
}
}

//NRF_LOG_INFO("notmal user  end time Hour ----  %d ", hour);
 //NRF_LOG_INFO("notmal user  end time Minute ----  %d ", minute);

if(TimeModifyFlag == 0x0F)
 {
 if(!MonitorUartBusyExe())
 {
bool  DelateFlag;

 DelateFlag  =  DelateOneNormalUserCipher(UserScanIndex, INTERNAL_TIME_ARRIVE_CMD_EXE_TRIGGER);
                        //      SetNormalUserCipherTimeSta(UserScanIndex, AFTER_TIME_USING);
                              #if  1
// AddCipherTestStart(500);
// SetAddCipherFailHandle(UserScanIndex);
if(DelateFlag  == false)
{
DelCipherTestStart(700);
SetDelCipherFailHandle(UserScanIndex);
}
#endif
                              UserScanIndex++;
}
 }
 else
 {
UserScanIndex++;
 }

CipherMgrTaskStart(CIPHER_MGR_LONG_DELAY_TIME);
}
}
else
{
UserScanIndex++;
   CipherMgrTaskStart(CIPHER_MGR_LONG_DELAY_TIME);
}
}
}








#if  0
void   LockUartRtcUserMgrTask(uint8_t *cmdLine, uint8_t data_len)
{
  static  SystemUserMgr_t  UserLockUseMgr;
  RealTime_t  PassCodeMgrTimeStart;
  RealTime_t  PassCodeMgrTimeEnd;
  RealTime_t  DorLockLocalTime;
  uint16_t  UserCipherExsitFlag;
  static  uint8_t   Year;
  static  uint8_t   month;
  static  uint8_t   day;
  static  uint8_t   hour;
  static  uint8_t   minute;
  static  uint8_t   i;
  static  uint8_t   RtcUserMgrTaskExeSta = 0;
  uint8_t  UserPassCodeUseTimePeriod;
  bool  IsCurUserAddDelOpera;
 
  if(RtcExeCmd.CurUartExeCmd  ==  LOCK_CMD_READ_RTC)
{
if(RtcUserMgrTaskExeSta == 0)
{
if(cmdLine[4]  ==  0x00)
{
RtcUserMgrTaskExeSta  = 1;
GetSystemUserMgrAdd(&UserLockUseMgr);
Year  = cmdLine[5];
month = cmdLine[6];
day   = cmdLine[7];
hour  = cmdLine[8];
minute =  cmdLine[9];
 UserCipherExsitFlag  =  UserLockUseMgr.UserCipherMgrFlag;
 DorLockLocalTime.Yearl = Year;
 DorLockLocalTime.Month = month;
 DorLockLocalTime.Day   = day;
 DorLockLocalTime.Hour  = hour;
 DorLockLocalTime.Minute  = minute;
 NRF_LOG_INFO("lock time----  %x   %x    %x", day,hour, minute);
for(i = 0; i< CIPHER_TIME_USE_MGR_NUM; i++)
{
   if(i == TEMPOR_USER_PASSCODE_MGR_HANDLE)
{
UserPassCodeUseTimePeriod  = UserLockUseMgr.TemporUserMgr.DorLockUseTimeSchedul;
   PassCodeMgrTimeStart  =  UserLockUseMgr.TemporUserMgr.CipherValidStartTime;
   PassCodeMgrTimeEnd    =  UserLockUseMgr.TemporUserMgr.CipherValidEndTime;
}
else
{
UserPassCodeUseTimePeriod  = UserLockUseMgr.NormalUserMgr[i].DorLockUseTimeSchedul;
   PassCodeMgrTimeStart  =  UserLockUseMgr.NormalUserMgr[i].CipherValidStartTime;
   PassCodeMgrTimeEnd    =  UserLockUseMgr.NormalUserMgr[i].CipherValidEndTime;
}
   
                         
IsCurUserAddDelOpera  =  UserPassCodeTimeMgr(i, UserPassCodeUseTimePeriod, &PassCodeMgrTimeStart, &PassCodeMgrTimeEnd, &DorLockLocalTime, UserCipherExsitFlag);

if(IsCurUserAddDelOpera)
{
break;
}
}

if(i  >=  CIPHER_TIME_USE_MGR_NUM)
{
   RtcUserMgrTaskExeSta  = 0;
   RtcExeCmd.CurUartExeCmd  = DOOR_LOCK_CMD_IDLE;
CipherMgrTaskStart(CIPHER_MGR_LONG_DELAY_TIME);
}
}
else
{
CipherMgrTaskStart(CIPHER_MGR_SHORT_DELAY_TIME);
}
}
          else if(RtcUserMgrTaskExeSta  == 1)
{
 UserCipherExsitFlag  =  UserLockUseMgr.UserCipherMgrFlag;
 DorLockLocalTime.Yearl = Year;
DorLockLocalTime.Month = month;
DorLockLocalTime.Day   = day;
DorLockLocalTime.Hour  = hour;
DorLockLocalTime.Minute  = minute;
 do
{
i++;
if(i >= CIPHER_TIME_USE_MGR_NUM)
{
RtcUserMgrTaskExeSta  = 0;
   RtcExeCmd.CurUartExeCmd  = DOOR_LOCK_CMD_IDLE;
CipherMgrTaskStart(CIPHER_MGR_LONG_DELAY_TIME);
break;
}

if(i == TEMPOR_USER_PASSCODE_MGR_HANDLE)
{
UserPassCodeUseTimePeriod  = UserLockUseMgr.TemporUserMgr.DorLockUseTimeSchedul;
PassCodeMgrTimeStart  =  UserLockUseMgr.TemporUserMgr.CipherValidStartTime;
PassCodeMgrTimeEnd    =  UserLockUseMgr.TemporUserMgr.CipherValidEndTime;
}
else
 {
UserPassCodeUseTimePeriod  = UserLockUseMgr.NormalUserMgr[i].DorLockUseTimeSchedul;
PassCodeMgrTimeStart  =  UserLockUseMgr.NormalUserMgr[i].CipherValidStartTime;
 PassCodeMgrTimeEnd    =  UserLockUseMgr.NormalUserMgr[i].CipherValidEndTime;
}

IsCurUserAddDelOpera  =  UserPassCodeTimeMgr(i, UserPassCodeUseTimePeriod, &PassCodeMgrTimeStart, &PassCodeMgrTimeEnd, &DorLockLocalTime, UserCipherExsitFlag);

} while(!IsCurUserAddDelOpera);
}
}
 else if(RtcExeCmd.CurUartExeCmd  ==  LOCK_CMD_MODIFY_RTC)
{
if(cmdLine[4]  ==  0x00)
{
NRF_LOG_DEBUG("Modify  time  success.");
}
RtcExeCmd.CurUartExeCmd  = DOOR_LOCK_CMD_IDLE;
}
}
#endif




#if   0
bool   UserPassCodeTimeMgr(uint8_t UserHandle, uint8_t UseTimePeriod, RealTime_t *Mts, RealTime_t *Mte, RealTime_t *LocalTime, uint16_t CipherExsitFlag)
{
 uint8_t   TimeModifyFlag;
 bool   IsCurUserAddDelOpera;

if((CipherExsitFlag) & (0x0001 << UserHandle))
{
   TimeModifyFlag   = 0x00;
if(UserHandle == TEMPOR_USER_PASSCODE_MGR_HANDLE)
{
if(UseTimePeriod == TIME_IN_USING)
{
if(Mte->Yearl == LocalTime->Yearl)
{
TimeModifyFlag  |= 0x01;
 NRF_LOG_INFO("tempor time Mte->Yearl ----  %x ", Mte->Yearl);
}

if(Mte->Month == LocalTime->Month)
{
TimeModifyFlag  |= 0x02;
 NRF_LOG_INFO("tempor time Mte->Month ----  %x ", Mte->Month);
}

if(Mte->Day == LocalTime->Day)
{
TimeModifyFlag  |= 0x04;
 NRF_LOG_INFO("tempor time Mte->Day ----  %x ", Mte->Day);
}

if(Mte->Hour < LocalTime->Hour)
{
TimeModifyFlag  |= 0x08;
}
else if(Mte->Hour == LocalTime->Hour)
{
   if(Mte->Minute <= LocalTime->Minute)
TimeModifyFlag  |= 0x08;
}
NRF_LOG_INFO("tempor time Mte->Hour ----  %x ", Mte->Hour);
NRF_LOG_INFO("tempor time Mte->Minute ----  %x ", Mte->Minute);
if(TimeModifyFlag == 0x0F)
{
CancelTemporUserCipher(UserHandle);
                            IsCurUserAddDelOpera  =  true;
//                            SetNormalUserCipherTimeSta(UserHandle, AFTER_TIME_USING);
}
else
{
IsCurUserAddDelOpera  = false;
}

NRF_LOG_DEBUG("TEMPOR  UseTimePeriod  handle.");
}
}
else
{
if(UseTimePeriod == BEFORE_TIME_USING)
{
if(Mts->Yearl == LocalTime->Yearl)

TimeModifyFlag  |= 0x01;

if(Mts->Month == LocalTime->Month)
TimeModifyFlag  |= 0x02;

if(Mts->Day == LocalTime->Day)
TimeModifyFlag  |= 0x04;

if(Mts->Hour < LocalTime->Hour)
{
TimeModifyFlag  |= 0x08;
}
else if(Mts->Hour == LocalTime->Hour)
{
   if(Mts->Minute <= LocalTime->Minute)
TimeModifyFlag  |= 0x08;
}

if(TimeModifyFlag == 0x0F)
{
TimeForPermitNormalUserCipher(UserHandle);
                            IsCurUserAddDelOpera  =  true;
                            SetNormalUserCipherTimeSta(UserHandle, TIME_IN_USING);
}
else
{
IsCurUserAddDelOpera  = false;
}
}
else if(UseTimePeriod == TIME_IN_USING)
{
if(Mte->Yearl == LocalTime->Yearl)
TimeModifyFlag  |= 0x01;

if(Mte->Month == LocalTime->Month)
TimeModifyFlag  |= 0x02;

if(Mte->Day == LocalTime->Day)
TimeModifyFlag  |= 0x04;

if(Mte->Hour < LocalTime->Hour)
{
TimeModifyFlag  |= 0x08;
}
else if(Mte->Hour == LocalTime->Hour)
{
   if(Mte->Minute <= LocalTime->Minute)
TimeModifyFlag  |= 0x08;
}

if(TimeModifyFlag == 0x0F)
{
DelateOneNormalUserCipher(UserHandle);
                            IsCurUserAddDelOpera  =  true;
                            SetNormalUserCipherTimeSta(UserHandle, AFTER_TIME_USING);
}
else
{
IsCurUserAddDelOpera  = false;
}
}
}
}
else
{
IsCurUserAddDelOpera  = false;
}
 
return  IsCurUserAddDelOpera;
}
#endif






bool   ModifyLockLocalTime(RealTime_t *LocalTime)
{
LockUartCmd_t  LockUartCmd;
  bool  IsExeModifyTimeCmd;
  GetUserMgrCmdHandleAdd(&LockUartCmd);

  if(!MonitorUartBusyExe())
{
IsExeModifyTimeCmd  =  true;
     SetCurDorLockUartCmdExe(DOR_LOCK_TIME_MGR_CMD, LOCK_CMD_MODIFY_RTC , ETMARS_CMD_EXE_TRIGGER, 0xFF);
//      UartCmdRspProceStart(RSP_WAIT_SINGLE_TIME);
     RtcExeCmd.CmdHeader  =  DOOR_LOCK_CMD_HEAD;
   RtcExeCmd.FunCode    =  LOCK_CMD_MODIFY_RTC;
   RtcExeCmd.CurUartExeCmd  =  LOCK_CMD_MODIFY_RTC;
     SetCurUartExeCmd(LOCK_CMD_MODIFY_RTC);
   RtcExeCmd.lenth   = 7;
     RtcExeCmd.Content[0] = LocalTime->Yearl;
     RtcExeCmd.Content[1] = LocalTime->Month;
     RtcExeCmd.Content[2] = LocalTime->Day;
     RtcExeCmd.Content[3] = LocalTime->Hour;
     RtcExeCmd.Content[4] = LocalTime->Minute;
     RtcExeCmd.Content[5] = LocalTime->Second;
   CalculaLockCmdPacketLrc(&RtcExeCmd);
   LockCmdPacketStringToUart(&RtcExeCmd);
//      UartCmdRspProceStart(RSP_WAIT_SINGLE_TIME);
}
else
{
 IsExeModifyTimeCmd  =  false;
}
 
return  IsExeModifyTimeCmd;
}





#include  "app_timer.h"
#include  "dorlock_user_mgr.h"
#include  "ble_nus.h"
#include  "string.h"
#include  "BleCommand.h"
#include  "rtc_cripht_mgr.h"
#include  "dorlock_user_mgr.h"
#include  "user_cipher_mgr.h"
#include  "dorlock_cmd_rsp.h"
#include  "lock_cmd_def.h"
#include  "nrf_log.h"


#define  NOR_USER_CIPHER_SERIAL        PRESCRIP_USER_SIZE
#define  TEMPOR_USER_CIPHER_HANDLE     TEMPOR_ID_SIGN_POS
#define  PASS_CODE_SIZE     6


APP_TIMER_DEF(NorUserCipherTxClk);
APP_TIMER_DEF(UartCmdTestClk);
APP_TIMER_DEF(AddCipherTestClk);
APP_TIMER_DEF(DelCipherTestClk);




void   UartCmdTestHandle(void * p_context);
void  NorUserCipherInforTx(void * p_context);
void   AddCipherTest(void * p_context);
void  DelCipherTest(void * p_context);
void  SetTemporUserPassCodeInfor(void);


bool  UartCmdTestBootFlag = false;
uint8_t  AddCipherFailUserNum;
uint8_t  DelCipherFailUserNum;


void  CreatNorUserCipherEvt(void)
{
uint32_t  error;

   error   =  app_timer_create(&NorUserCipherTxClk, APP_TIMER_MODE_SINGLE_SHOT, NorUserCipherInforTx);
   APP_ERROR_CHECK(error);
}




void  CreatAddCipherTestEvt(void)
{
uint32_t  error;

   error   =  app_timer_create(&AddCipherTestClk, APP_TIMER_MODE_SINGLE_SHOT, AddCipherTest);
   APP_ERROR_CHECK(error);
}




void  CreatDelCipherTestEvt(void)
{
uint32_t  error;

   error   =  app_timer_create(&DelCipherTestClk, APP_TIMER_MODE_SINGLE_SHOT, DelCipherTest);
   APP_ERROR_CHECK(error);
}




void  DelCipherTestStart(uint16_t  TaskDelay)
{
uint32_t  error;
error = app_timer_start(DelCipherTestClk, APP_TIMER_TICKS(TaskDelay), NULL);
APP_ERROR_CHECK(error);
}






void  DelCipherTestStop(void)
{
uint32_t  error;
   error  =  app_timer_stop(DelCipherTestClk);
   APP_ERROR_CHECK(error);
}  






void  CreatUartCmdTestEvt(void)
{
uint32_t  error;

   error   =  app_timer_create(&UartCmdTestClk, APP_TIMER_MODE_SINGLE_SHOT, UartCmdTestHandle);
   APP_ERROR_CHECK(error);
}




void  AddCipherTestStart(uint16_t  TaskDelay)
{
uint32_t  error;
error = app_timer_start(AddCipherTestClk, APP_TIMER_TICKS(TaskDelay), NULL);
APP_ERROR_CHECK(error);
}




void  AddCipherTestStop(void)
{
uint32_t  error;
   error  =  app_timer_stop(AddCipherTestClk);
   APP_ERROR_CHECK(error);
}






void  NorUserCipherTxStart(uint16_t  TaskDelay)
{
   uint32_t  error;
error = app_timer_start(NorUserCipherTxClk, APP_TIMER_TICKS(TaskDelay), NULL);
APP_ERROR_CHECK(error);
}






void  UartCmdTestStart(uint16_t  TaskDelay)
{
   uint32_t  error;
error = app_timer_start(UartCmdTestClk, APP_TIMER_TICKS(TaskDelay), NULL);
APP_ERROR_CHECK(error);
}






void  UartCmdTestStop(void)
{
uint32_t  error;
   error  =  app_timer_stop(UartCmdTestClk);
   APP_ERROR_CHECK(error);
}






void   SetAddCipherFailHandle(uint8_t UserScanIndex)
{
AddCipherFailUserNum  =  UserScanIndex;
}






void   SetDelCipherFailHandle(uint8_t UserScanIndex)
{
DelCipherFailUserNum  =  UserScanIndex;
}






void  DelCipherTest(void * p_context)
{
if(GetCurUartExeCmd() != DOOR_LOCK_CMD_IDLE)
{
 SetNormalUserCipherTimeSta(DelCipherFailUserNum, TIME_IN_USING);
}
}




void   AddCipherTest(void * p_context)
{
if(GetCurUartExeCmd() != DOOR_LOCK_CMD_IDLE)
{
SetNormalUserCipherTimeSta(AddCipherFailUserNum, BEFORE_TIME_USING);
}
}




#if   0
void   UartCmdTestHandle(void * p_context)
{
   static  uint8_t  i = 0;



{
if(GetCurUartExeCmd() == DOOR_LOCK_CMD_ADD_USER)
{
if(0x37 == APP_ReceiveData[0])
{
SetTemporUserPassCodeInfor();
UartCmdTestStart(700);
}
}
else if(GetCurUartExeCmd() == LOCK_CMD_ADD_CIPHER)
{

   if(0x37 == APP_ReceiveData[0])
{
SetTemporUserPassCodeInfor();
UartCmdTestStart(700);
}
}
else if(GetCurUartExeCmd() == DOOR_LOCK_CMD_IDLE)
{
if(0x37 == APP_ReceiveData[0])
{
CreatTemporUserSuccess(TEMPOR_USER_CIPHER_HANDLE);
   
}
}
}


}
#endif






void   UartCmdTestHandle(void * p_context)
{
if((APP_ReceiveData[0] == BLE_CMD_TIMEREDIT) && (GetCurUartExeCmd() != DOOR_LOCK_CMD_IDLE))
{
APP_SendData[0] = APP_ReceiveData[0];
   APP_SendData[1] = APP_ReceiveData[1];
     APP_SendData[2] = 0x00;
   ProxReporter_SetParameter(&Tx_Rx_Nux, APP_SendData, &SocketReplyLength);
}
else if((APP_ReceiveData[0] == 0x37) && (GetCurUartExeCmd() != DOOR_LOCK_CMD_IDLE))
{
APP_SendData[0] = APP_ReceiveData[0];
   APP_SendData[1] = 0x00;
   ProxReporter_SetParameter(&Tx_Rx_Nux, APP_SendData, &SocketReplyLength);
}
else if((BLE_CMD_TIMERDELETE  == APP_ReceiveData[0]) && (GetCurUartExeCmd()!= DOOR_LOCK_CMD_IDLE))
{
APP_SendData[0] = APP_ReceiveData[0];
   APP_SendData[1] = APP_ReceiveData[1];
   APP_SendData[2] = 0x00;
   ProxReporter_SetParameter(&Tx_Rx_Nux, APP_SendData, &SocketReplyLength);
}
else if((0x38  ==  APP_ReceiveData[0]) && (GetCurUartExeCmd()!= DOOR_LOCK_CMD_IDLE))
{
APP_SendData[0] = APP_ReceiveData[0];
   APP_SendData[1] = 0x00;
   ProxReporter_SetParameter(&Tx_Rx_Nux, APP_SendData, &SocketReplyLength);
}
}




void  NorUserCipherInforTx(void * p_context)
{
static  uint8_t  NorUserHandle = 0;
   SystemUserMgr_t  UserLockUseMgr;
   GetSystemUserMgrAdd(&UserLockUseMgr);
//    uint8_t  Cmd;
//    uint8_t  UserSerial;
   
   if(NorUserHandle < NOR_USER_CIPHER_SERIAL)
{
if((UserLockUseMgr.UserCipherMgrFlag) & (0x0001 << NorUserHandle))
{
APP_SendData[0]  = BLE_CMD_TIMERGET;
   APP_SendData[1]  = NorUserHandle;
   memcpy(&APP_SendData[2], UserLockUseMgr.NormalUserMgr[NorUserHandle].DorLockOperaCipher, UserLockUseMgr.NormalUserMgr[NorUserHandle].CipherLenth);
   APP_SendData[UserLockUseMgr.NormalUserMgr[NorUserHandle].CipherLenth+2] = UserLockUseMgr.NormalUserMgr[NorUserHandle].CipherValidStartTime.Yearh;
   APP_SendData[UserLockUseMgr.NormalUserMgr[NorUserHandle].CipherLenth+3] = UserLockUseMgr.NormalUserMgr[NorUserHandle].CipherValidStartTime.Yearl;
   APP_SendData[UserLockUseMgr.NormalUserMgr[NorUserHandle].CipherLenth+4] = UserLockUseMgr.NormalUserMgr[NorUserHandle].CipherValidStartTime.Month;
   APP_SendData[UserLockUseMgr.NormalUserMgr[NorUserHandle].CipherLenth+5] = UserLockUseMgr.NormalUserMgr[NorUserHandle].CipherValidStartTime.Day;
   APP_SendData[UserLockUseMgr.NormalUserMgr[NorUserHandle].CipherLenth+6] = UserLockUseMgr.NormalUserMgr[NorUserHandle].CipherValidStartTime.Hour;
   APP_SendData[UserLockUseMgr.NormalUserMgr[NorUserHandle].CipherLenth+7] = UserLockUseMgr.NormalUserMgr[NorUserHandle].CipherValidStartTime.Minute;
   APP_SendData[UserLockUseMgr.NormalUserMgr[NorUserHandle].CipherLenth+8] = UserLockUseMgr.NormalUserMgr[NorUserHandle].CipherValidEndTime.Yearh;
   APP_SendData[UserLockUseMgr.NormalUserMgr[NorUserHandle].CipherLenth+9] = UserLockUseMgr.NormalUserMgr[NorUserHandle].CipherValidEndTime.Yearl;
   APP_SendData[UserLockUseMgr.NormalUserMgr[NorUserHandle].CipherLenth+10] = UserLockUseMgr.NormalUserMgr[NorUserHandle].CipherValidEndTime.Month;
   APP_SendData[UserLockUseMgr.NormalUserMgr[NorUserHandle].CipherLenth+11] = UserLockUseMgr.NormalUserMgr[NorUserHandle].CipherValidEndTime.Day;
   APP_SendData[UserLockUseMgr.NormalUserMgr[NorUserHandle].CipherLenth+12] = UserLockUseMgr.NormalUserMgr[NorUserHandle].CipherValidEndTime.Hour;
   APP_SendData[UserLockUseMgr.NormalUserMgr[NorUserHandle].CipherLenth+13] = UserLockUseMgr.NormalUserMgr[NorUserHandle].CipherValidEndTime.Minute;
//  NRF_LOG_INFO("quire----  %x   %x    %x", APP_SendData[2],APP_SendData[3], APP_SendData[4]);
//  NRF_LOG_INFO("quire----  %x   %x    %x", APP_SendData[5],APP_SendData[6], APP_SendData[7]);
ProxReporter_SetParameter(&Tx_Rx_Nux, APP_SendData, &SocketReplyLength);
}
NorUserHandle++;
   
NorUserCipherTxStart(100);
}
else
{
     NorUserHandle = 0;
//    NRF_LOG_INFO("quire----end");
   APP_SendData[0]  = BLE_CMD_TIMERGET;
   APP_SendData[1]  = 0xff;
   ProxReporter_SetParameter(&Tx_Rx_Nux, APP_SendData, &SocketReplyLength);
}
}








void  GetNormalUserCipherInfor(void)
{
   NorUserCipherTxStart(100);
// NRF_LOG_INFO("quire----start");
}






void  AddNormalUserPassCodeInfor(void)
{
SystemUserMgr_t  UserLockUseMgr;
   GetSystemUserMgrAdd(&UserLockUseMgr);

   RealTime_t   TimeStart;
   RealTime_t   TimeEnd;
   uint8_t   UserPassCode[PASS_CODE_SIZE];
//    NRF_LOG_INFO("app  send  pwd  index---- %x",  APP_ReceiveData[1]);
//    NRF_LOG_INFO("app  send  pwd  data----  %x   %x    %x", APP_ReceiveData[2], APP_ReceiveData[3], APP_ReceiveData[4]);
// NRF_LOG_INFO("app  send  pwd  data----  %x   %x    %x", APP_ReceiveData[5], APP_ReceiveData[6], APP_ReceiveData[7]);
   memcpy(UserPassCode, &APP_ReceiveData[2], PASS_CODE_SIZE);
   TimeStart.Yearh = APP_ReceiveData[8];
   TimeStart.Yearl = APP_ReceiveData[9];
   TimeStart.Month = APP_ReceiveData[10];
   TimeStart.Day   = APP_ReceiveData[11];
   TimeStart.Hour  = APP_ReceiveData[12];
   TimeStart.Minute  = APP_ReceiveData[13];
   
   TimeEnd.Yearh = APP_ReceiveData[14];
   TimeEnd.Yearl = APP_ReceiveData[15];
   TimeEnd.Month = APP_ReceiveData[16];
   TimeEnd.Day   = APP_ReceiveData[17];
   TimeEnd.Hour  = APP_ReceiveData[18];
   TimeEnd.Minute  = APP_ReceiveData[19];

//    if(!MonitorUartBusyExe())
{
AddOneNormalUserCipher(APP_ReceiveData[1], &TimeStart, &TimeEnd, UserPassCode, PASS_CODE_SIZE);
 UartCmdTestStart(1000);
}
// else
{
#if  0
APP_SendData[0] = APP_ReceiveData[0];
APP_SendData[1] = APP_ReceiveData[1];
 APP_SendData[2] = 0x01;
ProxReporter_SetParameter(&Tx_Rx_Nux, APP_SendData, &SocketReplyLength);
#endif
}

}








void DelNormalUserPassCodeInfor(void)
{
//    if(!MonitorUartBusyExe())
{
//  NRF_LOG_INFO("del  NormalUserPass----%x", APP_ReceiveData[1]);
if(DelateOneNormalUserCipher(APP_ReceiveData[1], ETMARS_CMD_EXE_TRIGGER) == false)
{
UartCmdTestStart(1000);
}
}
//    else
{
#if  0  
APP_SendData[0] = APP_ReceiveData[0];
APP_SendData[1] = APP_ReceiveData[1];
APP_SendData[2] = 0x01;
ProxReporter_SetParameter(&Tx_Rx_Nux, APP_SendData, &SocketReplyLength);
#endif
}
}










void  SetTemporUserPassCodeInfor(void)
{
   RealTime_t  TimeEnd;
   uint8_t  TemporPassCode[PASS_CODE_SIZE];

   memcpy(TemporPassCode, &APP_ReceiveData[1], PASS_CODE_SIZE);
   TimeEnd.Yearh    =  APP_ReceiveData[7];
   TimeEnd.Yearl    =  APP_ReceiveData[8];
   TimeEnd.Month    =  APP_ReceiveData[9];
   TimeEnd.Day      =  APP_ReceiveData[10];
   TimeEnd.Hour     =  APP_ReceiveData[11];
   TimeEnd.Minute   =  APP_ReceiveData[12];

//    if(!MonitorUartBusyExe())
{
CreatTemporUserCipher(&TimeEnd, TemporPassCode, TEMPOR_USER_CIPHER_HANDLE, PASS_CODE_SIZE);
 UartCmdTestStart(2000);
#if   0
 if(UartCmdTestBootFlag == false)
{
   UartCmdTestBootFlag  = true;
UartCmdTestStart(700);
}
#endif
}
//    else
{
#if  0
APP_SendData[0] = APP_ReceiveData[0];
APP_SendData[1] = 0x01;
ProxReporter_SetParameter(&Tx_Rx_Nux, APP_SendData, &SocketReplyLength);
 #endif
}
}










void  CancleTemporUserPassCodeInfor(void)
{
//    if(!MonitorUartBusyExe())
{
CancelTemporUserCipher(TEMPOR_USER_CIPHER_HANDLE, ETMARS_CMD_EXE_TRIGGER);
 UartCmdTestStart(1000);
//  UartCmdTestStart(500);
}


// else
{
#if  0
APP_SendData[0] = APP_ReceiveData[0];
APP_SendData[1] = 0x01;
ProxReporter_SetParameter(&Tx_Rx_Nux, APP_SendData, &SocketReplyLength);
 #endif
}
}






void  GetTemporUserPassCodeInfor(void)
{
SystemUserMgr_t  UserLockUseMgr;
   GetSystemUserMgrAdd(&UserLockUseMgr);
   
   APP_SendData[0] = APP_ReceiveData[0];
   if((UserLockUseMgr.UserCipherMgrFlag & (0x0001 << TEMPOR_USER_CIPHER_HANDLE)))
{
memcpy(&APP_SendData[1], UserLockUseMgr.TemporUserMgr.DorLockOperaCipher, UserLockUseMgr.TemporUserMgr.CipherLenth);
APP_SendData[UserLockUseMgr.TemporUserMgr.CipherLenth+1] = UserLockUseMgr.TemporUserMgr.CipherValidEndTime.Yearh;
APP_SendData[UserLockUseMgr.TemporUserMgr.CipherLenth+2] = UserLockUseMgr.TemporUserMgr.CipherValidEndTime.Yearl;
APP_SendData[UserLockUseMgr.TemporUserMgr.CipherLenth+3] = UserLockUseMgr.TemporUserMgr.CipherValidEndTime.Month;
APP_SendData[UserLockUseMgr.TemporUserMgr.CipherLenth+4] = UserLockUseMgr.TemporUserMgr.CipherValidEndTime.Day;
APP_SendData[UserLockUseMgr.TemporUserMgr.CipherLenth+5] = UserLockUseMgr.TemporUserMgr.CipherValidEndTime.Hour;
APP_SendData[UserLockUseMgr.TemporUserMgr.CipherLenth+6] = UserLockUseMgr.TemporUserMgr.CipherValidEndTime.Minute;
}
else
{
APP_SendData[1] = 0xff;
}

   ProxReporter_SetParameter(&Tx_Rx_Nux, APP_SendData, &SocketReplyLength);
}






#include "bd_wall_clock_timer.h"






void   ModifyLockRealTimeBCD(void)
{
RealTime_t  ModifyTime;
   bool  IsExeModifyTimeCmd;
   time_union_t time;

   ModifyTime.Yearh  = APP_ReceiveData[1];
   ModifyTime.Yearl  = APP_ReceiveData[2];
   ModifyTime.Month  = APP_ReceiveData[3];
   ModifyTime.Day    = APP_ReceiveData[4];
   ModifyTime.Hour   = APP_ReceiveData[5];
   ModifyTime.Minute = APP_ReceiveData[6];
   ModifyTime.Second = APP_ReceiveData[7];

   time.time.year = (APP_ReceiveData[2]>>4)*10+ (APP_ReceiveData[2]&0x0f);
 
   time.time.month = (APP_ReceiveData[3]>>4)*10+ (APP_ReceiveData[3]&0x0f);
   time.time.day = (APP_ReceiveData[4]>>4)*10+ (APP_ReceiveData[4]&0x0f);
   time.time.hours = (APP_ReceiveData[5]>>4)*10+ (APP_ReceiveData[5]&0x0f);
   time.time.minute = (APP_ReceiveData[6]>>4)*10+ (APP_ReceiveData[6]&0x0f);
   time.time.seconds = (APP_ReceiveData[7]>>4)*10+ (APP_ReceiveData[7]&0x0f);


      set_system_clock(time);
   CipherMgrTaskStart(1000);
// UartCmdTestStart(500);

   IsExeModifyTimeCmd  = ModifyLockLocalTime(&ModifyTime);

// if(IsExeModifyTimeCmd == false)
{
APP_SendData[0] = APP_ReceiveData[0];
         APP_SendData[1] = 0x01;
         ProxReporter_SetParameter(&Tx_Rx_Nux, APP_SendData, &SocketReplyLength);
}


/*
   if(IsExeModifyTimeCmd)
{
APP_SendData[0] = APP_ReceiveData[0];
APP_SendData[1] = 0x01;
ProxReporter_SetParameter(&Tx_Rx_Nux, APP_SendData, &SocketReplyLength);
//    CipherMgrTaskStart(1000);
}
else
{
 APP_SendData[0] = APP_ReceiveData[0];
         APP_SendData[1] = 0x00;
         ProxReporter_SetParameter(&Tx_Rx_Nux, APP_SendData, &SocketReplyLength);
}
*/
}


typedef struct 
{
uint16_t year;
uint8_t  mon;
uint8_t  day;
uint8_t  hour;
uint8_t  min;
uint8_t  sec;
}Rtctime;


void   ModifyLockRealTime(void)
{
RealTime_t  ModifyTime;
   bool  IsExeModifyTimeCmd;
   time_union_t time;
static Rtctime rtctime;

   rtctime.year = APP_ReceiveData[8]<<0x08|APP_ReceiveData[9];
   rtctime.mon = APP_ReceiveData[2];
   rtctime.day = APP_ReceiveData[3]; 
   rtctime.hour = APP_ReceiveData[5];
   rtctime.min = APP_ReceiveData[6];
   rtctime.sec = APP_ReceiveData[7];

   ModifyTime.Yearh  = (rtctime.year/1000)<<4|(rtctime.year%1000/100);
   ModifyTime.Yearl  = ((rtctime.year%100)/10)<<4|rtctime.year%10;
   ModifyTime.Month  = (rtctime.mon/10)<<4|rtctime.mon%10;
   ModifyTime.Day    = (rtctime.day/10)<<4|rtctime.day%10;
   ModifyTime.Hour   = (rtctime.hour/10)<<4|rtctime.hour%10;
   ModifyTime.Minute = (rtctime.min/10)<<4|rtctime.min%10;
   ModifyTime.Second = (rtctime.sec/10)<<4|rtctime.sec%10;

   time.time.year = rtctime.year - 2000;
 
   time.time.month = rtctime.mon;
   time.time.day = rtctime.day;
   time.time.hours = rtctime.hour;
   time.time.minute = rtctime.min;
   time.time.seconds = rtctime.sec;


      set_system_clock(time);
   CipherMgrTaskStart(1000);


   IsExeModifyTimeCmd  = ModifyLockLocalTime(&ModifyTime);

// if(IsExeModifyTimeCmd == false)
{
APP_SendData[0] = APP_ReceiveData[0];
         APP_SendData[1] = 0x01;
         ProxReporter_SetParameter(&Tx_Rx_Nux, APP_SendData, &SocketReplyLength);
}


/*
   if(IsExeModifyTimeCmd)
{
APP_SendData[0] = APP_ReceiveData[0];
APP_SendData[1] = 0x01;
ProxReporter_SetParameter(&Tx_Rx_Nux, APP_SendData, &SocketReplyLength);
//    CipherMgrTaskStart(1000);
}
else
{
 APP_SendData[0] = APP_ReceiveData[0];
         APP_SendData[1] = 0x00;
         ProxReporter_SetParameter(&Tx_Rx_Nux, APP_SendData, &SocketReplyLength);
}
*/
}








void  DoorLockOpen(void)
{
// DoorLockNormalOpen();
  MasterCipherQuery();
}








void  GetMasterPassCode(void)
{
MasterCipherQuery();
}






void UpdataMasterPassCode(void)
{
ModifyMasterPassCode(APP_ReceiveData[1], &APP_ReceiveData[2]);

   APP_SendData[0] = APP_ReceiveData[0];
   APP_SendData[1] = 1;
   ProxReporter_SetParameter(&Tx_Rx_Nux, APP_SendData, &SocketReplyLength);
}

#include <stdint.h>
#include <string.h>
#include "nordic