/**
 * @copyright 2015 Indie Semiconductor.
 *
 * This file is proprietary to Indie Semiconductor.
 * All rights reserved. Reproduction or distribution, in whole
 * or in part, is forbidden except by express written permission
 * of Indie Semiconductor.
 *
 * @file pdsTask.c
 * @Author: Jack.Pan
 * @E-mail:jack.pan@indiemicro.com
 * @Date: 2020/09/10
 */
#include <applicationTask.h>
#include <pdsTask.h>
#include <crc32.h>
#include <meta.h>
#include <motorControlTask.h>
#include <flash_device.h>
#include <flash_sfrs.h>
#include <linsNodeCfgIdentify.h>
#include <linStackTask.h>
#include <linSlaveTask.h>
#include <crc_sfr.h>

uint8_t pds_store(uint8_t index);

static SystemParams_t systemParam;
static Userdata_t userdata;
static TaskState_t pdsState = TASK_STATE_INIT;
static PdsStatus_t pdsStatus = PDS_STATUS_USING_NORMAL;

#define PDS_ACTIVE_DATA_INDEX           (0U)
#define PDS_ACTIVE_DATA_BACKUP_INDEX    (1U)

void PDS_PowerONRead_MotorParamfromFlash(uint16_t *buff,uint16_t leng)
{
  for (uint16_t i = 0U; i < leng; i++){
    *buff = systemParam.info.motorParams.data16[i];
     buff++;
  }
}

void PDS_Init(void)
{
    uint32_t crcValue;
    uint32_t crcValueuserdata;
    CRC32_Init(); 
    
    Userdata_t *Motorstep= (Userdata_t *)FLASH_START_ADDRESS_USER_DATA;    
    crcValueuserdata = CRC32_GetRunTimeCRC32((uint8_t *)&Motorstep->info ,(uint16_t)sizeof(Motorstep->info));
    
    if(crcValueuserdata == Motorstep->head.crc32){
      userdata = *Motorstep;
    }else{
      userdata.info.data[0] = 0;
      userdata.info.data[1] = 0;
    }  
    
    CRC32_Init();
    SystemParams_t *param = (SystemParams_t *)FLASH_START_ADDRESS_SYSTEM_DATA;
    crcValue = CRC32_GetRunTimeCRC32((uint8_t *)&param->info ,(uint16_t)sizeof(param->info));
    if (crcValue == param->head.crc32){
        systemParam = *param;
        pdsStatus = PDS_STATUS_USING_NORMAL;
    }else{
        param = (SystemParams_t *)FLASH_START_ADDRESS_SYSTEM_DATA_BACK_UP;
        crcValue = CRC32_GetRunTimeCRC32((uint8_t *)&param->info ,(uint16_t)sizeof(param->info));
        if (crcValue == param->head.crc32){
            systemParam = *param;
            pdsStatus = PDS_STATUS_USING_BACKUP;
        }else{
            pdsStatus = PDS_STATUS_USING_DEFAULT;
        }
    }
    pdsStatus = PDS_STATUS_USING_DEFAULT;
    if (pdsStatus == PDS_STATUS_USING_DEFAULT){
/*  **********************fix LIN configuration default value ************************************/
        systemParam.head.index = 0U;
        systemParam.info.linParams.nad          = INIT_LINS_NAD_ADDR;
        systemParam.info.linParams.supplierID   = LINS_SUPPLIER_ID;
        systemParam.info.linParams.functionID   = LINS_FUNCTION_ID;
        systemParam.info.linParams.variant      = LINS_VARIANT;
        systemParam.info.linParams.serialNo     = LINS_SERIAL_NO;
        systemParam.info.linParams.fwVersion    = LINS_FW_VERSION;
        systemParam.info.linParams.hwVersion    = LINS_HW_VERSION;
        
        systemParam.info.motorParams.Constantspeed            = DEFAULT_CONSTANTSPEED;
        systemParam.info.motorParams.startspeed               = DEFAULT_STARTSPEED;
        systemParam.info.motorParams.Slowspeed                = DEFAULT_SLOWSPEED;
        systemParam.info.motorParams.MotorlockAcoilvoltage    = DEFAULT_ACOILVOLTAGE;
        systemParam.info.motorParams.MotorlockBcoilvoltage    = DEFAULT_BCOILVOLTAGE;
        systemParam.info.motorParams.ClimbTime                = DEFAULT_CLIMBTIME;
        systemParam.info.motorParams.SlowTime                 = DEFAULT_SLOWTIME; 
        
//        GetMotorPhyParam[0] = systemParam.info.motorParams.Constantspeed;//Constantspeed us/step 
//        GetMotorPhyParam[1] = systemParam.info.motorParams.startspeed;//Motorlock startspeed us/step 
//        GetMotorPhyParam[2] = systemParam.info.motorParams.Slowspeed;//Motorlock Slowspeed us/step 
//        GetMotorPhyParam[3] = systemParam.info.motorParams.MotorlockAcoilvoltage;//Motorlock Acoil voltage
//        GetMotorPhyParam[4] = systemParam.info.motorParams.MotorlockBcoilvoltage;//Motorlock Bcoil voltage
//        GetMotorPhyParam[5] = systemParam.info.motorParams.ClimbTime + (uint16_t)systemParam.info.motorParams.SlowTime << 8;//ClimbTime: ms low8bit, SlowTime: ms high8bit 
       
   
        LIN_Device_Frame_t volatile *frame = LINS_GetUcndFramesTable(&systemParam.info.linParams.frameIDSize);
        for (uint8_t i = 0; i < systemParam.info.linParams.frameIDSize; i++){
            systemParam.info.linParams.frameInfo[i].frameId      = frame[i].frame_id;
            systemParam.info.linParams.frameInfo[i].frameIsValid = TRUE;
        }
    }    
    ls_set_initialNad(INIT_LINS_NAD_ADDR);
    ls_set_nad(INIT_LINS_NAD_ADDR);
    /* must be call here for init LIN param */
    LNCI_Init();
}


