/*==================================================================================================

FILE INFORMATION HEADER

USED IN PROJECT:			S1003065-01 PPS-TX/S1003067-01 PPS-RX software application
ITEM TYPE:					Source Code
ITEM NAME:					xlru_lcu.cpp
ITEM DESCRIPTION:			This file contains the implementation of the class e and the interfaces for the LCU / REP connection
TARGET:						ATSAM4LC8B / ATSAM4LS8B
DOC REFERENCES:				SWDS1003065-01/SWDS1003065-01
PROGRAMMER NAME(S):			A.Chessa, L.Vallongo
COPYRIGHT:					LEONARDO-FINMECCANICA S.p.A
REVISION HISTORY:
- 01.00: first release

====================================================================================================
© Copyright LEONARDO S.p.A.. All rights reserved
Any right of industrial and intellectual property on this document,
and of technical Know-how herein contained, belongs to
LEONARDO S.p.A. and/or third parties.
According to the law, it is forbidden to disclose, reproduce or however
use this document and any data herein contained for any use without
previous written authorization by LEONARDO S.p.A.
==================================================================================================*/

/**************************** INCLUDE ****************************************/
#include <string.h>
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include "xlru_lcu.h"
#include "xlru_message_def.h"
#include "xlru_common_func.h"
#include "xlru_bytes_def.h"

using namespace xlru;

//GENERAL DECLARATION

char rx_buffer[BUFFER_DIM];		//bytes buffer to store input

char tx_buffer[BUFFER_DIM];		//bytes buffer to store output

/*header received */

uint8_t LCU_Mode_Status = LCUPowerUp;
uint8_t LCU_BIT_Progress = LCUIBITnotInProgress;
uint8_t LCU_Bypass_Status = LCUByPassNotActive;
uint8_t LCU_Health_Status = LCUHealthGo;
uint8_t LCU_Hazard_Status = LCUNoHazard;
//uint8_t LCU_Status_byte[5] = {0, 0, 0, 0, 0};

uint32_t previous_time = 0;
uint32_t error_link = 0;

//*** STATIC
xlru_lcu::xlru_lcu_command_t xlru_lcu::xlru_lcu_command;
xlru_lcu::xlru_lcu_status_t xlru_lcu::xlru_lcu_status;
xlru_counter_t xlru_lcu::xlru_counter;

char xlru_lcu::xlru_lcu_fcs_prev = 'p';


/**************************** MACRO DEFINITIONS ******************************/

void xlru_lcu::lcu_header_master(void)
{
	//SOM
	tx_buffer[0] = SOM;

	//DSTID
	tx_buffer[1] = DSTID_LCU;

	// FCS
	char fcs_temp = ((xlru_lcu::xlru_lcu_fcs_prev%16)+'a');
	tx_buffer[FCS_INDEX] = fcs_temp;
	xlru_lcu::xlru_lcu_fcs_prev = fcs_temp;

	tx_buffer[ACK_INDEX] = XGET;
}

//****************************************************
// MASTER - from EIF TO LCU - SET MESSAGE - LCU Operative Control Msg

void xlru_lcu::lcu_set_message_payload_master(void)
{
	tx_buffer[4] = LCU_CONTROL_MSG;				//"L", LCU Operative Control Msg

	if (xlru_lcu::xlru_lcu_command.ibit==1)
		tx_buffer[5] = LCU_TEST;				// LCU_TEST "T"
	else
		tx_buffer[5] = LCU_NO_TEST;				// LCU_NO_TEST "_"

	if (xlru_lcu::xlru_lcu_command.heater==1)
		tx_buffer[6] = LCU_HEATER_ON;			//"H", heater on
	else
		tx_buffer[6] = LCU_NO_HEATER;			//"_", no heater

	if (xlru_lcu::xlru_lcu_command.restart==1)
		tx_buffer[7] = LCU_RESTART;				//"R", no restart
	else
		tx_buffer[7] = LCU_NO_RESTART;			//"_", no restart

    tx_buffer[8] = STATUS_SPARE;
    tx_buffer[9] = STATUS_SPARE;
	tx_buffer[10] = 0;

	char checksum[2] = {0};
	calc_checksum(checksum, tx_buffer);
	tx_buffer[10] = checksum[0];
	tx_buffer[11] = checksum[1];

	tx_buffer[12]= CR_EOM;
	tx_buffer[13]= 0;
}

char* xlru_lcu::lcu_set_message_master(void)
{
	memset(tx_buffer, 0, sizeof(tx_buffer));
	lcu_header_master();
	lcu_set_message_payload_master();
	return tx_buffer;
}

//****************************************************
// MASTER - from EIF TO LCU - GET MESSAGE

void xlru_lcu::lcu_get_message_payload_master(void)
{
	tx_buffer[4] = LCU_GET_MESSAGE;			//"S", LCU General Status Message
	tx_buffer[5] = 0;

	char checksum[2] = {0};
	calc_checksum(checksum, tx_buffer);
	tx_buffer[5] = checksum[0];
	tx_buffer[6] = checksum[1];

	//snprintf(&tx_buffer[5], 3, "%02x", get_checksum(tx_buffer));
	tx_buffer[7]= CR_EOM;
	tx_buffer[8]= 0;
}

char* xlru_lcu::lcu_get_message_master(void)
{
	lcu_header_master();
	lcu_get_message_payload_master();
	return tx_buffer;
}

void xlru_lcu::init(void)
{
	//xlru_lcu::xlru_lcu_status.status.commStatus.commDeviceOk = false;
	//xlru_lcu::xlru_lcu_status.status.commStatus.linkUp = false;
	//xlru_lcu::xlru_lcu_status.status.basicStatus.overtempHazard = false;
	//xlru_lcu::xlru_lcu_status.status.basicStatus.overtempWarning = false;
	//xlru_lcu::xlru_lcu_status.status.basicStatus.unitOk = false;

	xlru_lcu::set_lcu_heater(DEF_HEATER);
	xlru_lcu::set_lcu_ibit(DEF_IBIT);
	xlru_lcu::set_lcu_restart(DEF_RESTART);
}

//***********************************************************************************
void xlru_lcu::lcu_reset_buffer_TX_RX(void)
{
	memset(tx_buffer, 0, sizeof(tx_buffer));
	memset(rx_buffer, 0, sizeof(rx_buffer));
}

char * xlru_lcu::lcu_getStringTx(void)
{
	return tx_buffer;
}

char * xlru_lcu::lcu_getStringRx(void)
{
	return rx_buffer;
}

void xlru_lcu::lcu_setStringTx(char *txt)
{
	strcpy(tx_buffer, txt);
}

void xlru_lcu::lcu_setStringRx(char *txt)
{
	strcpy(rx_buffer, txt);
}

