CCS/CC256XB-BT-SP: application crash

/*
 * Service_Mode.c
 *
 *  Created on: 13-Mar-2018
 *      Author: Adhitya GN
 */


/***************************************************************
*
* COPYRIGHT 2018, Vasmed Health Sciences Pvt. Ltd..
*
* Filename: Service_Mode.c
* Author:   Adhitya GN
* $Revision: -
* $Date: -
*
* Description:
*  All the codes related to service mode will be executed from here.
*
*
*****************************************************************/

#include "Main.h"
#include "Service_Mode.h"

#include <stdbool.h>
#include <stdint.h>

#include "inc/hw_memmap.h"
#include "driverlib/uart.h"
#include "driverlib/gpio.h"
#include "driverlib/watchdog.h"
#include "driverlib/sysctl.h"

#include "Battery_board.h"
#include "IBP.h"
#include "RJC.h"
#include "Keypad.h"
#include "SPPDEMO.h"


//*************************function declaration************************************************

Byte_t service_battery();
Byte_t service_ibp();
Byte_t service_rjc();
Byte_t service_keypad_00();
Byte_t service_keypad_01();
Byte_t service_baseboard();
Byte_t s_error_handler(bool , int , Byte_t );
void service_data_packet(void *UserParameter);

//----------------------------------------------------------------------------------------------


Byte_t s_adapter_connection_status(Byte_t);
Byte_t battery_connection_status(Byte_t);
Byte_t battery_adc_id(Byte_t);
Byte_t battery_charging_status(Byte_t);

Byte_t ibp_adc_id(Byte_t);
Byte_t ibp_mux_selection_0V(Byte_t);
Byte_t ibp_mux_selection_5V(Byte_t);
Byte_t ao_sensor_connection(Byte_t);
Byte_t haemodynamic_output(Byte_t);

Byte_t console_bluetooth_status(Byte_t);
Byte_t tablet_bluetooth_status(Byte_t);
Byte_t reset_reason(Byte_t,int,int);
Byte_t application_software_integrity_check(Byte_t);
bool reset_cause(int);

Byte_t reg_00_keys(Byte_t,int);
Byte_t defualt_keypad_00_01_circuitry(Byte_t);

Byte_t reg_01_keys(Byte_t,int);

Byte_t pd_sensor_connection(Byte_t);
Byte_t warm_up_status(Byte_t);
Byte_t temperature(Byte_t);
Byte_t heater_duty_cycle(Byte_t);
Byte_t maintenenace_required(Byte_t);
//Byte_t done_testing(Byte_t);

void rjc_sensor_value();

//********************************************************************************************


//********************************global variables*******************************************


int one_time_execute=0;
bool warm_up;
Byte_t sensor_name1;
Byte_t sensor_name2;
int done=0;
//********************************************************************************************


/*************************************************************
* Function:  service_battery()
*
* Description:  This is called by service_data_packet(). This is used to
* 				execute all of battery board functionality.
*
* Parameters:   NULL
*
* Returns:     value indicating the status of each battery test in a single byte.
*
* Reentrancy:  Yes.
*
* Execution Requirements/Assumptions: NULL
*
*************************************************************/

Byte_t service_battery()
{
	Byte_t	l_s_battery=0;

	l_s_battery=s_adapter_connection_status(l_s_battery);
	//Display(("\n1=%x",l_s_battery));
	l_s_battery=battery_connection_status(l_s_battery);
	//Display(("\n2=%x",l_s_battery));
	l_s_battery=battery_adc_id(l_s_battery);
	//Display(("\n3=%x",l_s_battery));
	l_s_battery=battery_charging_status(l_s_battery);
	//Display(("\n4=%x",l_s_battery));
	//Display(("\n-l_s_battery= %x\n",l_s_battery));
	return(l_s_battery);
}

/*************************************************************
* Function:  service_ibp()
*
* Description:  This is called by service_data_packet(). This is used to
* 				execute all of ibp board functionality. For 0v calibration
* 				and 5v calibration, it can be executed only 3 times and
* 				store those values and from next time(after 3 times), directly
* 				send the values without executing 0v and 5v calibration.
*
* Parameters:   NULL
*
* Returns:     value indicating the status of each ibp board test in a single byte.
*
* Reentrancy:  Yes. During self_Test, and till self test finishes, this will keep on executing.
*
* Execution Requirements/Assumptions: NULL
*
*************************************************************/

