/**
  ******************************************************************************
  * @file    dflash_sf1.c 
  * @author  AMG Energy Solution Team
  * @version V1.0.0
  * @date    07-Feb-2022
  * @brief   This file provides all the codes of safety parameter functions.
  ******************************************************************************
  * @attention
  *
  * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
  * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
  * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
  * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
  * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
  * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
  *
  * <h2><center>&copy; COPYRIGHT 2022 AMG</center></h2>
  ******************************************************************************
  */ 

/** @addtogroup mBMS2
  * @{
  */

/* Includes ------------------------------------------------------------------*/
#include <includes.h>
#include "dflash_sf1.h"
#include "device_param.h"
#include "asutil.h"
#include "console.h"
#include "alarm.h"
//#include "temp.h"

#ifdef CONSOLE_DEBUG

/* Private typedef -----------------------------------------------------------*/
/* Private define ------------------------------------------------------------*/
/* Private macro -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
/* Private function prototypes -----------------------------------------------*/
uint8_t SetSF1_Param(uint8_t *text, uint8_t aDevice);

/* Private functions ---------------------------------------------------------*/

/* Command processing in SETTING STATE */
int8_t Process_DataSF1Set(uint8_t *text, uint16_t size)
{
	uint16_t i, ret;

	/* Invalid command if space is in first position */
	if (size > 1) {if (text[1] != ' ') return(0);}
	text[size] = 0x00;
	ret = 1;

	switch (text[0]) 
	{
case 'o':     /* Switch to operating mode */
			screenmode = OP_MODE;
			ViewScreen();
			break;
case 's':     /* Switch to setting status */
			screenmode = SET_MODE;
			ViewScreen();
			break;
case 'd':     /* Switch to diagnostic mode */
			screenmode = DIAG_MODE;
			ViewScreen();
			break;
		case 'z':
			screenmode = OS_STATUS_MODE;
			ViewScreen();
			break;
		case 'c':
			screenmode = CHG_CTRL_CFG_MODE;
			ViewScreen();
			break;
		case '1':		// Cell Voltage Parameter Setting
		case '2':		// Current Parameter Setting
		case '3':		// Temperature Parameter Setting
		case '4':		// System Voltage Parameter Setting
		case '5':		// SOC Parameter Setting
		case '6':		// Open Thermistor Parameter Setting
			i = SetSF1_Param(&text[2],text[0]);
			if (i == 0) 
				UserMessage("COMMAND COMPLETE");
			else if (i == 1) 
UserMessage("COMMAND FORMAT ERROR");   /* setting format error */
			else 		
UserMessage("COMMAND LIMIT ERROR");    /* setting limit error */
			break;
		case 'I':
			SF1_InitData();
			Save_Param();
			break;
		default :
			ret = 0;
			break;
	}

	return(ret);
}

void SF1DisplayCellVoltage(uint8_t p)
{
	uint8_t text[20];
	PDEVICE_PARAM param = &device_param;
	PDEVICE_PARAM dis_param = &dis_device_param;
	int x;
	
	x = 20;
	// COV Threshold (Offset 0)
	if (p || (dis_param->safety.voltage.COV_Threshold != param->safety.voltage.COV_Threshold))
	{
		sprintf((char *)text, "%4d", param->safety.voltage.COV_Threshold);
		GreenOutXY(x, 4, text);
		dis_param->safety.voltage.COV_Threshold = param->safety.voltage.COV_Threshold;
	}
	// COV Warning (Offset 2)
	if (p || (dis_param->safety.voltage.COV_Warning != param->safety.voltage.COV_Warning))
	{
		sprintf((char *)text, "%4d", param->safety.voltage.COV_Warning);
		GreenOutXY(x, 5, text);
		dis_param->safety.voltage.COV_Warning = param->safety.voltage.COV_Warning;
	}
	// COV Recovery (Offset 4)
	if (p || (dis_param->safety.voltage.COV_Recovery != param->safety.voltage.COV_Recovery))
	{
		sprintf((char *)text, "%4d", param->safety.voltage.COV_Recovery);
		GreenOutXY(x, 6, text);
		dis_param->safety.voltage.COV_Recovery = param->safety.voltage.COV_Recovery;
	}
	// CUV Threshold (Offset 6)
	if (p || (dis_param->safety.voltage.CUV_Threshold != param->safety.voltage.CUV_Threshold))
	{
		sprintf((char *)text, "%4d", param->safety.voltage.CUV_Threshold);
		GreenOutXY(x, 8, text);
		dis_param->safety.voltage.CUV_Threshold = param->safety.voltage.CUV_Threshold;
	}
	// CUV Warning	(Offset 8)
	if (p || (dis_param->safety.voltage.CUV_Warning != param->safety.voltage.CUV_Warning))
	{
		sprintf((char *)text, "%4d", param->safety.voltage.CUV_Warning);
		GreenOutXY(x, 9, text);
		dis_param->safety.voltage.CUV_Warning = param->safety.voltage.CUV_Warning;
	}
	// CUV Recovery (Offset 10)
	if (p || (dis_param->safety.voltage.CUV_Recovery != param->safety.voltage.CUV_Recovery))
	{
		sprintf((char *)text, "%4d", param->safety.voltage.CUV_Recovery);
		GreenOutXY(x, 10, text);
		dis_param->safety.voltage.CUV_Recovery = param->safety.voltage.CUV_Recovery;
	}
}

