motor_ctl-1/3.BasicFunction/Source/flash_master.c

/************************************************************************
 Project:               Welling Motor Control Paltform
 Filename:              flash_master.c
 Partner Filename:      flash_master.h
 Description:           flash master driver
 Complier:              IAR Embedded Workbench for ARM 8.40.2
 CPU TYPE :           STM32F30x
*************************************************************************
 Copyright (c) 20 Welling Motor Technology(Shanghai) Co. Ltd.
 All rights reserved.
*************************************************************************
*************************************************************************
 Revising History (ECL of this file):
 M0_20220410, by Ling Baizhou, create this file;
************************************************************************/
/************************************************************************
 Beginning of File, do not put anything above here except notes
 Compiler Directives:
*************************************************************************/

#ifndef _FLASH_MASTER_C
#define _FLASH_MASTER_C_
#endif

/************************************************************************
 Included File
*************************************************************************/
//#include "syspar.h"
#include "flash_master.h"
//#include "at32f421.h"//#include "stm32f10x.h"
#include "queue.h"
#include "string.h"
#include "user.h"
#include "i2c_master.h"
#include "MosResCalib.h"
#include "ti_msp_dl_config.h"



#define FLASH_END                          ((uint32_t)0x00005fff)
#define FLASH_PAGE_SIZE                    (0x400u)        //1k扇区单位
#define MAIN_SECTOR_SIZE ((uint32_t) 1024)

//FLASH_PARA_TYPE flash_stPara;
History_PARAMETER  stHistoryPara;
UWORD           dataIndex;
//从指定地址开始写入多个数据
  UBYTE pageNum_test=0; 
  volatile DL_FLASHCTL_COMMAND_STATUS gCmdStatus;
  uint32_t gDataArray64[] = {0, 0};
  uint32_t  countToWrite_MinSize=0;
  uint32_t  countToWrite_remaiSize=0;
  UWORD  uwFlash_IRQ_Enble=0;
  void flash_voMosResParaInit(void);
  void flash_voProductParaInit(void);

//  typedef struct
//  {
//      UWORD     stMotorPara;
//      UWORD     stBikePara;
//      UWORD     stMControlPara;
//      UWORD     stSensorPara;
//      UWORD     stAssistPara;
//      UWORD     flash_stPara;
//      UWORD     EepromMosPara;
//      UWORD     uwCRC;
//      UWORD     uwCRC1;
//  } STRUCT_FLASHCHECK;

  inline void BSL_CI_disableCache(void)
  {
      DL_CORE_configInstruction(CPUSS_CTL_ICACHE_DISABLE,
          CPUSS_CTL_PREFETCH_DISABLE, CPUSS_CTL_LITEN_DISABLE);
  }

  inline void BSL_CI_enableCache(void)
  {
      DL_CORE_configInstruction(CPUSS_CTL_ICACHE_ENABLE,
          CPUSS_CTL_PREFETCH_ENABLE, CPUSS_CTL_LITEN_ENABLE);
  }
  //addr_end =1024整数倍-1
  uint8_t CMD_USER_API_Flash_Range_Erase(uint32_t addrStart,uint32_t addr_end)
  {
      uint8_t ret                       = 0;
      uint8_t erase_status              = (uint8_t) 1;
      uint32_t main_flash_start_address = addrStart;
      uint32_t main_flash_end_address =addr_end;;

      uint32_t data_pointer;
      data_pointer           = addrStart;

      /* Check if BSL is unlocked */

          /* If the address range is valid, then erase the memory range */
          if ((addrStart >= main_flash_start_address) &&
              (addr_end <= main_flash_end_address) && (addrStart <= addr_end))
          {
             // BSL_CI_disableCache();
              while (data_pointer <= addr_end) {
                  DL_FlashCTL_unprotectSector(
                      FLASHCTL, data_pointer, DL_FLASHCTL_REGION_SELECT_MAIN);
                  DL_FlashCTL_eraseMemoryFromRAM(
                      FLASHCTL, data_pointer, DL_FLASHCTL_COMMAND_SIZE_SECTOR);

                  erase_status = erase_status &
                                 (uint8_t) DL_FlashCTL_waitForCmdDone(FLASHCTL);
                  data_pointer = data_pointer + MAIN_SECTOR_SIZE;
              }

//              DL_FlashCTL_unprotectSector(
//                  FLASHCTL, addr_end, DL_FLASHCTL_REGION_SELECT_MAIN);
//              DL_FlashCTL_eraseMemoryFromRAM(
//                  FLASHCTL, addr_end, DL_FLASHCTL_COMMAND_SIZE_SECTOR);

//              erase_status =
//                  erase_status & (uint8_t) DL_FlashCTL_waitForCmdDone(FLASHCTL);

             // BSL_CI_enableCache();

              /* Check if all flash sector erase got passed */
              if (erase_status == (uint8_t) 0)
              {
                  ret = 2;
              }
          }
          else {
              ret = 3;
          }

      return ret;
  }





  //STRUCT_FLASHCHECK Flash_test={0x1234,0x5678,0x9012,0x2345,0x6789,0x1234,0x5678,0x9876,0x4321};
 // STRUCT_FLASHCHECK Flash_testread={0};
  ULONG  endtAddress;