Byte_t service_ibp()												// need to test 5v and 0v calib for new ibp board. 26-7-18
{
	Byte_t	l_s_ibp=0;
	static bool retain_value_0V=0;
	static bool retain_value_5V=0;
	bool b;

	l_s_ibp=ibp_adc_id(l_s_ibp);

	if(	one_time_execute < 4 )										// for 0v calib
	{
		l_s_ibp=ibp_mux_selection_0V(l_s_ibp);						// 1st bit. execute this only 3 times.  when we select this
																	//channel, whether the adc values are coming in reference to 0v. if
																	// coming properly for 0v reference, then make it 1. else make it 0.
		if(one_time_execute >= 1)									// this variable will increment for first time in service_baseboard()
		{
			one_time_execute++;
			b=CHECK_BIT(l_s_ibp,1);									// check whether its 1 or 0. and retain it in variable for code
																	// life time as we need to send in each data packet.
			if(b==true)
			{
				retain_value_0V=true;								// if it is 1, store 1 in variable.
			}
			else
			{
				retain_value_0V=false;
			}
		}
	}
	else
	{
		l_s_ibp|=(retain_value_0V<<1); 								//put that above stored retain_value varaible in data packet.
	}

	l_s_ibp=ao_sensor_connection(l_s_ibp);
	l_s_ibp=haemodynamic_output(l_s_ibp);

	if( (one_time_execute > 3 ) & (one_time_execute < 7) )			//for 5v calib.. same method as used in 0v calibration.
	{
		l_s_ibp=ibp_mux_selection_5V(l_s_ibp);						//2nd bit. by changing the channel to select 5v, adc value is checked
																	//in reference with 5v and whether adc value is coming in that range
		one_time_execute++;
		b=CHECK_BIT(l_s_ibp,2);										// check whether its 1 or 0. and retain it in variable for code
																	// life time as we need to send in each data packet.
		if(b==true)
		{
			retain_value_5V=true;									// if it is 1, store 1 in variable.
		}
		else
		{
			retain_value_5V=false;
		}
	}
	else
	{
		l_s_ibp|=(retain_value_5V<<2); 								//put that above stored varaible in data packet.
	}

	//Display(("\n-l_s_ibp= %x\n",l_s_ibp));

	return(l_s_ibp);
}

/*************************************************************
* Function:  service_rjc()
*
* Description:  This is called by service_data_packet(). This is used to
* 				execute all of rjc board functionality.
*
* Parameters:   NULL
*
* Returns:      value indicating the status of each rjc board test in a single byte.
*
* Reentrancy:  Yes.
*
* Execution Requirements/Assumptions: NULL
*
*************************************************************/

Byte_t service_rjc()
{
	Byte_t	l_s_rjc=0;
	service_data();
	l_s_rjc=pd_sensor_connection(l_s_rjc);
	l_s_rjc=warm_up_status(l_s_rjc);
	l_s_rjc=temperature(l_s_rjc);
	l_s_rjc=heater_duty_cycle(l_s_rjc);
	l_s_rjc=maintenenace_required(l_s_rjc);
	//l_s_rjc=done_testing(l_s_rjc);

	//Display(("\n-l_s_rjc= %x\n",l_s_rjc));
	return(l_s_rjc);
}


/*************************************************************
* Function:  service_keypad_00()
*
* Description:  This is called by service_data_packet(). This is used to get status
* 				 of keys in register keypad00 and status of two registers in keypad .
* 				 It will call two functions from this function. first function will
* 				 get the status of two registers in keypad. This is executed only once.
* 				 The second function will get the status of each key in the register 00.
*
* Parameters:   NULL
*
* Returns:      value indicating status of the keys from register 00 and status of
* 				both the registers in keypad..
*
* Reentrancy:   Yes.
*
* Execution Requirements/Assumptions: NULL
*
*************************************************************/