//Decode rx message and fill xlru_lcu_status
//return
//			0		no error
//			1
int xlru_lcu::xlru_lcu_command_message_decoder(char* buffer)
{
	//xlru_lcu::xlru_lcu_status.status.commStatus.commDeviceOk = true;
	//xlru_lcu::xlru_lcu_status.status.commStatus.linkUp = true;

	char tmp = 0;
	int value = 0;
	int error = DECODE_NO_ERROR;
	bool ok = false;

	//check message's len, if it is too short, return error
	int len = strlen(buffer);

	//!3a-t_i_G__001281__		example test status message

	if (len<LCU_STATUS_ETI_INDEX) //LCU_CTRL_BOARD_RELEASE_INDEX)
	{
		error = DECODE_TOO_SHORT;
		return error;	//message is too short
	}

	memset( &xlru_lcu::xlru_lcu_status, 0, sizeof( xlru_lcu::xlru_lcu_status ) );


	//MODE STATUS
	tmp = buffer[LCU_MODE_STATUS_INDEX];
	switch(tmp)
	{
		case LCU_POWER_UP:
			xlru_lcu::xlru_lcu_status.mode_status = LCUPowerUp;
			break;
		case LCU_ON_GO:
			xlru_lcu::xlru_lcu_status.mode_status = LCUOnGo;
			break;
		case LCU_I_BIT:
			xlru_lcu::xlru_lcu_status.mode_status = LCUIBIT;
			break;
		case LCU_RESERVED:
			xlru_lcu::xlru_lcu_status.mode_status = LCUreserved;
			break;
		default:
			error++;	//char not correct
			break;
	}

	//IBIT
	tmp = buffer[LCU_BIT_PROGRESS_INDEX];
	switch(tmp)
	{
		case LCU_I_BIT_NOT_IN_PROGRESS:
			xlru_lcu::xlru_lcu_status.bit_progress = LCUIBITnotInProgress;
			break;
		case LCU_I_BIT_COMPLETED:
			xlru_lcu::xlru_lcu_status.bit_progress = LCUIBITcompelted;
			break;
		case LCU_I_BIT_NEVER_EXECUTED:
			xlru_lcu::xlru_lcu_status.bit_progress = LCUIBITneverExecuted;
			break;
		default:
			error++;	//char not correct
			break;
	}

	//BYPASS
	tmp = buffer[LCU_BYPASS_INDEX];
	switch(tmp)
	{
		case LCU_NOT_ACTIVE:
			xlru_lcu::xlru_lcu_status.byPass_status = LCUByPassNotActive;
			break;
		case LCU_BY_PASS_ACTIVE:
			xlru_lcu::xlru_lcu_status.byPass_status = LCUByPassActive;
			break;
		default:
			error++;	//char not correct
			break;
	}

	//HEATH STATUS
	tmp = buffer[LCU_HEALTH_STATUS_INDEX];
	switch(tmp)
	{
		case LCU_GO:
			xlru_lcu::xlru_lcu_status.health_status = LCUHealthGo;
			break;
		case LCU_WARNING:
			xlru_lcu::xlru_lcu_status.health_status = LCUHealthWarning;
			break;
		case LCU_FAIL:
			xlru_lcu::xlru_lcu_status.health_status = LCUHealthFail;
			break;
		default:
			error++;	//char not correct
			break;
	}

	//HAZARD STATUS
	tmp = buffer[LCU_HAZARD_STATUS_INDEX];
	switch(tmp)
	{
		case LCU_WARNING:
			xlru_lcu::xlru_lcu_status.hazard_status = LCUWarning;
			break;
		case LCU_NO_HAZARD:
			xlru_lcu::xlru_lcu_status.hazard_status = LCUNoHazard;
			break;
		case LCU_HAZARD_1:
			xlru_lcu::xlru_lcu_status.hazard_status = LCUHazard1;
			break;
		case LCU_HAZARD_2:
			xlru_lcu::xlru_lcu_status.hazard_status = LCUHazard2;
			break;
		default:
			error++;	//char not correct
			break;
	}

    //OVERRIDE STATUS
    tmp = buffer[LCU_OVERRIDE_INDEX];
    switch(tmp)
    {
        case LCU_OVERRIDE:
            xlru_lcu::xlru_lcu_status.override_status = LCUOverride;
            break;
        case LCU_NO_OVERRIDE:
            xlru_lcu::xlru_lcu_status.override_status = LCUNoOverride;
            break;
        default:
            error++;	//char not correct
            break;
    }


	if (buffer[4]=='t' || buffer[4]=='T')
	{
        error = 0;
		//LCU_STATUS_ETI_INDEX

		//test status message
		/*char tmp6[7] = { 0 };
		tmp6[0] = buffer[LCU_STATUS_ETI_INDEX];
		tmp6[1] = buffer[LCU_STATUS_ETI_INDEX+1];
		tmp6[2] = buffer[LCU_STATUS_ETI_INDEX+2];
		tmp6[3] = buffer[LCU_STATUS_ETI_INDEX+3];
		tmp6[4] = buffer[LCU_STATUS_ETI_INDEX+4];
		tmp6[5] = buffer[LCU_STATUS_ETI_INDEX+5];

		//valuel = strtol(&tmp6[0], &end, 16);
		*/

		int valuel = 0;
        ok=xlru::hex2u48(&valuel , &buffer[LCU_STATUS_ETI_INDEX]);
		if (!ok)
			error++;	//problem in decode value;

        xlru_lcu::xlru_lcu_status.ETI = valuel;// * LCU_ETI_LSB;
	}
	else
	{
		//LCU_BIT_STATUS

		//BYTES#1 - General and pressure
		ok=xlru::hex2u8(&value , &buffer[LCU_BYTES1_INDEX]);
		if (!ok)
			error++;	//problem in decode value;

		xlru_lcu::xlru_lcu_status.byte1_general_pressure.b1_phase_A_fail = ((value & Bit_PhaseA_failure) == Bit_PhaseA_failure);
		xlru_lcu::xlru_lcu_status.byte1_general_pressure.b2_phase_B_fail = ((value & Bit_PhaseB_failure) == Bit_PhaseB_failure);
		xlru_lcu::xlru_lcu_status.byte1_general_pressure.b3_phase_C_fail = ((value & Bit_PhaseC_failure) == Bit_PhaseC_failure);
		xlru_lcu::xlru_lcu_status.byte1_general_pressure.b4_phase_sequence_fail = ((value & Bit_Phase_Sequence_failure) == Bit_Phase_Sequence_failure);
		xlru_lcu::xlru_lcu_status.byte1_general_pressure.b7_pressure_sensor_fail = ((value & Bit_Pressure_Sensor_fail) == Bit_Pressure_Sensor_fail);

		//BYTES#2 - ctrl_board
		ok=xlru::hex2u8(&value , &buffer[LCU_BYTES2_INDEX]);
		if (!ok)
			error++;	//problem in decode value;

		xlru_lcu::xlru_lcu_status.byte2_ctrl_board.b1_temperature_hazard = ((value & Bit_Temperature_Hazard) == Bit_Temperature_Hazard);
		xlru_lcu::xlru_lcu_status.byte2_ctrl_board.b2_temperature_warning = ((value & Bit_Temperature_Warning) == Bit_Temperature_Warning);
		xlru_lcu::xlru_lcu_status.byte2_ctrl_board.b3_nvm_access_warning = ((value & Bit_NVM_Access_Warning) == Bit_NVM_Access_Warning);
		xlru_lcu::xlru_lcu_status.byte2_ctrl_board.b4_board_error_fail = ((value & Bit_Board_Error_failure) == Bit_Board_Error_failure);
		xlru_lcu::xlru_lcu_status.byte2_ctrl_board.b5_link_fail = ((value & Bit_Link_failure) == Bit_Link_failure);

		//BYTES#3 - motor_pump
		ok=xlru::hex2u8(&value , &buffer[LCU_BYTES3_INDEX]);
		if (!ok)
			error++;	//problem in decode value;

		xlru_lcu::xlru_lcu_status.byte3_motor_pump.b1_motor_speed_sensor_fail = ((value & Bit_motor_speed_sensor_fail) == Bit_motor_speed_sensor_fail);
		xlru_lcu::xlru_lcu_status.byte3_motor_pump.b2_temperature_hazard = ((value & Bit_motor_temperature_hazard2) == Bit_motor_temperature_hazard2);
		xlru_lcu::xlru_lcu_status.byte3_motor_pump.b3_temperature_warning = ((value & Bit_motor_temperature_hazard) == Bit_motor_temperature_hazard);
		xlru_lcu::xlru_lcu_status.byte3_motor_pump.b4_motor_fail = ((value & Bit_motor_failure) == Bit_motor_failure);
		xlru_lcu::xlru_lcu_status.byte3_motor_pump.b8_motor_temperature_sensor_fail = ((value & Bit_motor_temp_sensor_fail) == Bit_motor_temp_sensor_fail);

		//BYTES#4 - sensor_fails
		ok=xlru::hex2u8(&value , &buffer[LCU_BYTES4_INDEX]);
		if (!ok)
			error++;	//problem in decode value;
		xlru_lcu::xlru_lcu_status.byte4_sensor.b1_inlet_temp_sensor_fail_aesa_ts1 = ((value & Bit_inlet_temp_sensor_fail_AESA_TS1) == Bit_inlet_temp_sensor_fail_AESA_TS1);
		xlru_lcu::xlru_lcu_status.byte4_sensor.b2_inlet_temp_sensor_fail_pps_ts2 = ((value & Bit_inlet_temp_sensor_fail_PPS_TS2) == Bit_inlet_temp_sensor_fail_PPS_TS2);
		xlru_lcu::xlru_lcu_status.byte4_sensor.b3_inlet_temp_sensor_fail_combo_ts3 = ((value & Bit_inlet_temp_sensor_fail_Combo_TS3) == Bit_inlet_temp_sensor_fail_Combo_TS3);
		xlru_lcu::xlru_lcu_status.byte4_sensor.b4_outlet_temp_sensor_fail_ts4 = ((value & Bit_outlet_temp_sensor_fail_TS4) == Bit_outlet_temp_sensor_fail_TS4);
		xlru_lcu::xlru_lcu_status.byte4_sensor.b5_inlet_air_temp_sensor_fail_ts5 = ((value & Bit_inlet_air_temp_sensor_fail_TS5) == Bit_inlet_air_temp_sensor_fail_TS5);
		xlru_lcu::xlru_lcu_status.byte4_sensor.b6_outlet_air_temp_sensor_fail_ts6 = ((value & Bit_outlet_air_temp_sensor_fail_TS6) == Bit_outlet_air_temp_sensor_fail_TS6);
		xlru_lcu::xlru_lcu_status.byte4_sensor.b7_inlet_flow_sensor_aesa_branch_fs1 = ((value & Bit_inlet_flow_sensor_AESA_FS1) == Bit_inlet_flow_sensor_AESA_FS1);
		xlru_lcu::xlru_lcu_status.byte4_sensor.b8_inlet_flow_sensor_pps_branch_fs2 = ((value & Bit_inlet_flow_sensor_PPS_FS2) == Bit_inlet_flow_sensor_PPS_FS2);

		//BYTES#5 - general_fails
		ok=xlru::hex2u8(&value , &buffer[LCU_BYTES5_INDEX]);
		if (!ok)
			error++;	//problem in decode value;
		xlru_lcu::xlru_lcu_status.byte5_general_fails.b1_dirty_filter_he_warn = ((value & Bit_Dirty_filter_HE_warning) == Bit_Dirty_filter_HE_warning);
		xlru_lcu::xlru_lcu_status.byte5_general_fails.b2_dirty_aesa_stream_warn1 = ((value & Bit_Dirty_AESA_Stream_warning) == Bit_Dirty_AESA_Stream_warning);
		xlru_lcu::xlru_lcu_status.byte5_general_fails.b3_dirty_aesa_stream_warn2 = ((value & Bit_Dirty_PPS_Stream_warning) == Bit_Dirty_PPS_Stream_warning);
		xlru_lcu::xlru_lcu_status.byte5_general_fails.b5_dirty_filter_he_failure = ((value & Bit_Dirty_filter_HE_failure) == Bit_Dirty_filter_HE_failure);
		xlru_lcu::xlru_lcu_status.byte5_general_fails.b6_dirty_aesa_stream_fail1 = ((value & Bit_Dirty_AESA_stream_failure) == Bit_Dirty_AESA_stream_failure);
		xlru_lcu::xlru_lcu_status.byte5_general_fails.b7_dirty_aesa_stream_fail2 = ((value & Bit_Dirty_PPS_stream_failure) == Bit_Dirty_PPS_stream_failure);
		xlru_lcu::xlru_lcu_status.byte5_general_fails.b8_by_pass_fail = ((value & Bit_By_Pass_failure) == Bit_By_Pass_failure);

		//LCU_CTRL_BOARD_TEMP
		ok=xlru::hex2s8(&xlru_lcu::xlru_lcu_status.ctrl_board_temp , &buffer[LCU_CTRL_BOARD_TEMP_INDEX]);
		if (!ok)
			error++;	//problem in decode value;

		//LCU_MOTOR_TEMP_INDEX
		ok=xlru::hex2s8(&xlru_lcu::xlru_lcu_status.motor_temp_mts , &buffer[LCU_MOTOR_TEMP_INDEX]);
		if (!ok)
			error++;	//problem in decode value;

		//LCU_MOTOR_VEL_INDEX
        ok=xlru::hex3s8f(&xlru_lcu::xlru_lcu_status.motor_speed_mfs , &buffer[LCU_MOTOR_VEL_INDEX], LCU_MOTOR_VEL_LSB);
        if (!ok)
            error++;	//problem in decode value;

        //LCU_LIQUID_AESA_TEMP_INDEX
        ok=xlru::hex2s8(&xlru_lcu::xlru_lcu_status.liquid_inlet_temp_aesa_ts1 , &buffer[LCU_LIQUID_AESA_TEMP_INDEX]);
        if (!ok)
            error++;	//problem in decode value;

        //LCU_LIQUID_PPS_TEMP_INDEX
        ok=xlru::hex2s8(&xlru_lcu::xlru_lcu_status.liquid_inlet_temp_pps_ts2 , &buffer[LCU_LIQUID_PPS_TEMP_INDEX]);
        if (!ok)
            error++;	//problem in decode value;

        //LCU_LIQUID_PUMP_TEMP_INDEX
        ok=xlru::hex2s8(&xlru_lcu::xlru_lcu_status.liquid_pump_inlet_temp_ts3 , &buffer[LCU_LIQUID_PUMP_TEMP_INDEX]);
        if (!ok)
           error++;	//problem in decode value;

        //LCU_LIQUID_OUTLET_TEMP_INDEX
        ok=xlru::hex2s8(&xlru_lcu::xlru_lcu_status.liquid_outlet_temp_ts4 , &buffer[LCU_LIQUID_OUTLET_TEMP_INDEX]);
        if (!ok)
           error++;	//problem in decode value;

        //LCU_AIR_INLET_TEMP_INDEX
        ok=xlru::hex2s8(&xlru_lcu::xlru_lcu_status.air_inlet_temp_ts5 , &buffer[LCU_AIR_INLET_TEMP_INDEX]);
        if (!ok)
            error++;	//problem in decode value;

        //LCU_AIR_OUTLET_TEMP_INDEX
        ok=xlru::hex2s8(&xlru_lcu::xlru_lcu_status.air_outlet_temp_ts6 , &buffer[LCU_AIR_OUTLET_TEMP_INDEX]);
        if (!ok)
            error++;	//problem in decode value;

        //LCU_LIQUID_AESA_INDEX
        ok=xlru::hex2u8(&xlru_lcu::xlru_lcu_status.liquid_inlet_flow_aesa_fs1 , &buffer[LCU_LIQUID_AESA_INDEX]);
        if (!ok)
            error++;	//problem in decode value;

        //LCU_LIQUID_PPS_INDEX
        ok=xlru::hex2u8(&xlru_lcu::xlru_lcu_status.liquid_inlet_flow_pps_fs2 , &buffer[LCU_LIQUID_PPS_INDEX]);
        if (!ok)
            error++;	//problem in decode value;

        //LCU_LIQUID_OUTLET_PRESSURE_INDEX
        ok=xlru::hex3u8f(&xlru_lcu::xlru_lcu_status.liquid_outlet_pressure_ps , &buffer[LCU_LIQUID_OUTLET_PRESSURE_INDEX], LCU_LIQUID_OUTLET_PRESSURE_LSB);
		if (!ok)
			error++;	//problem in decode value;

		//LCU_CTRL_BOARD_VERSION_INDEX
		ok=xlru::hex2u8(&xlru_lcu::xlru_lcu_status.crtl_board_version, &buffer[LCU_CTRL_BOARD_VERSION_INDEX]);
		if (!ok)
			error++;	//problem in decode value;

		//LCU_CTRL_BOARD_RELEASE_INDEX
		ok=xlru::hex2u8(&xlru_lcu::xlru_lcu_status.crtl_board_release, &buffer[LCU_CTRL_BOARD_RELEASE_INDEX]);
		if (!ok)
			error++;	//problem in decode value;
	}

	xlru_lcu::xlru_lcu_status.status.unitOk=xlru_lcu::xlru_lcu_status.health_status==LCUHealthGo;

	switch(xlru_lcu::xlru_lcu_status.hazard_status)
	{
			case LCUNoHazard:
				xlru_lcu::xlru_lcu_status.status.overtempWarning=false;
				xlru_lcu::xlru_lcu_status.status.overtempHazard=false;
				break;
			case LCUWarning:
				xlru_lcu::xlru_lcu_status.status.overtempWarning=true;
				xlru_lcu::xlru_lcu_status.status.overtempHazard=false;
				break;
			default:
				xlru_lcu::xlru_lcu_status.status.overtempHazard=true;
				xlru_lcu::xlru_lcu_status.status.overtempWarning=true;

			}

	return error;
}

