/*
 * File: BCU.c
 *
 * Code generated for Simulink model 'BCU'.
 *
 * Model version                  : 1.33
 * Simulink Coder version         : 9.4 (R2020b) 29-Jul-2020
 * C/C++ source code generated on : Thu Sep  9 18:19:09 2021
 *
 * Target selection: ert.tlc
 * Embedded hardware selection: Intel->x86-64 (Windows64)
 * Code generation objectives: Unspecified
 * Validation result: Not run
 */

#include "BCU.h"
#include "BCU_private.h"
static StaticTask_t         gProcess_Bcu_Task_t;
static UINT8                gProcess_Bcu_TaskStack[PROC_BCU_TASK_STACK_SIZE];
static osThreadId_t         BcuTaskId = NULL;
static process_Bcu 		    gProcess_Bcu_Task;
#define PROC_BCU_STATE_SWITCH(a)  (gProcess_Bcu_Task = a)

/* Real-time model */
static RT_MODEL_BCU_T BCU_M_;
RT_MODEL_BCU_T *const BCU_M = &BCU_M_;

/* Model step function */
void BCU_step(void)
{
      uint8_T i;
	  osDelay(1000);
	  PROC_BCU_STATE_SWITCH(PROCESS_STATE_INIT);
	  while (TRUE)
	  {
		switch(gProcess_Bcu_Task)
		{
		  case PROCESS_STATE_INIT:
		  { BCU_initialize();  
		    cand_Nr_cellNr=0;
			memcpy(blcv_Q_totalCpEi,AppDataInfo.blcv_Q_totalCpE, 28*sizeof(uint32_T));		 
			memcpy(blcv_Q_reqCpEi,AppDataInfo.blcv_Q_reqCpE, 28*sizeof(uint16_T));	 
			socd_pct_bcuSocEi = AppDataInfo.socd_pct_bcuSocE;			
			socd_pct_battSocEi = AppDataInfo.socd_pct_battSocE; 		
			sohd_tm_chrgStartStatEi = AppDataInfo.sohd_tm_chrgStartStatE;	  
			sohd_flg_chrgEndEi = AppDataInfo.sohd_flg_chrgEndE; 		   
			memcpy(sohv_V_chrgStartStatEi,AppDataInfo.sohv_V_chrgStartStatE, 28*sizeof(uint16_T));
			sohd_Q_chrgEi = AppDataInfo.sohd_Q_chrgE;				  
			memcpy(sohv_Q_packCapArrEi,AppDataInfo.sohv_Q_packCapArrE, 10*sizeof(uint16_T));
			memcpy(sohv_Q_cellCapArrEi,AppDataInfo.sohv_Q_cellCapArrE, 28*sizeof(uint16_T));
			PROC_BCU_STATE_SWITCH(PROCESS_STATE_IDLE);
			break;
		  }
		  case PROCESS_STATE_IDLE:
		  {
			while (TRUE)
			{
			  osDelay(100);
			  if(gProcess_app!=LISTEN)
			  {
				PROC_BCU_STATE_SWITCH(PROCESS_STATE_WORK);
				break;
			  }
			  else
			  {
				PROC_BCU_STATE_SWITCH(PROCESS_STATE_SLEEP);
				break;
			  }
			}
			break;
		  }
		  case PROCESS_STATE_WORK:
		  {
			while (TRUE)
			{
			  osDelay(100);
			  if(gProcess_app==LISTEN)
			  {
				PROC_BCU_STATE_SWITCH(PROCESS_STATE_SLEEP);
				break;
			  }
			  //***************
			  ihd_I_curr = (int16_T)(-(battI - 10000));
			  ihd_V_cellUMax = maxCellVol;
			  ihd_V_cellUMin = minCellVol;
			  ihd_V_cellUAvrg = avrgCellVol;
			  memcpy(ihv_V_cellU,battCellU,AppNVMData.BattCellCount*sizeof(uint16_T));
			  for(i=0;i<4;i++)
			  {
			   ihv_T_modT[i]= battCellTemp[i]-40;
			  	}
			  //memcpy(ihv_T_modT,battCellTemp,AppNVMData.BattTempCount*sizeof(uint16_T));
			  ihd_T_modTMax = maxCellTemp-40;
			  ihd_T_modTMin = minCellTemp-40;
			  ihd_st_workStat  = BattWorkStateDelay;
			  ihd_L_urtRecv=UartRecvFlag;
			  ihd_flg_currFlt= ((battWarningState >> 1) & 0x01) == 1;   //battu low
			  ihd_flg_chrgMosClosFlt= ((battWarningState >> 19) & 0x01) == 1;
			  ihd_flg_dischrgMosClosFlt=((battWarningState >> 18) & 0x01) == 1;
			 // socd_pct_battSocEi=300;


			  SFM();
	

			  SPM();


			  //
              cand_Nr_cellNr=cand_Nr_cellNr+1;
			  if(cand_Nr_cellNr> cmnc_num_cellUNum)
			  	{
               cand_Nr_cellNr=1;

			  }
			  cand_Q_cellCap=sohv_Q_cellCap[cand_Nr_cellNr-1];
			  cand_V_chrgStartStat=sohv_V_chrgStartStatEo[cand_Nr_cellNr-1];
			  //

				if(socd_flg_EEsave==1)
				{
				  memcpy(AppDataInfo.blcv_Q_totalCpE,blcv_Q_totalCpEo, 28*sizeof(uint32_T));	   
				  memcpy(AppDataInfo.blcv_Q_reqCpE,blcv_Q_reqCpEo, 28*sizeof(uint16_T));	
				  AppDataInfo.socd_pct_bcuSocE =  socd_pct_bcuSocEo;  
				  AppDataInfo.socd_pct_battSocE = socd_pct_battSocEo;
				  AppDataInfo.sohd_tm_chrgStartStatE = sohd_tm_chrgStartStatEo;
				  AppDataInfo.sohd_flg_chrgEndE = sohd_flg_chrgEndEo;	  
				  memcpy(AppDataInfo.sohv_V_chrgStartStatE,sohv_V_chrgStartStatEo, 28*sizeof(uint16_T));
				  AppDataInfo. sohd_Q_chrgE = sohd_Q_chrgEo;		   
				  memcpy(AppDataInfo.sohv_Q_packCapArrE,sohv_Q_packCapArrEo, 10*sizeof(uint16_T));
				  memcpy(AppDataInfo.sohv_Q_cellCapArrE,sohv_Q_cellCapArrEo, 28*sizeof(uint16_T));
				  AppDataInfo.appDataModify = TRUE;
				 }

			}
			break;
		  }
		  case PROCESS_STATE_SLEEP:
		  { 
			memcpy(AppDataInfo.blcv_Q_totalCpE,blcv_Q_totalCpEo, 28*sizeof(uint32_T));		 
			memcpy(AppDataInfo.blcv_Q_reqCpE,blcv_Q_reqCpEo, 28*sizeof(uint16_T));	  
			AppDataInfo.socd_pct_bcuSocE =	socd_pct_bcuSocEo;	
			AppDataInfo.socd_pct_battSocE = socd_pct_battSocEo;
			AppDataInfo.sohd_tm_chrgStartStatE = sohd_tm_chrgStartStatEo;
			AppDataInfo.sohd_flg_chrgEndE = sohd_flg_chrgEndEo; 	
			memcpy(AppDataInfo.sohv_V_chrgStartStatE,sohv_V_chrgStartStatEo, 28*sizeof(uint16_T));
			AppDataInfo. sohd_Q_chrgE = sohd_Q_chrgEo;			 
			memcpy(AppDataInfo.sohv_Q_packCapArrE,sohv_Q_packCapArrEo, 10*sizeof(uint16_T));
			memcpy(AppDataInfo.sohv_Q_cellCapArrE,sohv_Q_cellCapArrEo, 28*sizeof(uint16_T));
			AppDataInfo.appDataModify = TRUE;
			//
			cand_Nr_cellNr=0;
			ihd_tm_parkTime=0;
			while (TRUE)
			{
			  osDelay(1000);
			  ihd_tm_parkTime++;
			  if(gProcess_app!=LISTEN)
			  {
				PROC_BCU_STATE_SWITCH(PROCESS_STATE_INIT);
				break;
			  }
			}
			break;
		  }
		  default:
		  {
			PROC_BCU_STATE_SWITCH(PROCESS_STATE_INIT);
			break;
		  }
		}
	  }
}