Byte_t service_keypad_00()
{
	bool b;
	Byte_t	l_s_keypad_00=0;
	static bool retain_key00;
	static bool retain_key01;

	keypad_keys();

	if(one_time_execute==0)													// 2 and 3 bits, checking whether ff and f are coming.
	{
		l_s_keypad_00=defualt_keypad_00_01_circuitry(l_s_keypad_00);		// gets the status of the two register as a (ff and f)
																			//group(not individual key) and updated in ls_key.

		b=CHECK_BIT(l_s_keypad_00,2);										// check whether its 1 or 0. and retain it in variable for
																			// code life time as we need to send in each data packet.
		if(b==true)
		{
			retain_key00=true;												// if it is 1, store 1 in variable. If we get 'f', then 1.
		}
		else
		{
			retain_key00=false;												// if we dont get 'f', then 0 as that register has issue.
		}

		b=CHECK_BIT(l_s_keypad_00,3);										// check whether its 1 or 0. and retain it in variable for
																			// code life time as we need to send in each data packet.
		if(b==true)
		{
			retain_key01=true;												// if it is 1, store 1 in variable. If we get 'ff', then 1.
		}
		else
		{
			retain_key01=false;												// If we dont get 'ff', then 0.
		}

	}
	else
	{
		l_s_keypad_00|=(retain_key00<<2);									// whatever key status for two registers was retained
		l_s_keypad_00|=(retain_key01<<3);									// in above, put them here for the rest of the packets.
	}

	l_s_keypad_00=reg_00_keys(l_s_keypad_00,0);								// 0 bit	//enter	//2nd part

	// here ask user to press back. once back is pressed, 'd' will go. in tablet side,initially 'press' shud be there.if '0' is received,
	//that means it is pressed and this byte should be ignored from then onwards.
	//ex- back - 1)press it.... 2) if not pressed, nothing happens. 3)if pressed, in tab, changes to pressed and ok. 4)ignore this bit
	// from next time.

	l_s_keypad_00=reg_00_keys(l_s_keypad_00,1);								// 1 bit	// back	//2nd part.

	//Display(("\n-l_s_keypad_00= %x\n",l_s_keypad_00));

	return(l_s_keypad_00);
}


/*************************************************************
* Function:  service_keypad_01()
*
* Description:  This is called by service_data_packet(). This is used to get status
* 				 of keys in register keypad01. Since, the status of two register in
* 				 keypad is captured in function 'service_keypad_00', here we will
* 				 execute only status of keys in register 01.
*
* Parameters:   NULL
*
* Returns:      value indicating status of the keys from register 01
*
* Reentrancy:  Yes.
*
* Execution Requirements/Assumptions: NULL
*
*************************************************************/

Byte_t service_keypad_01()
{
	Byte_t	l_s_keypad_01=0;
	keypad_keys();

	l_s_keypad_01=reg_01_keys(l_s_keypad_01,0);
	l_s_keypad_01=reg_01_keys(l_s_keypad_01,1);
	l_s_keypad_01=reg_01_keys(l_s_keypad_01,2);
	l_s_keypad_01=reg_01_keys(l_s_keypad_01,3);
	l_s_keypad_01=reg_01_keys(l_s_keypad_01,4);
	l_s_keypad_01=reg_01_keys(l_s_keypad_01,5);
	l_s_keypad_01=reg_01_keys(l_s_keypad_01,6);
	l_s_keypad_01=reg_01_keys(l_s_keypad_01,7);

	//Display(("\n-l_s_keypad_01= %x\n",l_s_keypad_01));

	return(l_s_keypad_01);
}

/*************************************************************
* Function:  service_baseboard()
*
* Description:  This is called by service_data_packet(). This is used to get status
* 				 of bluetooth and reset. The status of reset is executed only once as
* 				 the reset reasons will be cleared so that the reset reason can be
* 				 captured the next time.
*
* Parameters:   NULL
*
* Returns:      value indicating the status of baseboard.
*
* Reentrancy:  Yes.
*
* Execution Requirements/Assumptions: NULL
*
*************************************************************/

Byte_t service_baseboard()
{
	Byte_t	l_s_baseboard=0;

	l_s_baseboard=console_bluetooth_status(l_s_baseboard);
	l_s_baseboard=tablet_bluetooth_status(l_s_baseboard);

	if(one_time_execute==0)
	{
		l_s_baseboard=reset_reason(l_s_baseboard,3,2); 					//reset_reason
		l_s_baseboard=reset_reason(l_s_baseboard,0,3); 					//external_reset
		l_s_baseboard=reset_reason(l_s_baseboard,2,4);					//brown_out_reset
		l_s_baseboard=reset_reason(l_s_baseboard,12,6);					//hssr_reset
		one_time_execute++;
	}
	l_s_baseboard=application_software_integrity_check(l_s_baseboard);

	//Display(("\n-l_s_baseboard= %x\n",l_s_baseboard));
	return(l_s_baseboard);
}