unsigned int xlru_lcu::get_lcu_ibit()
{
	return xlru_lcu::xlru_lcu_command.ibit;
}

unsigned int xlru_lcu::get_lcu_heater()
{
	return xlru_lcu::xlru_lcu_command.heater;
}

unsigned int xlru_lcu::get_lcu_restart()
{
	return xlru_lcu::xlru_lcu_command.restart;
}

void xlru_lcu::set_lcu_ibit(bool enable)
{
	xlru_lcu::xlru_lcu_command.ibit = enable;
}

void xlru_lcu::set_lcu_heater(bool enable)
{
	xlru_lcu::xlru_lcu_command.heater = enable;
}

void xlru_lcu::set_lcu_restart(bool enable)
{
	xlru_lcu::xlru_lcu_command.restart = enable;
}


void xlru_lcu::xlru_display(int (*print_func)(const char*, ...))
{

	print_func("\n     -> Info from LCU <-\n");

	print_func("     %-35s: %d.%d\n","board version.release", xlru_lcu::xlru_lcu_status.crtl_board_version, xlru_lcu_status.crtl_board_release);

	print_func("     %-35s: %c\n","status mode", xlru_lcu::xlru_lcu_status.mode_status);
	print_func("     %-35s: %c\n","bit progress",xlru_lcu::xlru_lcu_status.bit_progress);
	print_func("     %-35s: %c\n","by-pass status",xlru_lcu::xlru_lcu_status.byPass_status);
	print_func("     %-35s: %c\n","health status",xlru_lcu::xlru_lcu_status.health_status);
	print_func("     %-35s: %c\n","hazard status",xlru_lcu::xlru_lcu_status.hazard_status);
    print_func("     %-35s: %c\n","Override status",xlru_lcu::xlru_lcu_status.override_status);

	print_func("     %-35s: %-4d    %-35s: %-4d\n",
			"board temp.",
			xlru_lcu::xlru_lcu_status.ctrl_board_temp,
			"liquid outlet temp TS4",
			xlru_lcu::xlru_lcu_status.liquid_outlet_temp_ts4);

	print_func("     %-35s: %-4d    %-35s: %-4d\n",
			"motor temp. MTS",
			xlru_lcu::xlru_lcu_status.motor_temp_mts,
			"air inlet temp TS5",
			xlru_lcu::xlru_lcu_status.air_inlet_temp_ts5);

	print_func("     %-35s: %-4.1f    %-35s: %-4d\n",
			"motor speed MFS (rpm)",
			xlru_lcu::xlru_lcu_status.motor_speed_mfs,
			"air outlet temp TS6",
			xlru_lcu::xlru_lcu_status.air_outlet_temp_ts6);

	print_func("     %-35s: %-4d    %-35s: %-4d\n",
			"liquid inlet temp aesa TS1",
			xlru_lcu::xlru_lcu_status.liquid_inlet_temp_aesa_ts1,
			"liquid inlet flow aesa FS1 (g/s)",
			xlru_lcu::xlru_lcu_status.liquid_inlet_flow_aesa_fs1);

	print_func("     %-35s: %-4d    %-35s: %-4d\n",
			"liquid inlet temp pps TS2",
			xlru_lcu::xlru_lcu_status.liquid_inlet_temp_pps_ts2,
			"liquid inlet flow pps FS2 (g/s)",
			xlru_lcu::xlru_lcu_status.liquid_inlet_flow_pps_fs2);

	print_func("     %-35s: %-4d    %-35s: %-2.2f\n\n",
			"liquid pump inlet temp TS3",
			xlru_lcu::xlru_lcu_status.liquid_pump_inlet_temp_ts3,
			"liquid outlet pressure PS (psi)",
			xlru_lcu::xlru_lcu_status.liquid_outlet_pressure_ps);

	print_func("\n     -> general/pressure (byte1 status) <-        -> ctrl board (byte2 status) <-\n");

	print_func("bit1 %-35s: %-4d    %-35s: %-4d\n",
			"phase A failure",
			xlru_lcu::xlru_lcu_status.byte1_general_pressure.b1_phase_A_fail,
			"temperature hazard",
			xlru_lcu::xlru_lcu_status.byte2_ctrl_board.b1_temperature_hazard);

	print_func("bit2 %-35s: %-4d    %-35s: %-4d\n",
			"phase B failure",
			xlru_lcu::xlru_lcu_status.byte1_general_pressure.b2_phase_B_fail,
			"temperature warning",
			xlru_lcu::xlru_lcu_status.byte2_ctrl_board.b2_temperature_warning);

	print_func("bit3 %-35s: %-4d    %-35s: %-4d\n",
			"phase C failure",
			xlru_lcu::xlru_lcu_status.byte1_general_pressure.b3_phase_C_fail,
			"nvm access warning",
			xlru_lcu::xlru_lcu_status.byte2_ctrl_board.b3_nvm_access_warning);

	print_func("bit4 %-35s: %-4d    %-35s: %-4d\n",
			"phase sequence failure",
			xlru_lcu::xlru_lcu_status.byte1_general_pressure.b4_phase_sequence_fail,
			"board error failure",
			xlru_lcu::xlru_lcu_status.byte2_ctrl_board.b4_board_error_fail);

	print_func("bit5 %-35s: %-4d    %-35s: %-4d\n",
			"",
			0,
			"link failure",
			xlru_lcu::xlru_lcu_status.byte2_ctrl_board.b5_link_fail);

	print_func("bit6 %-35s: %-4d    \n","",0);
	print_func("bit7 %-35s: %-4d    \n","pressure sensor failure (PS)",xlru_lcu::xlru_lcu_status.byte1_general_pressure.b7_pressure_sensor_fail);
	print_func("bit8 %-35s: %-4d    \n","",0);

	print_func("\n     -> motor pump (byte3 status) <-        	  -> sensor (byte4 status) <-\n");
	print_func("bit1 %-35s: %-4d    %-35s: %-4d\n","motor speed sensor failure",xlru_lcu::xlru_lcu_status.byte3_motor_pump.b1_motor_speed_sensor_fail, "inlet temp sensor fail aesa ts1",xlru_lcu::xlru_lcu_status.byte4_sensor.b1_inlet_temp_sensor_fail_aesa_ts1);
	print_func("bit2 %-35s: %-4d    %-35s: %-4d\n","temperature hazard",xlru_lcu::xlru_lcu_status.byte3_motor_pump.b2_temperature_hazard,"inlet temp sensor fail pps ts2",xlru_lcu::xlru_lcu_status.byte4_sensor.b2_inlet_temp_sensor_fail_pps_ts2);
	print_func("bit3 %-35s: %-4d    %-35s: %-4d\n","temperature warning",xlru_lcu::xlru_lcu_status.byte3_motor_pump.b3_temperature_warning,"inlet temp sensor fail combo ts3",xlru_lcu::xlru_lcu_status.byte4_sensor.b3_inlet_temp_sensor_fail_combo_ts3);
	print_func("bit4 %-35s: %-4d    %-35s: %-4d\n","motor failure",xlru_lcu::xlru_lcu_status.byte3_motor_pump.b4_motor_fail, "outlet temp sensor fail ts4",xlru_lcu::xlru_lcu_status.byte4_sensor.b4_outlet_temp_sensor_fail_ts4);
	print_func("bit5 %-35s: %-4d    %-35s: %-4d\n","", 0, "inlet air temp sensor fail ts5",xlru_lcu::xlru_lcu_status.byte4_sensor.b5_inlet_air_temp_sensor_fail_ts5);
	print_func("bit6 %-35s: %-4d    %-35s: %-4d\n","", 0, "outlet air temp sensor fail ts6",xlru_lcu::xlru_lcu_status.byte4_sensor.b6_outlet_air_temp_sensor_fail_ts6);
	print_func("bit7 %-35s: %-4d    %-35s: %-4d\n","", 0, "inlet flow sensor aesa branch fs1",xlru_lcu::xlru_lcu_status.byte4_sensor.b7_inlet_flow_sensor_aesa_branch_fs1);
	print_func("bit8 %-35s: %-4d    %-35s: %-4d\n","motor temperature sensor failure",xlru_lcu::xlru_lcu_status.byte3_motor_pump.b8_motor_temperature_sensor_fail, "inlet flow sensor pps branch fs2",xlru_lcu::xlru_lcu_status.byte4_sensor.b8_inlet_flow_sensor_pps_branch_fs2);

	print_func("\n     -> general failures (byte5 status) <-\n");
	print_func("bit1 %-35s: %d\n","dirty filter he warn",xlru_lcu::xlru_lcu_status.byte5_general_fails.b1_dirty_filter_he_warn);
	print_func("bit2 %-35s: %d\n","dirty aesa stream warn1",xlru_lcu::xlru_lcu_status.byte5_general_fails.b2_dirty_aesa_stream_warn1);
	print_func("bit3 %-35s: %d\n","dirty aesa stream warn2",xlru_lcu::xlru_lcu_status.byte5_general_fails.b3_dirty_aesa_stream_warn2);
	print_func("bit4 %-35s: %d\n","",0);
	print_func("bit5 %-35s: %d\n","dirty filter he failure",xlru_lcu::xlru_lcu_status.byte5_general_fails.b5_dirty_filter_he_failure);
	print_func("bit6 %-35s: %d\n","dirty aesa stream fail1",xlru_lcu::xlru_lcu_status.byte5_general_fails.b6_dirty_aesa_stream_fail1);
	print_func("bit7 %-35s: %d\n","dirty aesa stream fail2",xlru_lcu::xlru_lcu_status.byte5_general_fails.b7_dirty_aesa_stream_fail2);
	print_func("bit8 %-35s: %d\n","by-pass failure",xlru_lcu::xlru_lcu_status.byte5_general_fails.b8_by_pass_fail);

	print_func("\n");

}