/* Model initialize function */
void BCU_initialize(void)
{
  /* Registration code */

  /* block I/O */

  /* custom signals */
  {
    int32_T i;
    for (i = 0; i < 28; i++) {
      sohv_Q_cellCap[i] = 300U;
    }
  }

  sohd_pct_bcuSoh = 1000U;

  /* Model Initialize function for ModelReference Block: '<Root>/SFM' */
  SFM_initialize(rtmGetErrorStatusPointer(BCU_M));

  /* Model Initialize function for ModelReference Block: '<Root>/SPM' */
  SPM_initialize(rtmGetErrorStatusPointer(BCU_M));

  /* SystemInitialize for ModelReference: '<Root>/SFM' incorporates:
   *  Inport: '<Root>/In1'
   *  Inport: '<Root>/battI '
   *  Inport: '<Root>/ihd_L_urtRecv'
   *  Inport: '<Root>/ihd_P_gas'
   *  Inport: '<Root>/ihd_flg_chrgMosClosFlt'
   *  Inport: '<Root>/ihd_flg_disChrgMosClosFlt'
   *  Inport: '<Root>/ihv_T_modT'
   *  Inport: '<Root>/ihv_V_cellU'
   */
  SFM_Init();

  /* SystemInitialize for ModelReference: '<Root>/SPM' incorporates:
   *  Inport: '<Root>/blcv_Q_reqCpEi'
   *  Inport: '<Root>/blcv_Q_totalCpEi'
   *  Inport: '<Root>/ihd_T_bdtemp'
   *  Inport: '<Root>/ihd_st_workStat'
   *  Inport: '<Root>/ihd_tm_packTime'
   *  Inport: '<Root>/socd_pct_battSocEi'
   *  Inport: '<Root>/socd_pct_bcuSocEi'
   *  Inport: '<Root>/sohd_Q_chrgEi '
   *  Inport: '<Root>/sohd_flg_chrgEndEi '
   *  Inport: '<Root>/sohd_tm_chrgStartStatEi '
   *  Inport: '<Root>/sohv_Q_cellCapArrEi 1'
   *  Inport: '<Root>/sohv_Q_packCapArrEi '
   *  Inport: '<Root>/sohv_V_chrgStartStatEi '
   */
  SPM_Init();
}

/* Model terminate function */
void BCU_terminate(void)
{
  /* (no terminate code required) */
}

/*
 * File trailer for generated code.
 *
 * [EOF]
 */

	  void AppTaskBcuInit(void *arg)
	{
		osThreadAttr_t task_attr;
		memset(&task_attr,0,sizeof(task_attr));
		memset(gProcess_Bcu_TaskStack, 0xA5, PROC_BCU_TASK_STACK_SIZE);
		task_attr.name = "Bcu_Task";
		task_attr.stack_mem = gProcess_Bcu_TaskStack;
		task_attr.stack_size = PROC_BCU_TASK_STACK_SIZE;
		task_attr.priority = osPriorityBelowNormal7;
		task_attr.cb_mem = &gProcess_Bcu_Task_t;
		task_attr.cb_size = sizeof(StaticTask_t);
		BcuTaskId = osThreadNew(BCU_step, NULL, &task_attr);
	}