void FLASH_voWriteMoreData(ULONG startAddress, UWORD *writeData, UWORD countToWrite, UBYTE Era_enble)
{
    uint8_t gErrorType      = (uint8_t) 1;
    UBYTE pageNum = (countToWrite-1)/(FLASH_PAGE_SIZE/2)+1;

    endtAddress=startAddress + countToWrite * 2-1;

    pageNum_test=pageNum;
    if (startAddress > FLASH_END
        || ((startAddress + countToWrite * 2-1) > (FLASH_END))
        || (countToWrite < 1)
        /*||(pageNum>1)*/)
    {
        return; //非法地址
    }
    /* Disable all interrupts */
   // DISABLE_IRQ; /* MCU Core and GPIO configuration */
    if(Era_enble!=0)
    {
        CMD_USER_API_Flash_Range_Erase(startAddress,startAddress+FLASH_PAGE_SIZE-1);

    }
    countToWrite_MinSize  =  countToWrite/4;
    countToWrite_remaiSize=  countToWrite%4;
    for (dataIndex = 0; dataIndex < countToWrite_MinSize; dataIndex++)
    {
        gDataArray64[0]=(uint32_t)(writeData[dataIndex*4+1] <<16) +writeData[dataIndex*4];
        gDataArray64[1]=(uint32_t)(writeData[dataIndex*4+3] <<16) +writeData[dataIndex*4+2];
        DL_FlashCTL_unprotectSector(
                      FLASHCTL, startAddress, DL_FLASHCTL_REGION_SELECT_MAIN);
          gCmdStatus = DL_FlashCTL_programMemoryFromRAM64WithECCGenerated(
                      FLASHCTL, (startAddress + dataIndex * 8 ), &gDataArray64[0]);
//                  if (gCmdStatus != DL_FLASHCTL_COMMAND_STATUS_PASSED) {
//                      /* If command did not pass, set error flag. */
//                      gErrorType = 15;
//                  }
//      flash_halfword_program(startAddress + dataIndex * 2, writeData[dataIndex]);
    }
    if(countToWrite_remaiSize !=0)
    {
        if(countToWrite_remaiSize==1)
        {
            writeData[dataIndex*4+1]=0xffff;
            writeData[dataIndex*4+2]=0xffff;
            writeData[dataIndex*4+3]=0xffff;
        }
        else if(countToWrite_remaiSize==2)
        {

           writeData[dataIndex*4+2]=0xffff;
           writeData[dataIndex*4+3]=0xffff;
        }
        else if(countToWrite_remaiSize==3)
        {
            writeData[dataIndex*4+3]=0xffff;
        }
        gDataArray64[0]=(uint32_t)(writeData[dataIndex*4+1] <<16) +writeData[dataIndex*4];
        gDataArray64[1]=(uint32_t)(writeData[dataIndex*4+3] <<16) +writeData[dataIndex*4+2];

             DL_FlashCTL_unprotectSector(
                           FLASHCTL, startAddress, DL_FLASHCTL_REGION_SELECT_MAIN);
               gCmdStatus = DL_FlashCTL_programMemoryFromRAM64WithECCGenerated(
                           FLASHCTL, (startAddress + dataIndex * 8 ), &gDataArray64[0]);
//                       if (gCmdStatus != DL_FLASHCTL_COMMAND_STATUS_PASSED) {
//                           /* If command did not pass, set error flag. */
//                           gErrorType = 22;
//                       }
    }


//   flash_lock();//    上锁写保护
    
    /* Enable all interrupts */
//    if(uwFlash_IRQ_Enble!=0)
//    {
//        ENABLE_IRQ;
//    }
}