void xlru_lcu::xlru_display_compact(int (*print_func)(const char*, ...))
{

	print_func("\n     -> Info from LCU <-\n");

	print_func("     %-10s: %d.%d     %-10s: %-6.2f  \n",
			"ver.rel", xlru_lcu::xlru_lcu_status.crtl_board_version, xlru_lcu_status.crtl_board_release,
			"ETI", xlru_lcu::xlru_lcu_status.ETI);

	print_func("     %-10s: %c       %-10s: %c\n","status", xlru_lcu::xlru_lcu_status.mode_status, "health", xlru_lcu::xlru_lcu_status.health_status);
	print_func("     %-10s: %c       %-10s: %c\n","bit",xlru_lcu::xlru_lcu_status.bit_progress, "hazard", xlru_lcu::xlru_lcu_status.hazard_status);
    print_func("     %-10s: %c       %-10s: %c\n","by-pass",xlru_lcu::xlru_lcu_status.byPass_status, "override", xlru_lcu::xlru_lcu_status.override_status);

	print_func("     %-10s: %-4d    %-10s: %-4d\n","board temp", xlru_lcu::xlru_lcu_status.ctrl_board_temp, "TS4", xlru_lcu::xlru_lcu_status.liquid_outlet_temp_ts4);
	print_func("     %-10s: %-4d    %-10s: %-4d\n","MTS ",xlru_lcu::xlru_lcu_status.motor_temp_mts,"TS5", xlru_lcu::xlru_lcu_status.air_inlet_temp_ts5);
	print_func("     %-10s: %-4.1f    %-10s: %-4d\n","MFS",xlru_lcu::xlru_lcu_status.motor_speed_mfs,"TS6", xlru_lcu::xlru_lcu_status.air_outlet_temp_ts6);
	print_func("     %-10s: %-4d    %-10s: %-4d\n","TS1",xlru_lcu::xlru_lcu_status.liquid_inlet_temp_aesa_ts1,"FS1", xlru_lcu::xlru_lcu_status.liquid_inlet_flow_aesa_fs1);
	print_func("     %-10s: %-4d    %-10s: %-4d\n","TS2",xlru_lcu::xlru_lcu_status.liquid_inlet_temp_pps_ts2,"FS2", xlru_lcu::xlru_lcu_status.liquid_inlet_flow_pps_fs2);
	print_func("     %-10s: %-4d    %-10s: %-2.2f\n\n","TS3",xlru_lcu::xlru_lcu_status.liquid_pump_inlet_temp_ts3, "PS", xlru_lcu::xlru_lcu_status.liquid_outlet_pressure_ps);


	print_func("\nbit     ->  7 6 5 4 3 2 1 0\n");
	print_func("byte%d   ->  %01d %01d %01d %01d %01d %01d %01d %01d\n",
				1,
				0,
				xlru_lcu::xlru_lcu_status.byte1_general_pressure.b7_pressure_sensor_fail,
				0,
				0,
				xlru_lcu::xlru_lcu_status.byte1_general_pressure.b4_phase_sequence_fail,
				xlru_lcu::xlru_lcu_status.byte1_general_pressure.b3_phase_C_fail,
				xlru_lcu::xlru_lcu_status.byte1_general_pressure.b2_phase_B_fail,
				xlru_lcu::xlru_lcu_status.byte1_general_pressure.b1_phase_A_fail);

	print_func("byte%d   ->  %01d %01d %01d %01d %01d %01d %01d %01d\n",
				2,
				0,
				0,
				0,
				xlru_lcu::xlru_lcu_status.byte2_ctrl_board.b5_link_fail,
				xlru_lcu::xlru_lcu_status.byte2_ctrl_board.b4_board_error_fail,
				xlru_lcu::xlru_lcu_status.byte2_ctrl_board.b3_nvm_access_warning,
				xlru_lcu::xlru_lcu_status.byte2_ctrl_board.b2_temperature_warning,
				xlru_lcu::xlru_lcu_status.byte2_ctrl_board.b1_temperature_hazard
				);

	print_func("byte%d   ->  %01d %01d %01d %01d %01d %01d %01d %01d\n",
				3,
				xlru_lcu::xlru_lcu_status.byte3_motor_pump.b8_motor_temperature_sensor_fail,
				0,
				0,
				0,
				xlru_lcu::xlru_lcu_status.byte3_motor_pump.b4_motor_fail,
				xlru_lcu::xlru_lcu_status.byte3_motor_pump.b3_temperature_warning,
				xlru_lcu::xlru_lcu_status.byte3_motor_pump.b2_temperature_hazard,
				xlru_lcu::xlru_lcu_status.byte3_motor_pump.b1_motor_speed_sensor_fail
				);

	print_func("byte%d   ->  %01d %01d %01d %01d %01d %01d %01d %01d\n",
					4,
					xlru_lcu::xlru_lcu_status.byte4_sensor.b8_inlet_flow_sensor_pps_branch_fs2,
					xlru_lcu::xlru_lcu_status.byte4_sensor.b7_inlet_flow_sensor_aesa_branch_fs1,
					xlru_lcu::xlru_lcu_status.byte4_sensor.b6_outlet_air_temp_sensor_fail_ts6,
					xlru_lcu::xlru_lcu_status.byte4_sensor.b5_inlet_air_temp_sensor_fail_ts5,
					xlru_lcu::xlru_lcu_status.byte4_sensor.b4_outlet_temp_sensor_fail_ts4,
					xlru_lcu::xlru_lcu_status.byte4_sensor.b3_inlet_temp_sensor_fail_combo_ts3,
					xlru_lcu::xlru_lcu_status.byte4_sensor.b2_inlet_temp_sensor_fail_pps_ts2,
					xlru_lcu::xlru_lcu_status.byte4_sensor.b1_inlet_temp_sensor_fail_aesa_ts1
					);

	print_func("byte%d   ->  %01d %01d %01d %01d %01d %01d %01d %01d\n",
					5,
					xlru_lcu::xlru_lcu_status.byte5_general_fails.b8_by_pass_fail,
					xlru_lcu::xlru_lcu_status.byte5_general_fails.b7_dirty_aesa_stream_fail2,
					xlru_lcu::xlru_lcu_status.byte5_general_fails.b6_dirty_aesa_stream_fail1,
					xlru_lcu::xlru_lcu_status.byte5_general_fails.b5_dirty_filter_he_failure,
					0,
					xlru_lcu::xlru_lcu_status.byte5_general_fails.b3_dirty_aesa_stream_warn2,
					xlru_lcu::xlru_lcu_status.byte5_general_fails.b2_dirty_aesa_stream_warn1,
					xlru_lcu::xlru_lcu_status.byte5_general_fails.b1_dirty_filter_he_warn
					);

	print_func("\n");

}