void SF1DisplayCurrent(uint8_t p)
{
	uint8_t text[20];
	PDEVICE_PARAM param = &device_param;
	PDEVICE_PARAM dis_param = &dis_device_param;
	int x;
	
	x = 19;
	// OC_Chg_Threshold (Offset 0)
	if (p || (dis_param->safety.current.OC_Chg_Threshold != param->safety.current.OC_Chg_Threshold))
	{
		sprintf((char *)text, "%5d", param->safety.current.OC_Chg_Threshold);
		GreenOutXY(x, 12, text);
		dis_param->safety.current.OC_Chg_Threshold = param->safety.current.OC_Chg_Threshold;
	}
	// OC_Chg_Warning (Offset 2)
	if (p || (dis_param->safety.current.OC_Chg_Warning != param->safety.current.OC_Chg_Warning))
	{
		sprintf((char *)text, "%5d", param->safety.current.OC_Chg_Warning);
		GreenOutXY(x, 13, text);
		dis_param->safety.current.OC_Chg_Warning = param->safety.current.OC_Chg_Warning;
	}
	// OC_Chg_Recovery (Offset 6)
	if (p || (dis_param->safety.current.OC_Chg_Recovery != param->safety.current.OC_Chg_Recovery))
	{
		sprintf((char *)text, "%5d", param->safety.current.OC_Chg_Recovery);
		GreenOutXY(x, 14, text);
		dis_param->safety.current.OC_Chg_Recovery = param->safety.current.OC_Chg_Recovery;
	}
	// OC_Chg_Rec_Time (Offset 8)
	if (p || (dis_param->safety.current.OC_Chg_Rec_Time != param->safety.current.OC_Chg_Rec_Time))
	{
		sprintf((char *)text, "%3d", param->safety.current.OC_Chg_Rec_Time);
		GreenOutXY(x + 2, 15, text);
		dis_param->safety.current.OC_Chg_Rec_Time = param->safety.current.OC_Chg_Rec_Time;
	}
	
	// OC_Dsg_Threshold (Offset 10)
	if (p || (dis_param->safety.current.OC_Dsg_Threshold != param->safety.current.OC_Dsg_Threshold))
	{
		sprintf((char *)text, "%5d", param->safety.current.OC_Dsg_Threshold);
		GreenOutXY(x, 17, text);
		dis_param->safety.current.OC_Dsg_Threshold = param->safety.current.OC_Dsg_Threshold;
	}
	// OC_Dsg_Warning (Offset 12)
	if (p || (dis_param->safety.current.OC_Dsg_Warning != param->safety.current.OC_Dsg_Warning))
	{
		sprintf((char *)text, "%5d", param->safety.current.OC_Dsg_Warning);
		GreenOutXY(x, 18, text);
		dis_param->safety.current.OC_Dsg_Warning = param->safety.current.OC_Dsg_Warning;
	}
	// OC_Dsg_Recovery (Offset 14)
	if (p || (dis_param->safety.current.OC_Dsg_Recovery != param->safety.current.OC_Dsg_Recovery))
	{
		sprintf((char *)text, "%5d", param->safety.current.OC_Dsg_Recovery);
		GreenOutXY(x, 19, text);
		dis_param->safety.current.OC_Dsg_Recovery = param->safety.current.OC_Dsg_Recovery;
	}
	// OC_Dsg_Rec_Time (Offset 16)
	if (p || (dis_param->safety.current.OC_Dsg_Rec_Time != param->safety.current.OC_Dsg_Rec_Time))
	{
		sprintf((char *)text, "%3d", param->safety.current.OC_Dsg_Rec_Time);
		GreenOutXY(x + 2, 20, text);
		dis_param->safety.current.OC_Dsg_Rec_Time = param->safety.current.OC_Dsg_Rec_Time;
	}
}