/*************************************************************
* Function:  service_data_packet()
*
* Description: This function calls all the functions such as rjc, ibp,
* 				battery, baseboard and then forms the service packet and
* 				calls a function ProcessCommandLine3 which is in sppdemo.c
* 				which will send the service packet from console to tablet
*
* Parameters:   NULL
*
* Returns:		NULL
*
* Reentrancy:  Yes. This is scheduled in SPPDemo.c when tablet sends data
* 				to console to go to service mode.
*
* Execution Requirements/Assumptions: NULL
*
*************************************************************/

void service_data_packet(void *UserParameter)
{

	GPIOPinWrite(GPIO_PORTE_BASE, GPIO_PIN_3, GPIO_PIN_3);				//HARDWARE WATCHDOG
	GPIOPinWrite(GPIO_PORTE_BASE, GPIO_PIN_3, 0X00);					//HARDWARE WATCHDOG

	if(WatchdogIntStatus(WATCHDOG0_BASE, true)) 						// clear hardware watchdog timer.
	{
		WatchdogIntClear(WATCHDOG0_BASE);
	}

	//Display(("\nCame to service mode\n"));
	Byte_t s_data_packet[10];
	int var=0;

	Byte_t s_ibp;
	Byte_t s_battery;
	Byte_t s_rjc;
	Byte_t s_keypad_00;
	Byte_t s_keypad_01;
	Byte_t s_baseboard;
	Byte_t s_battery_percentage=battery_percentage_error_code;
	Byte_t s_temperature;
	Byte_t s_temperature_decimal;
	//Display(("\nbattery_percentage_error_code=%x\n",battery_percentage_error_code));

	s_battery=service_battery();
	s_ibp=service_ibp();
	s_rjc=service_rjc();
	s_keypad_00=service_keypad_00();
	s_keypad_01=service_keypad_01();
	s_baseboard=service_baseboard();

	//WARNING---------28-3-18-
	// if you want to see service mode packets(below), you have to uncomment rjc service_Data() also else battery flags will be error.
	//26-7-18-- test this once. maybe the above warning is not necessary.

	for(var=0;var<SERVICE_PACKET_SIZE;var++)
	{
		switch(var)
		{
			case 0:

				s_data_packet[var]=PACKET_SERVICE;								// to indicate that this is service mode packets.
				//Display(("\nvar=%d, s_data_packet[var]=%x",var,s_data_packet[var]));
				break;

			case 1:

				s_data_packet[var]=s_battery;
				//Display(("\nvar=%d, s_data_packet[var]=%x",var,s_data_packet[var]));
				break;

			case 2:

				s_data_packet[var]=s_battery_percentage;
				//Display(("\nvar=%d, s_data_packet[var]=%x",var,s_data_packet[var]));
				break;

			case 3:

				s_data_packet[var]=s_ibp;
				//Display(("\nvar=%d, s_data_packet[var]=%x",var,s_data_packet[var]));
				break;

			case 4:

				s_data_packet[var]=s_baseboard;
				//Display(("\nvar=%d, s_data_packet[var]=%x",var,s_data_packet[var]));
				break;

			case 5:

				s_data_packet[var]=s_keypad_00;
				//Display(("\nvar=%d, s_data_packet[var]=%x",var,s_data_packet[var]));
				break;

			case 6:

				s_data_packet[var]=s_keypad_01;
				//Display(("\nvar=%d, s_data_packet[var]=%x",var,s_data_packet[var]));
				break;

			case 7:

				s_data_packet[var]=s_rjc;
				//Display(("\nvar=%d, s_data_packet[var]=%x",var,s_data_packet[var]));
				break;

			case 8:

				rjc_sensor_value();
				s_data_packet[var]=sensor_name1;
				//Display(("\nvar=%d, s_data_packet[var]=%x",var,s_data_packet[var]));
				break;

			case 9:

				s_data_packet[var]=sensor_name2;
				//Display(("\nvar=%d, s_data_packet[var]=%x",var,s_data_packet[var]));
				break;

			case 10:

				s_temperature=g_temperature/10;
				s_data_packet[var]=s_temperature;
				//Display(("\nvar=%d, s_data_packet_decimal[var]=%d",var,s_data_packet[var]));
				break;

			case 11:

				s_temperature_decimal=g_temperature%10;
				s_data_packet[var]=s_temperature_decimal;
				//Display(("\nvar=%d, s_data_packet_Decimal[var]=%d\n",var,s_data_packet[var]));
				break;

			default:
				break;
		}
	}

	ProcessCommandLine3(s_data_packet,SERVICE_PACKET_SIZE);
}