void xlru_lcu::xlru_add_error(int n_error)	//error into last decode response message
{
	xlru_lcu::xlru_counter.last_decode_error += n_error;
}

void xlru_lcu::xlru_add_rx(int n_rx)				//response messages
{
	xlru_lcu::xlru_counter.rx_mess+= n_rx;
}

void xlru_lcu::xlru_add_rx_error(int n_error)		//response messages with error
{
	xlru_lcu::xlru_counter.rx_mess_error += n_error;
}

void xlru_lcu::xlru_add_no_rx(int n_error)	//count messages without response
{
	xlru_lcu::xlru_counter.no_response += n_error;
}

void xlru_lcu::xlru_set_last_error(char *last_error)	//report last error
{
	strcpy(xlru_lcu::xlru_counter.last_error, last_error);
}

void xlru_lcu::xlru_set_last_rx(char *last_rx)		//report last received message
{
	strcpy(xlru_lcu::xlru_counter.last_rx, last_rx);
}
void xlru_lcu::xlru_set_last_tx(char *last_tx)		//report last trasmitted message
{
	strcpy(xlru_lcu::xlru_counter.last_tx, last_tx);
}
char* xlru_lcu::xlru_get_last_rx()
{
	return xlru_lcu::xlru_counter.last_rx;
}
char* xlru_lcu::xlru_get_last_tx()
{
	return xlru_lcu::xlru_counter.last_tx;
}
char* xlru_lcu::xlru_get_last_error()
{
	return xlru_lcu::xlru_counter.last_error;
}