//读取指定地址的半字(16位数据)
UWORD FLASH_ReadWord(ULONG address)
{
   return *(__IO UWORD *)address;
}

//从指定地址开始读取多个数据
void FLASH_voReadMoreData(ULONG startAddress, UWORD *readData, UWORD countToRead)
{
    UWORD dataIndex;
     for (dataIndex = 0; dataIndex < countToRead; dataIndex++)
    {
         readData[dataIndex] = FLASH_ReadWord(startAddress + dataIndex * 2);
     }

}



/***************************************************************
 Function: flash_HistoryWrite
 Description: write ERROR_LOG  to flash
 Call by:  ;
 Input Variables: N/A
 Output/Return Variables: N/A
 Subroutine Call: N/A;
 Reference: N/A
****************************************************************/

void flash_HistoryWrite(void)
{

      UWORD countHistory_len = sizeof(History_PARAMETER) / 2; ;

      stHistoryPara.uwCRC = uart_uwCRCCcitt((UBYTE*)(&stHistoryPara), (countHistory_len-1)*2);
      FLASH_voWriteMoreData(StartServerManageHistory_Address, (UWORD *)(&stHistoryPara), countHistory_len,1);



}

/***************************************************************
 Function: flash_voErrorRead
 Description: read ERROR_LOG  to flash
 Call by:  ;
 Input Variables: N/A
 Output/Return Variables: N/A
 Subroutine Call: N/A;
 Reference: N/A
****************************************************************/

void flash_HistoryRead(void)
{

    UWORD countHistory_len = (sizeof(History_PARAMETER)) / 2;

  FLASH_voReadMoreData(StartServerManageHistory_Address, (UWORD *)(&stHistoryPara), countHistory_len);
     UWORD uwCRC = uart_uwCRCCcitt((UBYTE*)(&stHistoryPara), (countHistory_len-1)*2);
     if(stHistoryPara.uwCRC != uwCRC)
       {
           CodeHistoryParaDelete();
           mn_voEEHistoryParaUpdate();
           flash_HistoryWrite();//
       }

}

/***************************************************************
 Function: flash_voErrorWrite
 Description: write ERROR_LOG  to flash
 Call by:  ;
 Input Variables: N/A
 Output/Return Variables: N/A
 Subroutine Call: N/A;
 Reference: N/A
****************************************************************/
void flash_voErrorWrite(void)
{
 
   UWORD count_len = sizeof(ERROR_LOG) * QUEUE_SIZE/ 2;

    que_stFlashErrorLog.stLog[0].ubHead = que_stFlashErrorLog.ubHead;
    que_stFlashErrorLog.stLog[0].ubRear = que_stFlashErrorLog.ubRear;


   FLASH_voWriteMoreData(StartServerManageError_Address, (UWORD *)(&que_stFlashErrorLog.stLog), count_len,1);

}