uint8_t pds_store(uint8_t index)
{
/****************************************************************************************************************/
  static uint16_t motorbuffdata[TransferCNT];
/*Take out new parameters for the motor through the 3C command*/  
    LINS_Transfer3CdataToPDS(motorbuffdata,TransferCNT);
    for(uint8_t n=0;n<TransferCNT;n++){
      systemParam.info.motorParams.data16[n] = motorbuffdata[n];
    }
    
    uint16_t wordLength;
    uint32_t *pWord = (uint32_t *)((void *)&systemParam);
    uint32_t crcValue = CRC32_GetRunTimeCRC32((uint8_t *)(&systemParam.info) ,(uint16_t)sizeof(systemParam.info));
    systemParam.head.crc32 = crcValue;
    systemParam.head.index ++;
    
    /*  sizeof(SystemParams_t) is the timers of word     */
    wordLength = ((uint16_t)sizeof(SystemParams_t) >> 2U);

    pdsStatus = PDS_STATUS_USING_NORMAL;
    
    if (index == PDS_ACTIVE_DATA_INDEX){
        /*write sys data normal*/
        f_FLASH_EraseSector(FLASH_START_ADDRESS_SYSTEM_DATA);
        for (uint32_t i = 0; i < wordLength; i+=2){
            f_FLASH_Write2WordsWithECC(FLASH_START_ADDRESS_SYSTEM_DATA +i*4U, pWord[i],pWord[i+1]);
        }
    }else{
        /*write sys data back up*/
        f_FLASH_EraseSector(FLASH_START_ADDRESS_SYSTEM_DATA_BACK_UP);
        for (uint32_t i = 0; i < wordLength; i++){
            f_FLASH_Write2WordsWithECC(FLASH_START_ADDRESS_SYSTEM_DATA_BACK_UP +i*4U, pWord[i],pWord[i+1]);
        }
    }
    return 0U;
}

void userdatapds_store(void)//进休眠时保存一次
{
/****************************************************************************************************************/
  
    userdata.info.data[0] = Motor_GetCurrentPosition();
    userdata.info.data[1] = Motor_GetCurrentPosition() >> 16U;
   
    uint16_t wordLength;
    uint32_t *pWord = (uint32_t *)((void *)&userdata);
    uint32_t crcValue = CRC32_GetRunTimeCRC32((uint8_t *)(&userdata.info) ,(uint16_t)sizeof(userdata.info));
    userdata.head.crc32 = crcValue;
    userdata.head.index ++;
    
    Flash_EraseSector(FLASH_START_ADDRESS_USER_DATA);
  
    /*  sizeof(Userdata_t) is the timers of word     */
    wordLength = ((uint32_t)sizeof(Userdata_t) >> 2U);

     /*write sys data normal*/
    for (uint32_t i = 0; i < wordLength; i++){
     FLASH_Write2WordsWithECC(FLASH_START_ADDRESS_USER_DATA+i*8U,pWord[i*2],pWord[i*2+1]);
  }
  
//    CRC32_Init(); 
    
//    Userdata_t *Motorstep= (Userdata_t *)FLASH_START_ADDRESS_USER_DATA;    
//    uint32_t crcValueuserdata = CRC32_GetRunTimeCRC32((uint8_t *)&Motorstep->info ,(uint16_t)sizeof(Motorstep->info));
    
//    if(crcValueuserdata == Motorstep->head.crc32){
//      userdata = *Motorstep;
//    }else{
//      userdata.info.data[0] = 0;
//      userdata.info.data[1] = 0;
//    }    
}

MotorClusterParams_t *PDS_GetMotorParam(void)
{
    return &systemParam.info.motorParams;
}

LINClusterParams_t *PDS_GetLINParam(void)
{
    return &systemParam.info.linParams;
}

PdsStatus_t PDS_GetPdsStatus(void)
{
    return pdsStatus;
}

uint32_t PDS_GetMotorstepnfromflash(void)
{
  uint32_t motorstepn = 0;
  motorstepn = userdata.info.data[1];
  motorstepn <<= 16U;
  motorstepn += userdata.info.data[0];
  
  return motorstepn;
}

void PDS_TaskHandler(void)
{
    switch(pdsState){
    case TASK_STATE_INIT:
      pdsState = TASK_STATE_ACTIVE;
      break;
    case TASK_STATE_ACTIVE:
      /* storage system parameters */
      (void)pds_store(PDS_ACTIVE_DATA_INDEX);
      pdsState = TASK_STATE_PROCESSING;
      //TM_PostTask(TASK_ID_PDS);
      break;
    case TASK_STATE_PROCESSING:
      /* storage system parameters backup*/
      (void)pds_store(PDS_ACTIVE_DATA_BACKUP_INDEX);
      /* set save parameters flag for lin stack*/
      (void)ls_save_configuration();
      pdsState = TASK_STATE_ACTIVE;
      break;
    default:
      break;
    }
}