/*************************************************************
* Function:  s_error_handler()
*
* Description:  This is the function where the status of each board/function's variable,
* 				bit by bit is updated in the variable. This variable is of form
* 				'Byte' is used to form data packet and send to table over bluetooth.
* 				 Refer the document to know which position represents which error.
*
* Parameters:   first parameter- the value which is written in the error_handler variable
* 				second parameter- the position where the value is written in the error_handler
* 				varaiable
* 				third parametr- the variable where each board's status has to be updated.
*
* Returns:      null
*
* Reentrancy:  Yes. Whenever the error of a certain board/module changes, this will
* 				be called.
*
* Execution Requirements/Assumptions: NULL
*
************************************************************* */


Byte_t s_error_handler(bool s_value, int s_position, Byte_t s_errors)
{
	s_errors|=(s_value<<s_position);
	//Display(("\n--errors= %x\n",s_errors));
	return(s_errors);

}

//------------------------------------------------------BYTE 1-----start-------------------------------------------------------
//-----------------------------------------------------------------------------------------------------------------------------

Byte_t s_adapter_connection_status(Byte_t l_s_battery)
{
	if(GPIOPinRead(GPIO_PORTS_BASE, GPIO_PIN_6))					// if this gpio pin reads high, then adapter is present.
	{
		l_s_battery=s_error_handler( true, 1 , l_s_battery);
	}
	else
	{
		l_s_battery=s_error_handler( false, 1 , l_s_battery);
	}
	return(l_s_battery);
}

Byte_t battery_connection_status(Byte_t l_s_battery)						// 26-7-18- need to test
{
	//int s_battery_connection=0;
	//s_battery_connection=battery_ilim_ain0_adc_calculation();
	//if( (s_battery_connection<1002) || (s_battery_connection > 2330) )	// commented 3 lines for old battery board. 26-7-18
	if( ilim_passing != 2 )
	{
		l_s_battery=s_error_handler( true, 2 , l_s_battery);				// battery is connected
	}
	else
	{
		l_s_battery=s_error_handler( false, 2 , l_s_battery);				// battery is not connected
	}
	return(l_s_battery);
}

Byte_t battery_adc_id(Byte_t l_s_battery)
{
	bool adc_id=false;
	adc_id=battery_board_self_test();
	if(adc_id==true)
	{
		l_s_battery=s_error_handler( true, 0 , l_s_battery);
	}
	else
	{
		l_s_battery=s_error_handler( false, 0 , l_s_battery);
	}
	return(l_s_battery);

}

Byte_t battery_charging_status(Byte_t l_s_battery)								// 26-7-18- need to test
{
	//int s_battery_charging=0;
	//s_battery_charging=battery_ilim_ain0_adc_calculation();					// commented 3 lines for old battery board. 26-7-18
	//if(s_battery_charging<1002)
	if( ilim_passing == 0 )														// bat not charging. AC off or bat is full.
	{
		l_s_battery=s_error_handler( false, 3 , l_s_battery);
	}
	//else if (s_battery_charging > 2100)
	else if( ilim_passing == 1 )												// bat is charging
	{
		l_s_battery=s_error_handler( true, 3 , l_s_battery);
	}
	else																		// if ilim=3, den bat nt connected & hence nt charging.
	{
		l_s_battery=s_error_handler( false, 3 , l_s_battery);
	}
	return(l_s_battery);

}


//------------------------------------------------------BYTE 1-----end-------------------------------------------------------
//-----------------------------------------------------------------------------------------------------------------------------



//------------------------------------------------------BYTE 2-----start-------------------------------------------------------
//-----------------------------------------------------------------------------------------------------------------------------
		// done in data packet section above.
//------------------------------------------------------BYTE 2-----end-------------------------------------------------------
//-----------------------------------------------------------------------------------------------------------------------------



//------------------------------------------------------BYTE 3-----start-------------------------------------------------------
//-----------------------------------------------------------------------------------------------------------------------------

Byte_t ibp_adc_id(Byte_t l_s_ibp)
{
	bool s_ibp_id=false;
	s_ibp_id=ibp_self_test();
	if(s_ibp_id==false)
	{
		l_s_ibp=s_error_handler( false, 0 , l_s_ibp);
	}
	else
	{
		l_s_ibp=s_error_handler( true, 0 , l_s_ibp);
	}
	return(l_s_ibp);
}


Byte_t ibp_mux_selection_0V(Byte_t l_s_ibp) 										//check for new adc. 26-7-18.
{
	int calib_zero;
	calib_zero=ibp_calib_zero();
	//Display(("\ncalib_zero-->%d\n",calib_zero));
	if( (calib_zero > 16775504) && (calib_zero < 16775935) )
	{
		l_s_ibp=s_error_handler( true, 1 , l_s_ibp);
	}
	else
	{
		l_s_ibp=s_error_handler( false, 1 , l_s_ibp);
	}
	return(l_s_ibp);

}