/***************************************************************
 Function: flash_voErrorRead
 Description: read ERROR_LOG  to flash
 Call by:  ;
 Input Variables: N/A
 Output/Return Variables: N/A
 Subroutine Call: N/A;
 Reference: N/A
****************************************************************/

void flash_voErrorRead(void)
{
    UWORD count_len = sizeof(ERROR_LOG) * QUEUE_SIZE/ 2;


    FLASH_voReadMoreData(StartServerManageError_Address, (UWORD *)(&que_stFlashErrorLog.stLog), count_len);
    que_stFlashErrorLog.ubHead = que_stFlashErrorLog.stLog[0].ubHead;
    que_stFlashErrorLog.ubRear = que_stFlashErrorLog.stLog[0].ubRear;


    if(que_stFlashErrorLog.ubHead == 0xFF)
    {
       que_voInit(&que_stFlashErrorLog);
    }

}
/***************************************************************
 Function: flash_voErrorClear
 Description: Clear Err Address data-2k
 Call by:  ;
 Input Variables: N/A
 Output/Return Variables: N/A
 Subroutine Call: N/A;
 Reference: N/A
****************************************************************/
void flash_voErrorClear(void)
{
    UBYTE erase_status;
   /* Disable all interrupts */
     //  DISABLE_IRQ; /* MCU Core and GPIO configuration */

//      DL_FlashCTL_unprotectSector(
//           FLASHCTL, StartServerManageError_Address, DL_FLASHCTL_REGION_SELECT_MAIN);
//       gCmdStatus = DL_FlashCTL_eraseMemoryFromRAM(
//           FLASHCTL, StartServerManageError_Address, DL_FLASHCTL_COMMAND_SIZE_SECTOR);

    CMD_USER_API_Flash_Range_Erase(StartServerManageError_Address,EndServerManageError_Address);


      /* Enable all interrupts */
   //  ENABLE_IRQ;
}

void flash_voSysParaWrite(void)
{
     UWORD count_len = (sizeof(SYSTEM_PARAMETER2) ) / 2;
     UWORD tmpCRC;
    tmpCRC = Syspara2.uwCRC;
    Syspara2.uwCRC = uart_uwCRCCcitt((UBYTE*)(&Syspara2), (count_len-1)*2);
    if(Syspara2.uwCRC != tmpCRC)
    {
      FLASH_voWriteMoreData(StartServerManageSysPara_Address, (UWORD *)(&Syspara2), count_len,1);
    }
    //test
//     UWORD count_len = (sizeof(STRUCT_FLASHCHECK) ) / 2;
//     FLASH_voWriteMoreData(StartServerManageSysPara_Address, (UWORD *)(&Flash_test), count_len,1);
}
//UWORD count_len_test=0;