void SF1DisplayTemperature(uint8_t p)
{
	PDEVICE_PARAM param = &device_param;
	PDEVICE_PARAM dis_param = &dis_device_param;
	int x;
	
	x = 46;
	// Over Temp Chg Threshold (Offset 0)
	if (p || (dis_param->safety.temperature.OT_Chg_Threshold != param->safety.temperature.OT_Chg_Threshold))
	{
		FloatNormalOutIntXY(x, 4, (float)param->safety.temperature.OT_Chg_Threshold / 10, 5, 1);
		dis_param->safety.temperature.OT_Chg_Threshold = param->safety.temperature.OT_Chg_Threshold;
	}
	// Over Temp Chg Warning (Offset 2)
	if (p || (dis_param->safety.temperature.OT_Chg_Warning != param->safety.temperature.OT_Chg_Warning))
	{
		FloatNormalOutIntXY(x, 5, (float)param->safety.temperature.OT_Chg_Warning / 10, 5, 1);
		dis_param->safety.temperature.OT_Chg_Warning = param->safety.temperature.OT_Chg_Warning;
	}

	// OT Chg Recovery (Offset 3)
	if (p || (dis_param->safety.temperature.OT_Chg_Recovery != param->safety.temperature.OT_Chg_Recovery))
	{
		FloatNormalOutIntXY(x, 6, (float)param->safety.temperature.OT_Chg_Recovery / 10, 5, 1);
		dis_param->safety.temperature.OT_Chg_Recovery = param->safety.temperature.OT_Chg_Recovery;
	}

	// Over Temp Dsg Threshold (Offset 5)
	if (p || (dis_param->safety.temperature.OT_Dsg_Threshold != param->safety.temperature.OT_Dsg_Threshold))
	{
		FloatNormalOutIntXY(x, 8, (float)param->safety.temperature.OT_Dsg_Threshold / 10, 5, 1);
		dis_param->safety.temperature.OT_Dsg_Threshold = param->safety.temperature.OT_Dsg_Threshold;
	}
	// Over Temp Dsg Warning (Offset 5)
	if (p || (dis_param->safety.temperature.OT_Dsg_Warning != param->safety.temperature.OT_Dsg_Warning))
	{
		FloatNormalOutIntXY(x, 9, (float)param->safety.temperature.OT_Dsg_Warning / 10, 5, 1);
		dis_param->safety.temperature.OT_Dsg_Warning = param->safety.temperature.OT_Dsg_Warning;
	}

	// OT Dsg Recovery (Offset 8)
	if (p || (dis_param->safety.temperature.OT_Dsg_Recovery != param->safety.temperature.OT_Dsg_Recovery))
	{
		FloatNormalOutIntXY(x, 10, (float)param->safety.temperature.OT_Dsg_Recovery / 10, 5, 1);
		dis_param->safety.temperature.OT_Dsg_Recovery = param->safety.temperature.OT_Dsg_Recovery;
	}

	// Low temperature
	// LT Chg Threshold (Offset 0)
	if (p || (dis_param->safety.temperature.LT_Chg_Threshold != param->safety.temperature.LT_Chg_Threshold))
	{
		FloatNormalOutIntXY(x, 12, (float)param->safety.temperature.LT_Chg_Threshold / 10, 5, 1);
		dis_param->safety.temperature.LT_Chg_Threshold = param->safety.temperature.LT_Chg_Threshold;
	}
	// LT Chg Warning (Offset 2)
	if (p || (dis_param->safety.temperature.LT_Chg_Warning != param->safety.temperature.LT_Chg_Warning))
	{
		FloatNormalOutIntXY(x, 13, (float)param->safety.temperature.LT_Chg_Warning / 10, 5, 1);
		dis_param->safety.temperature.LT_Chg_Warning = param->safety.temperature.LT_Chg_Warning;
	}
	// LT Chg Recovery (Offset 3)
	if (p || (dis_param->safety.temperature.LT_Chg_Recovery != param->safety.temperature.LT_Chg_Recovery))
	{
		FloatNormalOutIntXY(x, 14, (float)param->safety.temperature.LT_Chg_Recovery / 10, 5, 1);
		dis_param->safety.temperature.LT_Chg_Recovery = param->safety.temperature.LT_Chg_Recovery;
	}

	// LT Dsg Threshold (Offset 5)
	if (p || (dis_param->safety.temperature.LT_Dsg_Threshold != param->safety.temperature.LT_Dsg_Threshold))
	{
		FloatNormalOutIntXY(x, 16, (float)param->safety.temperature.LT_Dsg_Threshold / 10, 5, 1);
		dis_param->safety.temperature.LT_Dsg_Threshold = param->safety.temperature.LT_Dsg_Threshold;
	}
	// LT Dsg Warning (Offset 5)
	if (p || (dis_param->safety.temperature.LT_Dsg_Warning != param->safety.temperature.LT_Dsg_Warning))
	{
		FloatNormalOutIntXY(x, 17, (float)param->safety.temperature.LT_Dsg_Warning / 10, 5, 1);
		dis_param->safety.temperature.LT_Dsg_Warning = param->safety.temperature.LT_Dsg_Warning;
	}
	// LT Dsg Recovery (Offset 8)
	if (p || (dis_param->safety.temperature.LT_Dsg_Recovery != param->safety.temperature.LT_Dsg_Recovery))
	{
		FloatNormalOutIntXY(x, 18, (float)param->safety.temperature.LT_Dsg_Recovery / 10, 5, 1);
		dis_param->safety.temperature.LT_Dsg_Recovery = param->safety.temperature.LT_Dsg_Recovery;
	}
}