Byte_t ibp_mux_selection_5V(Byte_t l_s_ibp)											//check for new adc. 26-7-18
{
	int calib_five=0;
	calib_five=ibp_calib_five();
	if( (calib_five >= 8110000) && (calib_five <= 8125000) )							//7bea2d
	{
		l_s_ibp=s_error_handler( true, 2 , l_s_ibp);
	}
	else
	{
		l_s_ibp=s_error_handler( false, 2 , l_s_ibp);
	}
	return(l_s_ibp);
}


Byte_t ao_sensor_connection(Byte_t l_s_ibp)											//TODO , need consultants to tell their hardware
{
	bool s_ibp_sensor=true;
	if(s_ibp_sensor==false)
	{
		l_s_ibp=s_error_handler( false, 3 , l_s_ibp);
	}
	else
	{
		l_s_ibp=s_error_handler( true, 3 , l_s_ibp);
	}
	return(l_s_ibp);
}


Byte_t haemodynamic_output(Byte_t l_s_ibp)											//TODO, consultants input needed.
{
	bool s_ibp_haemo=true;
	//s_ibp_haemo=;
	if(s_ibp_haemo==false)
	{
		l_s_ibp=s_error_handler( false, 4 , l_s_ibp);
	}
	else
	{
		l_s_ibp=s_error_handler( true, 4 , l_s_ibp);
	}
	return(l_s_ibp);
}

//------------------------------------------------------BYTE 3-----end-------------------------------------------------------
//-----------------------------------------------------------------------------------------------------------------------------





//------------------------------------------------------BYTE 4-----start-------------------------------------------------------
//-----------------------------------------------------------------------------------------------------------------------------

Byte_t console_bluetooth_status(Byte_t l_s_baseboard)
{
	bool s_bt_status;
	s_bt_status=BtTest();

	if(s_bt_status==true)
	{
		l_s_baseboard=s_error_handler( true, 0 , l_s_baseboard);
	}
	else
	{
		l_s_baseboard=s_error_handler( false, 0 , l_s_baseboard);
	}
	return(l_s_baseboard);
}


Byte_t tablet_bluetooth_status(Byte_t l_s_baseboard)
{
	if(bt_g==true)
	{
		l_s_baseboard=s_error_handler( true, 1 , l_s_baseboard);
	}
	else
	{
		l_s_baseboard=s_error_handler( false, 1 , l_s_baseboard);
	}
	return(l_s_baseboard);
}


Byte_t reset_reason(Byte_t l_s_baseboard,int key_bit, int packet_bit)
{
	bool b;
	b=reset_cause(key_bit);														//4th byte. or 0,1,2,3....3
	if(b==true)
	{
		l_s_baseboard=s_error_handler( true, packet_bit , l_s_baseboard);
	}
	else
	{
		l_s_baseboard=s_error_handler( false, packet_bit , l_s_baseboard);
	}
	return(l_s_baseboard);
}


Byte_t application_software_integrity_check(Byte_t l_s_baseboard)	//todo
{
	bool b=false;
	if(b==true)
	{
		l_s_baseboard=s_error_handler( true, 5 , l_s_baseboard);
	}
	else
	{
		l_s_baseboard=s_error_handler( false, 5 , l_s_baseboard);
	}
	return(l_s_baseboard);
}


bool reset_cause(int y)
{
	uint32_t x;
	bool b;
	x=SysCtlResetCauseGet();
	//Display(("-reset reason==%x\n",x));
	b=CHECK_BIT(x,y);
	if(y==12)												// because 12 is the last value, I am checking. 12th bit
	{
		SysCtlResetCauseClear(x);							// clearing reset reason afer capturing all resets.
	}
	return(b);
}


//------------------------------------------------------BYTE 4-----end-------------------------------------------------------
//-----------------------------------------------------------------------------------------------------------------------------



//------------------------------------------------------BYTE 5-----start-------------------------------------------------------
//-----------------------------------------------------------------------------------------------------------------------------