void flash_voSysParaRead(void)
{
    //test
//    UWORD count_len = (sizeof(STRUCT_FLASHCHECK)) / 2;
//      count_len_test=count_len;
//    FLASH_voReadMoreData(StartServerManageSysPara_Address, (UWORD *)(&Flash_testread), count_len);

    UWORD count_len = (sizeof(SYSTEM_PARAMETER2)) / 2;
   // count_len_test=count_len;
    FLASH_voReadMoreData(StartServerManageSysPara_Address, (UWORD *)(&Syspara2), count_len);
    UWORD uwCRC = uart_uwCRCCcitt((UBYTE*)(&Syspara2), (count_len-1)*2);
    if(Syspara2.uwCRC != uwCRC)
    {
        flash_voSysParaInit();
    }

//    //mos校准参数更新
    MosResInside.bllibFinishFlag=TRUE;
    memcpy(&MosCal_A.RES, &Syspara2.EepromMosPara.EEP_MOSA, sizeof(Syspara2.EepromMosPara.EEP_MOSA));
    memcpy(&MosCal_B.RES, &Syspara2.EepromMosPara.EEP_MOSB, sizeof(Syspara2.EepromMosPara.EEP_MOSB));
    memcpy(&MosCal_C.RES, &Syspara2.EepromMosPara.EEP_MOSC, sizeof(Syspara2.EepromMosPara.EEP_MOSC));
    MosResRead();

}

 void flash_voSysParaInit(void)
{
    /*重置所有的参数，不包括历史记录*/
       // SYSTEM_PARAMETER2 Sysparaint = SYSPARA2;
         Assist_PARAMETER  FlashAssistPara=  I2CAssistPara;
         MOTOR_PARAMETER  FlashMotorPara=I2CMotorPara;
         BIKE_PARAMETER  FlashBikePara=I2CBikePara;
         MControl_PARAMETER  FlashMControlPara=I2CMControlPara;
         Sensor_PARAMETER FlashSensorPara=I2CSensorPara;
   
        Syspara2.stAssistPara = FlashAssistPara;//Sysparaint.stAssistPara;
        Syspara2.stBikePara = FlashBikePara;//Sysparaint.stBikePara;
        Syspara2.stMControlPara = FlashMControlPara;//Sysparaint.stMControlPara;
        Syspara2.stMotorPara = FlashMotorPara;//Sysparaint.stMotorPara;
        Syspara2.stSensorPara = FlashSensorPara;//Sysparaint.stSensorPara;


       // memset(&Syspara2.flash_stPara.ubMotorVersion, 0, sizeof(FLASH_PARA_TYPE));
        SLONG Flash_TorqueAssGain[15][4] = TORQUE_ASSIST_DEFAULT;
        SLONG Flash_CadAssGain[5][4] = CADENCE_ASSIST_DEFAULT;
        memcpy(&Syspara2.flash_stPara.slTorqAssGain[0], &Flash_TorqueAssGain[0], sizeof(Flash_TorqueAssGain));
        memcpy(&Syspara2.flash_stPara.slCadAssGain[0], &Flash_CadAssGain[0], sizeof(Flash_CadAssGain));
        CodeParaInit();
        Can_voUpdateMC_UpcInfo();
        memcpy(&Syspara2.flash_stPara.stTestParaInfo, &MC_UpcInfo.stTestParaInfo, sizeof(MC_UpcInfo.stTestParaInfo));
        flash_voMosResParaInit();
        flash_voSysParaWrite();
}

 //----mos内阻参数存储