void SF1DisplaySVoltage(uint8_t p)
{
	uint8_t text[20];
	PDEVICE_PARAM param = &device_param;
	PDEVICE_PARAM dis_param = &dis_device_param;
	int x;
	
	x = 73;
	// SOV Threshold (Offset 0)
	if (p || (dis_param->safety.voltage.SOV_Threshold != param->safety.voltage.SOV_Threshold))
	{
		sprintf((char *)text, "%4d", param->safety.voltage.SOV_Threshold);
		GreenOutXY(x, 4, text);
		dis_param->safety.voltage.SOV_Threshold = param->safety.voltage.SOV_Threshold;
	}
	// SOV Warning (Offset 2)
	if (p || (dis_param->safety.voltage.SOV_Warning != param->safety.voltage.SOV_Warning))
	{
		sprintf((char *)text, "%4d", param->safety.voltage.SOV_Warning);
		GreenOutXY(x, 5, text);
		dis_param->safety.voltage.SOV_Warning = param->safety.voltage.SOV_Warning;
	}
	// SOV Recovery (Offset 4)
	if (p || (dis_param->safety.voltage.SOV_Recovery != param->safety.voltage.SOV_Recovery))
	{
		sprintf((char *)text, "%4d", param->safety.voltage.SOV_Recovery);
		GreenOutXY(x, 6, text);
		dis_param->safety.voltage.SOV_Recovery = param->safety.voltage.SOV_Recovery;
	}
	// SUV Threshold (Offset 6)
	if (p || (dis_param->safety.voltage.SUV_Threshold != param->safety.voltage.SUV_Threshold))
	{
		sprintf((char *)text, "%4d", param->safety.voltage.SUV_Threshold);
		GreenOutXY(x, 8, text);
		dis_param->safety.voltage.SUV_Threshold = param->safety.voltage.SUV_Threshold;
	}
	// SUV Warning	(Offset 8)
	if (p || (dis_param->safety.voltage.SUV_Warning != param->safety.voltage.SUV_Warning))
	{
		sprintf((char *)text, "%4d", param->safety.voltage.SUV_Warning);
		GreenOutXY(x, 9, text);
		dis_param->safety.voltage.SUV_Warning = param->safety.voltage.SUV_Warning;
	}
	// SUV Recovery (Offset 10)
	if (p || (dis_param->safety.voltage.SUV_Recovery != param->safety.voltage.SUV_Recovery))
	{
		sprintf((char *)text, "%4d", param->safety.voltage.SUV_Recovery);
		GreenOutXY(x, 10, text);
		dis_param->safety.voltage.SUV_Recovery = param->safety.voltage.SUV_Recovery;
	}
}