void xlru_lcu::lcu_test_status_payload_master(void)
{
	tx_buffer[4] = LCU_GET_TEST_STATUS;			//"T", LCU test status message
    tx_buffer[5] = STATUS_SPARE;

	char checksum[2] = {0};
	calc_checksum(checksum, tx_buffer);
    tx_buffer[6] = checksum[0];
    tx_buffer[7] = checksum[1];

	//snprintf(&tx_buffer[5], 3, "%02x", get_checksum(tx_buffer));
    tx_buffer[8]= CR_EOM;
    tx_buffer[9]= 0;
}

char* xlru_lcu::lcu_set_test_status_master(void)
{
	memset(tx_buffer, 0, sizeof(tx_buffer));
	lcu_header_master();
	lcu_test_status_payload_master();
	return tx_buffer;
}

void xlru_lcu::lcu_reset_eti_payload_master(void)
{
    tx_buffer[4] = LCU_RESET_ETI;			//"R", reset ETI
    tx_buffer[5] = 0;

    char checksum[2] = {0};
    calc_checksum(checksum, tx_buffer);
    tx_buffer[5] = checksum[0];
    tx_buffer[6] = checksum[1];

    //snprintf(&tx_buffer[5], 3, "%02x", get_checksum(tx_buffer));
    tx_buffer[7]= CR_EOM;
    tx_buffer[8]= 0;
}