// void flash_voMosResParaRead(void)
// {
//       UWORD count_len = (sizeof(MOSEEPROM_Struct)) / 2;
//       count_len_test=count_len;
//     FLASH_voReadMoreData(StartMosPara_Address, (UWORD *)(&Syspara2.EepromMosPara), count_len);
//     UWORD uwCRC = uart_uwCRCCcitt((UBYTE*)(&EepromMosPara), (count_len-1)*2);
//
//     if(Syspara2.EepromMosPara.uwCRC != uwCRC)
//     {
//         flash_voMosResParaInit();
//     }
//     MosResInside.bllibFinishFlag=TRUE;
//     memcpy(&MosCal_A.RES, &Syspara2.EepromMosPara.EEP_MOSA, sizeof(Syspara2.EepromMosPara.EEP_MOSA));
//     memcpy(&MosCal_B.RES, &Syspara2.EepromMosPara.EEP_MOSB, sizeof(Syspara2.EepromMosPara.EEP_MOSB));
//     memcpy(&MosCal_C.RES, &Syspara2.EepromMosPara.EEP_MOSC, sizeof(Syspara2.EepromMosPara.EEP_MOSC));
//
//     MosResRead();
// }
//
// void flash_voMosResParaWrite(void)
// {
//     UWORD count_len = (sizeof(MOSEEPROM_Struct) ) / 2;
//     UWORD tmpCRC;
//     tmpCRC = Syspara2.EepromMosPara.uwCRC;
//     Syspara2.EepromMosPara.uwCRC = uart_uwCRCCcitt((UBYTE*)(&Syspara2.EepromMosPara), (count_len-1)*2);
//     if(EepromMosPara.uwCRC != tmpCRC)
//     {
//       FLASH_voWriteMoreData(StartMosPara_Address, (UWORD *)(&Syspara2.EepromMosPara), count_len,1);
//     }
// }
 void flash_voMosResParaInit(void)
{

     Syspara2.EepromMosPara.EEP_K50=1245;
     Syspara2.EepromMosPara.EEP_K75=1393;
     Syspara2.EepromMosPara.EEP_K100=1540;
     Syspara2.EepromMosPara.EEP_K125=1704;
     Syspara2.EepromMosPara.EEP_K150=1868;

     Syspara2.EepromMosPara.EEP_MOSA.uwTEMP_RES0=3050;
     Syspara2.EepromMosPara.EEP_MOSA.uwTEMP_RES1=3424;
     Syspara2.EepromMosPara.EEP_MOSA.uwTEMP_RES2=3797;
     Syspara2.EepromMosPara.EEP_MOSA.uwTEMP_RES3=4249;
     Syspara2.EepromMosPara.EEP_MOSA.uwTEMP_RES4=4697;
     Syspara2.EepromMosPara.EEP_MOSA.uwTEMP_RES5=5197;
     Syspara2.EepromMosPara.EEP_MOSA.uwTEMP_RES6=5697;

     Syspara2.EepromMosPara.EEP_MOSB.uwTEMP_RES0=3050;
     Syspara2.EepromMosPara.EEP_MOSB.uwTEMP_RES1=3424;
     Syspara2.EepromMosPara.EEP_MOSB.uwTEMP_RES2=3797;
     Syspara2.EepromMosPara.EEP_MOSB.uwTEMP_RES3=4249;
     Syspara2.EepromMosPara.EEP_MOSB.uwTEMP_RES4=4697;
     Syspara2.EepromMosPara.EEP_MOSB.uwTEMP_RES5=5197;
     Syspara2.EepromMosPara.EEP_MOSB.uwTEMP_RES6=5697;

     Syspara2.EepromMosPara.EEP_MOSC.uwTEMP_RES0=3050;
     Syspara2.EepromMosPara.EEP_MOSC.uwTEMP_RES1=3424;
     Syspara2.EepromMosPara.EEP_MOSC.uwTEMP_RES2=3797;
     Syspara2.EepromMosPara.EEP_MOSC.uwTEMP_RES3=4249;
     Syspara2.EepromMosPara.EEP_MOSC.uwTEMP_RES4=4697;
     Syspara2.EepromMosPara.EEP_MOSC.uwTEMP_RES5=5197;
     Syspara2.EepromMosPara.EEP_MOSC.uwTEMP_RES6=5697;

     //   Syspara2.MosResInside.bllibFinishFlag=FALSE;
}


 void flash_voProductParaWrite(void)
 {
      UWORD count_len = (sizeof(PRODUCT_INFO_Struct) ) / 2;
      UWORD tmpCRC;
     tmpCRC = Productionpara.uwCRC;
     Productionpara.uwCRC = uart_uwCRCCcitt((UBYTE*)(&Productionpara), (count_len-1)*2);
     if(Productionpara.uwCRC != tmpCRC)
     {
       FLASH_voWriteMoreData(StartServerManageProtuct_Address, (UWORD *)(&Productionpara), count_len,1);
     }

 }

 void flash_voProductParaRead(void)
 {
     UWORD count_len = (sizeof(PRODUCT_INFO_Struct)) / 2;
    // count_len_test=count_len;
     FLASH_voReadMoreData(StartServerManageProtuct_Address, (UWORD *)(&Productionpara), count_len);
     UWORD uwCRC = uart_uwCRCCcitt((UBYTE*)(&Productionpara), (count_len-1)*2);
     if(Productionpara.uwCRC != uwCRC)
     {
         flash_voProductParaInit();
     }

 }
 void flash_voProductParaInit(void)
{
     memset(&Productionpara.ubMotorVersion, 0, sizeof(PRODUCT_INFO_Struct));


}