void SF1DisplaySoc(uint8_t p)
{
	uint8_t text[20];
	PDEVICE_PARAM param = &device_param;
	PDEVICE_PARAM dis_param = &dis_device_param;
	int x;
	
	x = 74;
	// Low SOC Warning (Offset 0)
	if (p || (dis_param->safety.soc.Low_Soc_Warning != param->safety.soc.Low_Soc_Warning))
	{
		sprintf((char *)text, "%3d", param->safety.soc.Low_Soc_Warning);
		GreenOutXY(x, 12, text);
		dis_param->safety.soc.Low_Soc_Warning = param->safety.soc.Low_Soc_Warning;
	}
	// Low SOC Recovery (Offset 2)
	if (p || (dis_param->safety.soc.Low_Soc_Recovery != param->safety.soc.Low_Soc_Recovery))
	{
		sprintf((char *)text, "%3d", param->safety.soc.Low_Soc_Recovery);
		GreenOutXY(x, 13, text);
		dis_param->safety.soc.Low_Soc_Recovery = param->safety.soc.Low_Soc_Recovery;
	}
}

void SF1DisplayCellVoltageDiff(uint8_t p)
{
	uint8_t text[20];
	PDEVICE_PARAM param = &device_param;
	PDEVICE_PARAM dis_param = &dis_device_param;
	int x;
	
	x = 73;
	// Cell Voltage Diff Threshold (Offset 0)
	if (p || (dis_param->safety.cv_diff.Cell_Voltage_Diff_Threshold != param->safety.cv_diff.Cell_Voltage_Diff_Threshold))
	{
		sprintf((char *)text, "%4d", param->safety.cv_diff.Cell_Voltage_Diff_Threshold);
		GreenOutXY(x, 15, text);
		dis_param->safety.cv_diff.Cell_Voltage_Diff_Threshold = param->safety.cv_diff.Cell_Voltage_Diff_Threshold;
	}
	// Cell Voltage Diff Warning (Offset 2)
	if (p || (dis_param->safety.cv_diff.Cell_Voltage_Diff_Warning != param->safety.cv_diff.Cell_Voltage_Diff_Warning))
	{
		sprintf((char *)text, "%4d", param->safety.cv_diff.Cell_Voltage_Diff_Warning);
		GreenOutXY(x, 16, text);
		dis_param->safety.cv_diff.Cell_Voltage_Diff_Warning = param->safety.cv_diff.Cell_Voltage_Diff_Warning;
	}
	// Cell Voltage Diff Recovery (Offset 4)
	if (p || (dis_param->safety.cv_diff.Cell_Voltage_Diff_Recovery != param->safety.cv_diff.Cell_Voltage_Diff_Recovery))
	{
		sprintf((char *)text, "%4d", param->safety.cv_diff.Cell_Voltage_Diff_Recovery);
		GreenOutXY(x, 17, text);
		dis_param->safety.cv_diff.Cell_Voltage_Diff_Recovery = param->safety.cv_diff.Cell_Voltage_Diff_Recovery;
	}
}

void SF1DisplayThermistorOpen(uint8_t p)
{
	PDEVICE_PARAM param = &device_param;
	PDEVICE_PARAM dis_param = &dis_device_param;
	int x;
	
	x = 72;
	// Open Thermistor (Offset 0)
	if (p || (dis_param->safety.temperature.Open_Thermistor != param->safety.temperature.Open_Thermistor))
	{
		FloatNormalOutIntXY(x, 19, (float)param->safety.temperature.Open_Thermistor / 10, 5, 1);
		dis_param->safety.temperature.Open_Thermistor = param->safety.temperature.Open_Thermistor;
	}
	// Recovery Thermistor (Offset 2)
	if (p || (dis_param->safety.temperature.Recovery_Thermistor != param->safety.temperature.Recovery_Thermistor))
	{
		FloatNormalOutIntXY(x, 20, (float)param->safety.temperature.Recovery_Thermistor / 10, 5, 1);
		dis_param->safety.temperature.Recovery_Thermistor = param->safety.temperature.Recovery_Thermistor;
	}
}