Byte_t reg_00_keys(Byte_t l_s_key_00,int packet_bit)						// status of two keys in reg 00 and update in bit 0 and 1.
{
	bool b;
	b=CHECK_BIT(g_reg_00,packet_bit);
	if(b==true)
	{
		l_s_key_00=s_error_handler( true, packet_bit , l_s_key_00);			// if 1, then that key was not pressed.
	}
	else
	{
		l_s_key_00=s_error_handler( false, packet_bit , l_s_key_00);		// if 0, then that key was pressed.
	}
	return(l_s_key_00);
}


Byte_t defualt_keypad_00_01_circuitry(Byte_t l_s_key_00)		// status of two registers 00 and 01 as group(f and ff) in 2 and 3rd bit).
{
	int key;
	key=keypad_keys_self_test();							// gets status of two registers. whether ff and f is coming in two registers.

	if(key==ERR_KEYPAD_OK)
	{
		l_s_key_00=s_error_handler( true, 2 , l_s_key_00);		// if 'f' is coming, make 2nd bit as true. register 00.
		l_s_key_00=s_error_handler( true, 3 , l_s_key_00);		// if 'ff' is coming, make 3rd bit as true. register 01.
	}
	else if(key==ERR_KEYPAD_00_NOT_OK)
	{
		l_s_key_00=s_error_handler( false, 2 , l_s_key_00);
		l_s_key_00=s_error_handler( true, 3 , l_s_key_00);
	}
	else if(key==ERR_KEYPAD_01_NOT_OK)
	{
		l_s_key_00=s_error_handler( true, 2 , l_s_key_00);
		l_s_key_00=s_error_handler( false, 3 , l_s_key_00);
	}
	else if(key==ERR_KEYPAD_NOT_OK)
	{
		l_s_key_00=s_error_handler( false, 2 , l_s_key_00);
		l_s_key_00=s_error_handler( false, 3 , l_s_key_00);
	}
	return(l_s_key_00);											// return the value (2nd 3rd bit) whether those bits are true or false.
}




//------------------------------------------------------BYTE 5-----end-------------------------------------------------------
//-----------------------------------------------------------------------------------------------------------------------------



//------------------------------------------------------BYTE 6-----start-------------------------------------------------------
//-----------------------------------------------------------------------------------------------------------------------------

Byte_t reg_01_keys(Byte_t l_s_key_01, int packet_bit)
{
	bool b;
	b=CHECK_BIT(g_reg_01,packet_bit);
	if(b==true)
	{
		l_s_key_01=s_error_handler( true, packet_bit , l_s_key_01);
	}
	else
	{
		l_s_key_01=s_error_handler( false, packet_bit , l_s_key_01);
	}
	return(l_s_key_01);
}

//------------------------------------------------------BYTE 6-----end-------------------------------------------------------
//-----------------------------------------------------------------------------------------------------------------------------


//------------------------------------------------------BYTE 7-----start-------------------------------------------------------
//-----------------------------------------------------------------------------------------------------------------------------


Byte_t pd_sensor_connection(Byte_t l_s_rjc)	//todo
{
//	bool b=true;
//	if (i_dummy[4]==0x20)											// status flag-2	// works if data rate is adjusted.
//	{
//		b=CHECK_BIT(i_dummy[3],7);
//		if(b == true)												//sensor connected
//		{
//			l_s_rjc=s_error_handler( true, 0 , l_s_rjc);
//			return(l_s_rjc);
//		}
//		else
//		{															// normal
//			l_s_rjc=s_error_handler( false, 0 , l_s_rjc);
//			return(l_s_rjc);
//		}
//	}
//	else					//default is not connected.	//maybe wont come coz at 10, 11, 12 or anything else from 20, this will execute.
//	{
//		l_s_rjc=s_error_handler( false, 0 , l_s_rjc);
//		return(l_s_rjc);
//	}

	if(g_Pd[1] == RJC_IS_WARMING_UP) 								// this tells rjc is still warming up
	{
		l_s_rjc=s_error_handler( false, 0 , l_s_rjc);
	}
	else
	{
		l_s_rjc=s_error_handler( true, 0 , l_s_rjc);
	}
	return(l_s_rjc);
}