char* xlru_lcu::lcu_reset_eti_message_master(void)
{
    memset(tx_buffer, 0, sizeof(tx_buffer));
    lcu_header_master();
    lcu_reset_eti_payload_master();
    return tx_buffer;
}

void xlru_lcu::lcu_active_download_payload_master(void)
{
    tx_buffer[4] = LCU_ACTIVE_DOWNLOAD;			//"D", Active Download
    tx_buffer[5] = 'D';			//"D", Active Download
    tx_buffer[6] = 'W';			//"W, Active Download
    tx_buffer[7] = 'N';			//"L", Active Download
    tx_buffer[8] = 'L';			//"N", Active Download
    tx_buffer[9] = 'L';			//"N", Active Download
    tx_buffer[10] = 'C';			//"N", Active Download
    tx_buffer[11] = 'U';			//"N", Active Download

    tx_buffer[12] = STATUS_SPARE;

    char checksum[2] = {0};
    calc_checksum(checksum, tx_buffer);
    tx_buffer[13] = checksum[0];
    tx_buffer[14] = checksum[1];

    //snprintf(&tx_buffer[5], 3, "%02x", get_checksum(tx_buffer));
    tx_buffer[15]= CR_EOM;
    tx_buffer[16]= 0;
}

char* xlru_lcu::lcu_active_download_message_master(void)
{
    memset(tx_buffer, 0, sizeof(tx_buffer));

    //SOM
    //tx_buffer[0] = SOM;

    //DSTID
    //tx_buffer[1] = DSTID_PPS;

    lcu_header_master();

    lcu_active_download_payload_master();

    return tx_buffer;
}

void xlru_lcu::lcu_sw_status_payload_master(void)
{
    tx_buffer[4] = LCU_SW_STATUS;			//"A", software status
    tx_buffer[5] = 0;

    char checksum[2] = {0};
    calc_checksum(checksum, tx_buffer);
    tx_buffer[5] = checksum[0];
    tx_buffer[6] = checksum[1];

    //snprintf(&tx_buffer[5], 3, "%02x", get_checksum(tx_buffer));
    tx_buffer[7]= CR_EOM;
    tx_buffer[8]= 0;
}

char* xlru_lcu::lcu_sw_status_message_master(void)
{
    memset(tx_buffer, 0, sizeof(tx_buffer));
    lcu_header_master();
    lcu_sw_status_payload_master();
    return tx_buffer;
}