void SF1Display(uint8_t p)
{
	SF1DisplayCellVoltage(p);
	SF1DisplayCurrent(p);
	SF1DisplayTemperature(p);
	SF1DisplaySVoltage(p);
	SF1DisplaySoc(p);
	SF1DisplayCellVoltageDiff(p);
	SF1DisplayThermistorOpen(p);
}

uint8_t SetSF1_Param(uint8_t *text, uint8_t aDevice)
{
	uint16_t size, i, j;
	int16_t aParam[4];
	uint8_t temp[10];
	uint8_t ret;
	uint8_t cmd;

	ret = 0;
	size = 0;

	while (text[size] != 0x00) size++;              /* Measure total string length */

	switch (aDevice) 
	{
		case '1':		// SF1_VoltageSubClass
			i = 0;
			if (size < 2 ) return(1);

			j = FIND_CHAR((uint8_t *)&text[i], temp, size - i, ' ');            
			i = i + j + 1;                                                    
			temp[j] = 0x00;
					cmd = temp[0];
					
			j = FIND_CHAR((uint8_t *)&text[i], temp, size - i, ' ');            
			i = i + j + 1;                                                    
			temp[j] = 0x00;
			aParam[0] = StrToInt(temp, j);                              /* Value */
        
			switch (cmd)
			{
				case '1': device_param.safety.voltage.COV_Threshold = aParam[0];  break;
				case '2': device_param.safety.voltage.COV_Warning   = aParam[0];  break;
				case '3': device_param.safety.voltage.COV_Recovery  = aParam[0];  break;
				case '4': device_param.safety.voltage.CUV_Threshold = aParam[0];  break;
				case '5': device_param.safety.voltage.CUV_Warning   = aParam[0];  break;
				case '6': device_param.safety.voltage.CUV_Recovery  = aParam[0];  break;
				default : return (1);
			}
			Save_Param();
			break;
		case '2':		// SF1_CurrentSubClass
			i = 0;
			if (size < 2 ) return(1);

			j = FIND_CHAR((uint8_t *)&text[i], temp, size - i, ' ');            
			i = i + j + 1;                                                    
			temp[j] = 0x00;
			cmd = temp[0];
					
			j = FIND_CHAR((uint8_t *)&text[i], temp, size - i, ' ');            
			i = i + j + 1;                                                    
			temp[j] = 0x00;
			aParam[0] = StrToInt(temp, j);                              /* Value */

			switch (cmd)
			{
				case '1': device_param.safety.current.OC_Chg_Threshold = aParam[0]; break;
				case '2': device_param.safety.current.OC_Chg_Warning   = aParam[0]; break;
				case '3': device_param.safety.current.OC_Chg_Recovery  = aParam[0]; break;
				case '4': device_param.safety.current.OC_Chg_Rec_Time  = aParam[0]; break;
				case '5': device_param.safety.current.OC_Dsg_Threshold = aParam[0]; break;
				case '6': device_param.safety.current.OC_Dsg_Warning   = aParam[0]; break;
				case '7': device_param.safety.current.OC_Dsg_Recovery  = aParam[0]; break;
				case '8': device_param.safety.current.OC_Chg_Rec_Time  = aParam[0]; break;
				default : return (1);
			}
			Save_Param();
			break;
		case '3':		// SF1_TemperatureSubClass
			i = 0;
			if (size < 2 ) return(1);

			j = FIND_CHAR((uint8_t *)&text[i], temp, size - i, ' ');            
			i = i + j + 1;                                                    
			temp[j] = 0x00;
			cmd = temp[0];
					
			j = FIND_CHAR((uint8_t *)&text[i], temp, size - i, ' ');            
			i = i + j + 1;                                                    
			temp[j] = 0x00;
			aParam[0] = StrToInt(temp, j);                              /* Value */
        
			switch (cmd)
			{
				case '1': device_param.safety.temperature.OT_Chg_Threshold = aParam[0];  break;
				case '2': device_param.safety.temperature.OT_Chg_Warning   = aParam[0];  break;
				case '3': device_param.safety.temperature.OT_Chg_Recovery  = aParam[0];  break;
				case '4': device_param.safety.temperature.OT_Dsg_Threshold = aParam[0];  break;
				case '5': device_param.safety.temperature.OT_Dsg_Warning   = aParam[0];  break;
				case '6': device_param.safety.temperature.OT_Dsg_Recovery  = aParam[0];  break;
				
				case '7': device_param.safety.temperature.LT_Chg_Threshold = aParam[0];  break;
				case '8': device_param.safety.temperature.LT_Chg_Warning   = aParam[0];  break;
				case '9': device_param.safety.temperature.LT_Chg_Recovery  = aParam[0];  break;
				case 'a': device_param.safety.temperature.LT_Dsg_Threshold = aParam[0];  break;
				case 'b': device_param.safety.temperature.LT_Dsg_Warning   = aParam[0];  break;
				case 'c': device_param.safety.temperature.LT_Dsg_Recovery  = aParam[0];  break;
				default : return (1);
			}
			Save_Param();
			break;
		case '4':		// SF1_SVoltageSubClass
			i = 0;
			if (size < 2 ) return(1);

			j = FIND_CHAR((uint8_t *)&text[i], temp, size - i, ' ');            
			i = i + j + 1;                                                    
			temp[j] = 0x00;
					cmd = temp[0];
					
			j = FIND_CHAR((uint8_t *)&text[i], temp, size - i, ' ');            
			i = i + j + 1;                                                    
			temp[j] = 0x00;
			aParam[0] = StrToInt(temp, j);                              /* Value */
        
			switch (cmd)
			{
				case '1': device_param.safety.voltage.SOV_Threshold = aParam[0];  break;
				case '2': device_param.safety.voltage.SOV_Warning   = aParam[0];  break;
				case '3': device_param.safety.voltage.SOV_Recovery  = aParam[0];  break;
				case '4': device_param.safety.voltage.SUV_Threshold = aParam[0];  break;
				case '5': device_param.safety.voltage.SUV_Warning   = aParam[0];  break;
				case '6': device_param.safety.voltage.SUV_Recovery  = aParam[0];  break;
				default : return (1);
			}
			Save_Param();
			break;
		case '5':		// SF1_SocSubClass
			i = 0;
			if (size < 2 ) return(1);

			j = FIND_CHAR((uint8_t *)&text[i], temp, size - i, ' ');            
			i = i + j + 1;                                                    
			temp[j] = 0x00;
					cmd = temp[0];
					
			j = FIND_CHAR((uint8_t *)&text[i], temp, size - i, ' ');            
			i = i + j + 1;                                                    
			temp[j] = 0x00;
			aParam[0] = StrToInt(temp, j);                              /* Value */
					
			switch (cmd)
			{
				case '1': device_param.safety.soc.Low_Soc_Warning  = aParam[0];  break;
				case '2': device_param.safety.soc.Low_Soc_Recovery = aParam[0];  break;
				default : return (1);
			}
			Save_Param();
			break;
		case '6':		// SF1_SocSubClass
			i = 0;
			if (size < 2 ) return(1);

			j = FIND_CHAR((uint8_t *)&text[i], temp, size - i, ' ');            
			i = i + j + 1;                                                    
			temp[j] = 0x00;
					cmd = temp[0];
					
			j = FIND_CHAR((uint8_t *)&text[i], temp, size - i, ' ');            
			i = i + j + 1;                                                    
			temp[j] = 0x00;
			aParam[0] = StrToInt(temp, j);                              /* Value */
					
			switch (cmd)
			{
				case '1': device_param.safety.cv_diff.Cell_Voltage_Diff_Threshold = aParam[0];  break;
				case '2': device_param.safety.cv_diff.Cell_Voltage_Diff_Warning   = aParam[0];  break;
				case '3': device_param.safety.cv_diff.Cell_Voltage_Diff_Recovery  = aParam[0];  break;
				case '4': device_param.safety.cv_diff.Cell_Voltage_Diff_Time      = aParam[0];  break;
				default : return (1);
			}
			Save_Param();
			break;
		case '7':		// SF1_OpenThermistorSubClass
			i = 0;
			if (size < 2 ) return(1);

			j = FIND_CHAR((uint8_t *)&text[i], temp, size - i, ' ');            
			i = i + j + 1;                                                    
			temp[j] = 0x00;
					cmd = temp[0];
					
			j = FIND_CHAR((uint8_t *)&text[i], temp, size - i, ' ');            
			i = i + j + 1;                                                    
			temp[j] = 0x00;
			aParam[0] = StrToInt(temp, j);                              /* Value */
					
			switch (cmd)
			{
				case '1': device_param.safety.temperature.Open_Thermistor  = aParam[0];  break;
				case '2': device_param.safety.temperature.Recovery_Thermistor = aParam[0];  break;
				default : return (1);
			}
			Save_Param();
			break;
		default:
			ret = 1;
			break;
	}
return(ret);                /* Setting value OK */
}