Byte_t warm_up_status(Byte_t l_s_rjc)	//todo
{
	//	bool b=true;
	//	if (i_dummy[4]==0x20)										// status flag-2	// works if data rate is adjusted.
	//	{
	//		b=CHECK_BIT(i_dummy[2],2);								// why 2 in last variable.? it's 10.--5-4-18
	//		if(b == true)											//warm up  completed
	//		{
	//			l_s_rjc=s_error_handler( true, 1 , l_s_rjc);
	//			return(l_s_rjc);
	//		}
	//		else
	//		{														// still warming up
	//			l_s_rjc=s_error_handler( false, 1 , l_s_rjc);
	//			return(l_s_rjc);
	//		}
	//	}
	//	else														// still warming up
	//	{
	//		l_s_rjc=s_error_handler( false, 1 , l_s_rjc);
	//		return(l_s_rjc);
	//	}
	if(g_Pd[1] == RJC_IS_WARMING_UP) 							// this tells rjc is still warming up
	{
		l_s_rjc=s_error_handler( false, 1 , l_s_rjc);
		warm_up=false;
	}
	else
	{
		l_s_rjc=s_error_handler( true, 1 , l_s_rjc);
		warm_up=true;												// need this for getting rjc sensor id.
	}
	return(l_s_rjc);
}


Byte_t temperature(Byte_t l_s_rjc) 												// page 125 of my book
{
	//if(warm_up==true)
	//{
		if (g_Pd[4]==0x80)
		{
			if(g_Pd[2] >= RJC_BOARD_47C)										// error as temperature is high
			{																	// high
				l_s_rjc=s_error_handler( false, 2 , l_s_rjc);
			}
			else
			{																	// normal
				l_s_rjc=s_error_handler( true, 2 , l_s_rjc);
			}
		}
		else																	//default is normal
		{
			l_s_rjc=s_error_handler( true, 2 , l_s_rjc);
		}
		return(l_s_rjc);
		//}
}


Byte_t heater_duty_cycle(Byte_t l_s_rjc)
{
//	if(warm_up==true)
//	{
		if (g_Pd[4]==0xA0)
		{
			if(g_Pd[2] >= RJC_DUTY_CYCLE)							// error as dc is 1. pg 124 of my book
			{															// dc= 1.0
				l_s_rjc=s_error_handler( false, 3 , l_s_rjc);
			}
			else
			{															// normal
				l_s_rjc=s_error_handler( true, 3 , l_s_rjc);
			}
		}
		else															//default is normal
		{
			l_s_rjc=s_error_handler( true, 3 , l_s_rjc);
		}
		return(l_s_rjc);
//	}
}


Byte_t maintenenace_required(Byte_t l_s_rjc)	//todo
{
	bool b=true;
	if (g_Pd[4]==0x20)												// status flag-2
	{
		b=CHECK_BIT(g_Pd[3],1);

		if(b == true)
		{
			l_s_rjc=s_error_handler( false, 4 , l_s_rjc);
		}
		else
		{																// normal
			l_s_rjc=s_error_handler( true, 4 , l_s_rjc);
		}
	}
	else																//default is normal
	{
		l_s_rjc=s_error_handler( true, 4 , l_s_rjc);
	}
	return(l_s_rjc);
}

//Byte_t done_testing(Byte_t l_s_rjc);
//{
//
//}


//------------------------------------------------------BYTE 7-----end-------------------------------------------------------
//-----------------------------------------------------------------------------------------------------------------------------


//------------------------------------------------------BYTE 8-----start-------------------------------------------------------
//-----------------------------------------------------------------------------------------------------------------------------


void rjc_sensor_value()
{
	static bool execute_once=false;

	if(execute_once==false)
	{
		if(warm_up==true)										// only if warmup is over, I will get sensor value
		{
			execute_once=true;									// don't want to execute it multiple times.
		    UARTCharPutNonBlocking(UART1_BASE,0x01);			// for getting rfid user data//upper 16 bits
		    UARTCharPutNonBlocking(UART1_BASE,0x8D);			//397d to hex.//upper 16 bits
		    UARTCharPutNonBlocking(UART1_BASE,0x00);			//lower 16bits
		    UARTCharPutNonBlocking(UART1_BASE,0x00);			//lower 16bits
		    UARTCharPutNonBlocking(UART1_BASE,0x00);
		    UARTCharPutNonBlocking(UART1_BASE,0x51);
		    UARTCharPutNonBlocking(UART1_BASE,0xC2);			//3rd seq
		    UARTCharPutNonBlocking(UART1_BASE,0x13);

		    //Display(("\n-came here1\n"));

		    while(dummy1[4]!=0xC2)								// read from rjc till we get 'C2' packet as that has serial number.
		    {

		    }

		    //Display(("\n--came here2\n"));
	    	sensor_name1=dummy1[2];
	    	sensor_name2=dummy1[3];
		}
	}
}



//------------------------------------------------------BYTE 8-----end-------------------------------------------------------
//-----------------------------------------------------------------------------------------------------------------------------