void xlru_lcu::lcu_override_set_value_payload(lcu_override_param_id_t _param_id,int _value)
{
    int idx = 4;
    tx_buffer[idx++] = LCU_CMD_OVERRIDE;			//"X", override

    tx_buffer[idx++] = LCU_CMD_OVERRIDE_SET_VALUE;  //S, set value

    char tmp[3] = { 0 };

    snprintf(tmp, 3, "%02X", _param_id);

    tx_buffer[idx++] = tmp[0];
    tx_buffer[idx++] = tmp[1];

    char tmp1[5] = { 0 };

    snprintf(tmp1, 5, "%04X", _value);

    tx_buffer[idx++] = tmp1[0];
    tx_buffer[idx++] = tmp1[1];
    tx_buffer[idx++] = tmp1[2];
    tx_buffer[idx++] = tmp1[3];

/*#define LCU_CMD_OVERRIDE            'X'
#define LCU_CMD_OVERRIDE_SET_VALUE  'S'
#define LCU_CMD_OVERRIDE_RST_FACT   'R'
#define LCU_CMD_OVERRIDE_SET_VALUE  'S'
#define LCU_CMD_OVERRIDE_GET_FACT   'g'*/


    tx_buffer[idx++] = STATUS_SPARE;
    tx_buffer[idx++] = STATUS_SPARE;
    tx_buffer[idx++] = STATUS_SPARE;
    tx_buffer[idx++] = STATUS_SPARE;

    char checksum[2] = {0};
    calc_checksum(checksum, tx_buffer);
    tx_buffer[idx++] = checksum[0];
    tx_buffer[idx++] = checksum[1];

    //snprintf(&tx_buffer[5], 3, "%02x", get_checksum(tx_buffer));
    tx_buffer[idx++]= CR_EOM;
    tx_buffer[idx++]= 0;
}

char* xlru_lcu::lcu_override_set_value_message(lcu_override_param_id_t _param_id,int _value)
{
    memset(tx_buffer, 0, sizeof(tx_buffer));
    lcu_header_master();
    lcu_override_set_value_payload(_param_id, _value);
    return tx_buffer;
}


void xlru_lcu::lcu_override_get_value_payload(lcu_override_param_id_t _param_id)
{
    int idx = 4;
    tx_buffer[idx++] = LCU_CMD_OVERRIDE;			//"X", override

    tx_buffer[idx++] = LCU_CMD_OVERRIDE_GET_VALUE;  //S, set value

    char tmp[3] = { 0 };

    snprintf(tmp, 3, "%02X", _param_id);

    tx_buffer[idx++] = tmp[0];
    tx_buffer[idx++] = tmp[1];

/*#define LCU_CMD_OVERRIDE            'X'
#define LCU_CMD_OVERRIDE_SET_VALUE  'S'
#define LCU_CMD_OVERRIDE_RST_FACT   'R'
#define LCU_CMD_OVERRIDE_GET_VALUE  'G'
#define LCU_CMD_OVERRIDE_GET_FACT   'g'*/


    tx_buffer[idx++] = STATUS_SPARE;
    tx_buffer[idx++] = STATUS_SPARE;
    tx_buffer[idx++] = STATUS_SPARE;
    tx_buffer[idx++] = STATUS_SPARE;

    char checksum[2] = {0};
    calc_checksum(checksum, tx_buffer);
    tx_buffer[idx++] = checksum[0];
    tx_buffer[idx++] = checksum[1];

    //snprintf(&tx_buffer[5], 3, "%02x", get_checksum(tx_buffer));
    tx_buffer[idx++]= CR_EOM;
    tx_buffer[idx++]= 0;
}

char* xlru_lcu::lcu_override_get_value_message(lcu_override_param_id_t _param_id)
{
    memset(tx_buffer, 0, sizeof(tx_buffer));
    lcu_header_master();
    lcu_override_get_value_payload(_param_id);
    return tx_buffer;
}

void xlru_lcu::lcu_override_get_factory_payload(lcu_override_param_id_t _param_id)
{
    int idx = 4;
    tx_buffer[idx++] = LCU_CMD_OVERRIDE;			//"X", override

    tx_buffer[idx++] = LCU_CMD_OVERRIDE_GET_FACT;  //f, get factory

    char tmp[3] = { 0 };

    snprintf(tmp, 3, "%02X", _param_id);

    tx_buffer[idx++] = tmp[0];
    tx_buffer[idx++] = tmp[1];


    tx_buffer[idx++] = STATUS_SPARE;
    tx_buffer[idx++] = STATUS_SPARE;
    tx_buffer[idx++] = STATUS_SPARE;
    tx_buffer[idx++] = STATUS_SPARE;

    char checksum[2] = {0};
    calc_checksum(checksum, tx_buffer);
    tx_buffer[idx++] = checksum[0];
    tx_buffer[idx++] = checksum[1];

    //snprintf(&tx_buffer[5], 3, "%02x", get_checksum(tx_buffer));
    tx_buffer[idx++]= CR_EOM;
    tx_buffer[idx++]= 0;
}

char* xlru_lcu::lcu_override_get_factory_message(lcu_override_param_id_t _param_id)
{
    memset(tx_buffer, 0, sizeof(tx_buffer));
    lcu_header_master();
    lcu_override_get_factory_payload(_param_id);
    return tx_buffer;
}

void xlru_lcu::lcu_sw_set_to_factory_payload(lcu_override_param_id_t _param_id)
{
    int idx = 4;
    tx_buffer[idx++] = LCU_CMD_OVERRIDE;			//"X", override

    tx_buffer[idx++] = LCU_CMD_OVERRIDE_RST_FACT;  //R, reset to factory

    char tmp[3] = { 0 };

    snprintf(tmp, 3, "%02X", _param_id);

    tx_buffer[idx++] = tmp[0];
    tx_buffer[idx++] = tmp[1];

    tx_buffer[idx++] = STATUS_SPARE;
    tx_buffer[idx++] = STATUS_SPARE;
    tx_buffer[idx++] = STATUS_SPARE;
    tx_buffer[idx++] = STATUS_SPARE;

    char checksum[2] = {0};
    calc_checksum(checksum, tx_buffer);
    tx_buffer[idx++] = checksum[0];
    tx_buffer[idx++] = checksum[1];

    //snprintf(&tx_buffer[5], 3, "%02x", get_checksum(tx_buffer));
    tx_buffer[idx++]= CR_EOM;
    tx_buffer[idx++]= 0;
}

char* xlru_lcu::lcu_override_set_to_factory_message(lcu_override_param_id_t _param_id)
{
    memset(tx_buffer, 0, sizeof(tx_buffer));
    lcu_header_master();
    lcu_sw_set_to_factory_payload(_param_id);
    return tx_buffer;
}