#endif //#ifdef CONSOLE_DEBUG

void SF1_InitData(void)
{
	device_param.safety.voltage.COV_Threshold      			= 3850;		// mV
	device_param.safety.voltage.COV_Warning      				= 3750;		// mV
	device_param.safety.voltage.COV_Recovery       			= 3580;		// mV
	device_param.safety.voltage.CUV_Threshold         	= 1000;		// mV
	device_param.safety.voltage.CUV_Warning         		= 2800;		// mV
	device_param.safety.voltage.CUV_Recovery          	= 3000;		// mV

	device_param.safety.voltage.SOV_Threshold      			= 5700;		// 10mV
	device_param.safety.voltage.SOV_Warning      				= 5600;		// 10mV
	device_param.safety.voltage.SOV_Recovery       			= 5400;		// 10mV
	device_param.safety.voltage.SUV_Threshold        		= 2000;		// 10mV
	device_param.safety.voltage.SUV_Warning         		= 4200;		// 10mV
	device_param.safety.voltage.SUV_Recovery          	= 4500;		// 10mV

	device_param.safety.current.OC_Chg_Threshold      	= 110;			// A
	device_param.safety.current.OC_Chg_Warning      		= 100;			// A
	device_param.safety.current.OC_Chg_Recovery       	= 10;			// A
	device_param.safety.current.OC_Chg_Rec_Time       	= 30;			// Sec

	device_param.safety.current.OC_Dsg_Threshold      	= -500;		// A
	device_param.safety.current.OC_Dsg_Warning      		= -310;		// A
	device_param.safety.current.OC_Dsg_Recovery       	= -5;			// A
	device_param.safety.current.OC_Dsg_Rec_Time       	= 30;			// A

	device_param.safety.temperature.OT_Chg_Threshold  	= 550;		// 0.1C 
	device_param.safety.temperature.OT_Chg_Warning  		= 500;		// 0.1C
	device_param.safety.temperature.OT_Chg_Recovery   	= 450;		// 0.1C
	device_param.safety.temperature.OT_Dsg_Threshold  	= 900;		// 0.1C
	device_param.safety.temperature.OT_Dsg_Warning    	= 600;		// 0.1C
	device_param.safety.temperature.OT_Dsg_Recovery   	= 550;		// 0.1C

	device_param.safety.temperature.LT_Chg_Threshold  	= 0;			// 0.1C
	device_param.safety.temperature.LT_Chg_Warning    	= 30;			// 0.1C
	device_param.safety.temperature.LT_Chg_Recovery   	= 50;			// 0.1C
	device_param.safety.temperature.LT_Dsg_Threshold  	= -500;		// 0.1C
	device_param.safety.temperature.LT_Dsg_Warning    	= -150;		// 0.1C
	device_param.safety.temperature.LT_Dsg_Recovery   	= -100;		// 0.1C
	
	device_param.safety.temperature.Open_Thermistor			= -420;		// 0.1C
	device_param.safety.temperature.Recovery_Thermistor	= -380;		// 0.1C

	device_param.safety.soc.Low_Soc_Warning							= 3;			// %
	device_param.safety.soc.Low_Soc_Recovery						= 5;			// %
	
	device_param.safety.cv_diff.Cell_Voltage_Diff_Threshold = 200;			// mV (KT spec: 200mV)
	device_param.safety.cv_diff.Cell_Voltage_Diff_Warning   = 0;			// Unused
	device_param.safety.cv_diff.Cell_Voltage_Diff_Recovery  = 0;			// Unused
	Set_CV_Diff_ProtectHoldTime(0);
	Set_Temp_Diff_Threshold(0);
	Set_Temp_Diff_ProtectHoldTime(0);
// KT Requirement: Configure CV_Diff_ProtectHoldTime for testing (sec -> ms, 0 means 24h default)
}

/*******************(C)COPYRIGHT 2022 AMG ********************END OF FILE******/