//************************************************************************************
//**  
//**  Source name:   C:\CP\Knock Sensor\kNOCK1 3_3_2025.fcfx
//**  Title:         
//**  Description:   
//**  Device:        PIC.16F.16F18424
//**  
//**  Generated by:  Flowcode v9.3.1.36
//**  Date:          Monday, March 03, 2025 14:22:39
//**  Users:         1
//**  Registered to: baz_w (19815087)
//**  Licence key: PCFQTJ
//**  
//**  
//**  https://www.flowcode.co.uk
//**  
//************************************************************************************


#define MX_PIC

#define MX_CAL_PIC

#define MX_CLK_SPEED 8000000

#define FCP_NULL Unconnected_Port

#define MX_PWM_NEW_TMR_CONF2
#include <xc.h>
#include <math.h>
//Chip Configuration Settings
__PROG_CONFIG(0x1, 0x178C);
__PROG_CONFIG(0x2, 0x2F3F);
__PROG_CONFIG(0x3, 0x3F9F);
__PROG_CONFIG(0x4, 0x1FF9);
__PROG_CONFIG(0x5, 0x3FFF);

/*========================================================================*\
   Use :Include the type definitions
\*========================================================================*/
#include "C:\ProgramData\MatrixTSL\FlowcodeV9\CAL\internals.c"





/*========================================================================*\
   Use :panel
       :Variable declarations
       :Macro function declarations
\*========================================================================*/
#define FCV_FALSE (0)
#define FCV_TRUE (1)
MX_GLOBAL MX_SINT16 FCV_SEN = (0);
MX_GLOBAL MX_SINT16 FCV_IN_Y_0 = (0);
MX_GLOBAL MX_SINT16 FCV_Y_IN = (0);
MX_GLOBAL MX_SINT16 FCV_IN_Z_0 = (0);
MX_GLOBAL MX_SINT16 FCV_Z_IN = (0);
MX_GLOBAL MX_SINT16 FCV_X_OLD = (0);
MX_GLOBAL MX_BOOL FCV_FIRST_TIME = (0);
MX_GLOBAL MX_SINT16 FCV_Y_OLD = (0);
MX_GLOBAL MX_SINT16 FCV_Z_OLD = (0);
MX_GLOBAL MX_SINT16 FCV_X_IN = (0);
MX_GLOBAL MX_SINT16 FCV_IN_X_0 = (0);

void FCM_read_Inputs();
void FCD_03d91_led_base1__TurnOn();
void FCD_03d91_led_base1__TurnOff();

/*========================================================================*\
   Use :cal_adc
       :Variable declarations
       :Macro function declarations
\*========================================================================*/
#define MX_ADC_REF1 
#define MX_ADC_TYPE_33 
#define MX_ADC_CHANNEL_4 


/*=----------------------------------------------------------------------=*\
   Use :cal_adc
       :Supplementary defines
\*=----------------------------------------------------------------------=*/
#define FC_ADC_Enable_4 FC_CAL_ADC_Enable_1
#define FC_ADC_Disable_4 FC_CAL_ADC_Disable_1
#define FC_ADC_Sample_4 FC_CAL_ADC_Sample_1

#define FCV_0aae4_cal_adc__FALSE (0)
#define FCV_0aae4_cal_adc__TRUE (1)

void FC_ADC_Disable_4();
void FC_ADC_Enable_4(MX_UINT8 FCL_CHANNEL, MX_UINT8 FCL_CONV_SPEED, MX_UINT8 FCL_VREF, MX_UINT8 FCL_T_CHARGE);
MX_UINT16 FC_ADC_Sample_4(MX_UINT8 FCL_SAMPLE_MODE);
MX_UINT16 FCD_08f44_adc_base__RawSampleInt();
MX_UINT8 FCD_08f44_adc_base__RawAverageByte(MX_UINT8 FCL_NUMSAMPLES, MX_UINT8 FCL_DELAYUS);
void FCD_08f44_adc_base__GetString(MX_CHAR *FCR_RETVAL, MX_UINT16 FCRsz_RETVAL);
MX_UINT8 FCD_08f44_adc_base__GetAverageByte(MX_UINT8 FCL_NUMSAMPLES, MX_UINT8 FCL_DELAYUS);
MX_SINT16 FCD_08f44_adc_base__RawAverageInt(MX_UINT8 FCL_NUMSAMPLES, MX_UINT8 FCL_DELAYUS);
MX_UINT16 FCD_08f44_adc_base__GetAverageInt(MX_UINT8 FCL_NUMSAMPLES, MX_UINT8 FCL_DELAYUS);
MX_FLOAT FCD_08f44_adc_base__GetVoltage();
void FCD_08f44_adc_base__RawEnable();
MX_UINT8 FCD_08f44_adc_base__RawSampleByte();
MX_UINT16 FCD_08f44_adc_base__GetInt();
void FCD_08f44_adc_base__RawDisable();
MX_UINT8 FCD_08f44_adc_base__GetByte();
#define FCD_03524_pot_color_cap4__RawSampleInt FCD_08f44_adc_base__RawSampleInt
#define FCD_03524_pot_color_cap4__RawAverageByte FCD_08f44_adc_base__RawAverageByte
#define FCD_03524_pot_color_cap4__GetString FCD_08f44_adc_base__GetString
#define FCD_03524_pot_color_cap4__GetAverageByte FCD_08f44_adc_base__GetAverageByte
#define FCD_03524_pot_color_cap4__RawAverageInt FCD_08f44_adc_base__RawAverageInt
#define FCD_03524_pot_color_cap4__GetAverageInt FCD_08f44_adc_base__GetAverageInt
#define FCD_03524_pot_color_cap4__GetVoltage FCD_08f44_adc_base__GetVoltage
#define FCD_03524_pot_color_cap4__RawEnable FCD_08f44_adc_base__RawEnable
#define FCD_03524_pot_color_cap4__RawSampleByte FCD_08f44_adc_base__RawSampleByte
#define FCD_03524_pot_color_cap4__GetInt FCD_08f44_adc_base__GetInt
#define FCD_03524_pot_color_cap4__RawDisable FCD_08f44_adc_base__RawDisable
#define FCD_03524_pot_color_cap4__GetByte FCD_08f44_adc_base__GetByte

/*========================================================================*\
   Use :cal_adc
       :Variable declarations
       :Macro function declarations
\*========================================================================*/
#define MX_ADC_REF1 
#define MX_ADC_TYPE_33 
#define MX_ADC_CHANNEL_2 


/*=----------------------------------------------------------------------=*\
   Use :cal_adc
       :Supplementary defines
\*=----------------------------------------------------------------------=*/
#define FC_ADC_Enable_3 FC_CAL_ADC_Enable_1
#define FC_ADC_Disable_3 FC_CAL_ADC_Disable_1
#define FC_ADC_Sample_3 FC_CAL_ADC_Sample_1

#define FCV_0aae3_cal_adc__FALSE (0)
#define FCV_0aae3_cal_adc__TRUE (1)

void FC_ADC_Disable_3();
void FC_ADC_Enable_3(MX_UINT8 FCL_CHANNEL, MX_UINT8 FCL_CONV_SPEED, MX_UINT8 FCL_VREF, MX_UINT8 FCL_T_CHARGE);
MX_UINT16 FC_ADC_Sample_3(MX_UINT8 FCL_SAMPLE_MODE);
MX_UINT16 FCD_08f43_adc_base__RawSampleInt();
MX_UINT8 FCD_08f43_adc_base__RawAverageByte(MX_UINT8 FCL_NUMSAMPLES, MX_UINT8 FCL_DELAYUS);
void FCD_08f43_adc_base__GetString(MX_CHAR *FCR_RETVAL, MX_UINT16 FCRsz_RETVAL);
MX_UINT8 FCD_08f43_adc_base__GetAverageByte(MX_UINT8 FCL_NUMSAMPLES, MX_UINT8 FCL_DELAYUS);
MX_SINT16 FCD_08f43_adc_base__RawAverageInt(MX_UINT8 FCL_NUMSAMPLES, MX_UINT8 FCL_DELAYUS);
MX_UINT16 FCD_08f43_adc_base__GetAverageInt(MX_UINT8 FCL_NUMSAMPLES, MX_UINT8 FCL_DELAYUS);
MX_FLOAT FCD_08f43_adc_base__GetVoltage();
void FCD_08f43_adc_base__RawEnable();
MX_UINT8 FCD_08f43_adc_base__RawSampleByte();
MX_UINT16 FCD_08f43_adc_base__GetInt();
void FCD_08f43_adc_base__RawDisable();
MX_UINT8 FCD_08f43_adc_base__GetByte();
#define FCD_03523_pot_color_cap3__RawSampleInt FCD_08f43_adc_base__RawSampleInt
#define FCD_03523_pot_color_cap3__RawAverageByte FCD_08f43_adc_base__RawAverageByte
#define FCD_03523_pot_color_cap3__GetString FCD_08f43_adc_base__GetString
#define FCD_03523_pot_color_cap3__GetAverageByte FCD_08f43_adc_base__GetAverageByte
#define FCD_03523_pot_color_cap3__RawAverageInt FCD_08f43_adc_base__RawAverageInt
#define FCD_03523_pot_color_cap3__GetAverageInt FCD_08f43_adc_base__GetAverageInt
#define FCD_03523_pot_color_cap3__GetVoltage FCD_08f43_adc_base__GetVoltage
#define FCD_03523_pot_color_cap3__RawEnable FCD_08f43_adc_base__RawEnable
#define FCD_03523_pot_color_cap3__RawSampleByte FCD_08f43_adc_base__RawSampleByte
#define FCD_03523_pot_color_cap3__GetInt FCD_08f43_adc_base__GetInt
#define FCD_03523_pot_color_cap3__RawDisable FCD_08f43_adc_base__RawDisable
#define FCD_03523_pot_color_cap3__GetByte FCD_08f43_adc_base__GetByte

/*========================================================================*\
   Use :cal_adc
       :Variable declarations
       :Macro function declarations
\*========================================================================*/
#define MX_ADC_REF1 
#define MX_ADC_TYPE_33 
#define MX_ADC_CHANNEL_1 


/*=----------------------------------------------------------------------=*\
   Use :cal_adc
       :Supplementary defines
\*=----------------------------------------------------------------------=*/
#define FC_ADC_Enable_2 FC_CAL_ADC_Enable_1
#define FC_ADC_Disable_2 FC_CAL_ADC_Disable_1
#define FC_ADC_Sample_2 FC_CAL_ADC_Sample_1

#define FCV_0aae2_cal_adc__FALSE (0)
#define FCV_0aae2_cal_adc__TRUE (1)

void FC_ADC_Disable_2();
void FC_ADC_Enable_2(MX_UINT8 FCL_CHANNEL, MX_UINT8 FCL_CONV_SPEED, MX_UINT8 FCL_VREF, MX_UINT8 FCL_T_CHARGE);
MX_UINT16 FC_ADC_Sample_2(MX_UINT8 FCL_SAMPLE_MODE);
MX_UINT16 FCD_08f42_adc_base__RawSampleInt();
MX_UINT8 FCD_08f42_adc_base__RawAverageByte(MX_UINT8 FCL_NUMSAMPLES, MX_UINT8 FCL_DELAYUS);
void FCD_08f42_adc_base__GetString(MX_CHAR *FCR_RETVAL, MX_UINT16 FCRsz_RETVAL);
MX_UINT8 FCD_08f42_adc_base__GetAverageByte(MX_UINT8 FCL_NUMSAMPLES, MX_UINT8 FCL_DELAYUS);
MX_SINT16 FCD_08f42_adc_base__RawAverageInt(MX_UINT8 FCL_NUMSAMPLES, MX_UINT8 FCL_DELAYUS);
MX_UINT16 FCD_08f42_adc_base__GetAverageInt(MX_UINT8 FCL_NUMSAMPLES, MX_UINT8 FCL_DELAYUS);
MX_FLOAT FCD_08f42_adc_base__GetVoltage();
void FCD_08f42_adc_base__RawEnable();
MX_UINT8 FCD_08f42_adc_base__RawSampleByte();
MX_UINT16 FCD_08f42_adc_base__GetInt();
void FCD_08f42_adc_base__RawDisable();
MX_UINT8 FCD_08f42_adc_base__GetByte();
#define FCD_03522_pot_color_cap2__RawSampleInt FCD_08f42_adc_base__RawSampleInt
#define FCD_03522_pot_color_cap2__RawAverageByte FCD_08f42_adc_base__RawAverageByte
#define FCD_03522_pot_color_cap2__GetString FCD_08f42_adc_base__GetString
#define FCD_03522_pot_color_cap2__GetAverageByte FCD_08f42_adc_base__GetAverageByte
#define FCD_03522_pot_color_cap2__RawAverageInt FCD_08f42_adc_base__RawAverageInt
#define FCD_03522_pot_color_cap2__GetAverageInt FCD_08f42_adc_base__GetAverageInt
#define FCD_03522_pot_color_cap2__GetVoltage FCD_08f42_adc_base__GetVoltage
#define FCD_03522_pot_color_cap2__RawEnable FCD_08f42_adc_base__RawEnable
#define FCD_03522_pot_color_cap2__RawSampleByte FCD_08f42_adc_base__RawSampleByte
#define FCD_03522_pot_color_cap2__GetInt FCD_08f42_adc_base__GetInt
#define FCD_03522_pot_color_cap2__RawDisable FCD_08f42_adc_base__RawDisable
#define FCD_03522_pot_color_cap2__GetByte FCD_08f42_adc_base__GetByte

/*========================================================================*\
   Use :cal_adc
       :Variable declarations
       :Macro function declarations
\*========================================================================*/
#define MX_ADC_REF1 
#define MX_ADC_TYPE_33 
#define MX_ADC_CHANNEL_0 


/*=----------------------------------------------------------------------=*\
   Use :cal_adc
       :Supplementary defines
\*=----------------------------------------------------------------------=*/
#define FC_ADC_Enable_1 FC_CAL_ADC_Enable_1
#define FC_ADC_Disable_1 FC_CAL_ADC_Disable_1
#define FC_ADC_Sample_1 FC_CAL_ADC_Sample_1

#define FCV_0aae1_cal_adc__FALSE (0)
#define FCV_0aae1_cal_adc__TRUE (1)

void FC_ADC_Disable_1();
void FC_ADC_Enable_1(MX_UINT8 FCL_CHANNEL, MX_UINT8 FCL_CONV_SPEED, MX_UINT8 FCL_VREF, MX_UINT8 FCL_T_CHARGE);
MX_UINT16 FC_ADC_Sample_1(MX_UINT8 FCL_SAMPLE_MODE);
MX_UINT16 FCD_08f41_adc_base__RawSampleInt();
MX_UINT8 FCD_08f41_adc_base__RawAverageByte(MX_UINT8 FCL_NUMSAMPLES, MX_UINT8 FCL_DELAYUS);
void FCD_08f41_adc_base__GetString(MX_CHAR *FCR_RETVAL, MX_UINT16 FCRsz_RETVAL);
MX_UINT8 FCD_08f41_adc_base__GetAverageByte(MX_UINT8 FCL_NUMSAMPLES, MX_UINT8 FCL_DELAYUS);
MX_SINT16 FCD_08f41_adc_base__RawAverageInt(MX_UINT8 FCL_NUMSAMPLES, MX_UINT8 FCL_DELAYUS);
MX_UINT16 FCD_08f41_adc_base__GetAverageInt(MX_UINT8 FCL_NUMSAMPLES, MX_UINT8 FCL_DELAYUS);
MX_FLOAT FCD_08f41_adc_base__GetVoltage();
void FCD_08f41_adc_base__RawEnable();
MX_UINT8 FCD_08f41_adc_base__RawSampleByte();
MX_UINT16 FCD_08f41_adc_base__GetInt();
void FCD_08f41_adc_base__RawDisable();
MX_UINT8 FCD_08f41_adc_base__GetByte();
#define FCD_03521_pot_color_cap1__RawSampleInt FCD_08f41_adc_base__RawSampleInt
#define FCD_03521_pot_color_cap1__RawAverageByte FCD_08f41_adc_base__RawAverageByte
#define FCD_03521_pot_color_cap1__GetString FCD_08f41_adc_base__GetString
#define FCD_03521_pot_color_cap1__GetAverageByte FCD_08f41_adc_base__GetAverageByte
#define FCD_03521_pot_color_cap1__RawAverageInt FCD_08f41_adc_base__RawAverageInt
#define FCD_03521_pot_color_cap1__GetAverageInt FCD_08f41_adc_base__GetAverageInt
#define FCD_03521_pot_color_cap1__GetVoltage FCD_08f41_adc_base__GetVoltage
#define FCD_03521_pot_color_cap1__RawEnable FCD_08f41_adc_base__RawEnable
#define FCD_03521_pot_color_cap1__RawSampleByte FCD_08f41_adc_base__RawSampleByte
#define FCD_03521_pot_color_cap1__GetInt FCD_08f41_adc_base__GetInt
#define FCD_03521_pot_color_cap1__RawDisable FCD_08f41_adc_base__RawDisable
#define FCD_03521_pot_color_cap1__GetByte FCD_08f41_adc_base__GetByte

/*========================================================================*\
   Use :Include the chip adaption layer
\*========================================================================*/
#include "C:\ProgramData\MatrixTSL\FlowcodeV9\CAL\includes.c"


/*========================================================================*\
   Use :led_base1
       :Macro implementations
\*========================================================================*/
/*=----------------------------------------------------------------------=*\
   Use :Turn the LED on.

       :Active high - The pin is configured to output high.

       :Active low - The pin is configured to output low.
\*=----------------------------------------------------------------------=*/
void FCD_03d91_led_base1__TurnOn()
{

	#if (1)

		// pin = polarity
		SET_PORT_PIN(A, 5, 1);

	// #else

	//Code has been optimised out by the pre-processor
	#endif

}

/*=----------------------------------------------------------------------=*\
   Use :Turn the LED off.

       :Active high - The pin is configured to output low.

       :Active low - The pin is configured to output high.
\*=----------------------------------------------------------------------=*/
void FCD_03d91_led_base1__TurnOff()
{

	#if (1)

		// pin = 1 - polarity
		SET_PORT_PIN(A, 5, 1 - 1);

	// #else

	//Code has been optimised out by the pre-processor
	#endif

}


/*========================================================================*\
   Use :adc_base
       :Macro implementations
\*========================================================================*/
/*=----------------------------------------------------------------------=*\
   Use :Background call to read the ADC at full bit depth

       :Call Enable() first
       :
       :Returns : MX_UINT16
\*=----------------------------------------------------------------------=*/
MX_UINT16 FCD_08f44_adc_base__RawSampleInt()
{
	//Local variable definitions
	MX_UINT16 FCR_RETVAL;


	FCR_RETVAL = FC_ADC_Sample_4(1);

	return (FCR_RETVAL);

}

/*=----------------------------------------------------------------------=*\
   Use :Background call to read the ADC as a byte average sample over time

       :Call Enable() before this
       :
       :Parameters for macro RawAverageByte:
       :  NumSamples : MX_UINT8
       :  DelayUs : Number of micro seconds in between taking each sample
       :
       :Returns : MX_UINT8
\*=----------------------------------------------------------------------=*/
MX_UINT8 FCD_08f44_adc_base__RawAverageByte(MX_UINT8 FCL_NUMSAMPLES, MX_UINT8 FCL_DELAYUS)
{
	//Local variable definitions
	MX_UINT16 FCL_AVERAGE = (0x0);
	MX_UINT8 FCL_COUNT = (0x0);
	MX_UINT8 FCR_RETVAL;


	if (FCL_DELAYUS > 0)
	{

		while (FCL_COUNT < FCL_NUMSAMPLES)
		{

			FC_ADC_Enable_4(4, 3, 0, FCL_DELAYUS);

			// .average = .average + cal_adc :: Sample (cal_adc :: Sample_Byte)
			// .count = .count + 1
			FCL_AVERAGE = FCL_AVERAGE + FC_ADC_Sample_4(0);
			FCL_COUNT = FCL_COUNT + 1;


		}

	} else {

		while (FCL_COUNT < FCL_NUMSAMPLES)
		{

			FC_ADC_Enable_4(4, 3, 0, 40);

			// .average = .average + cal_adc :: Sample (cal_adc :: Sample_Byte)
			// .count = .count + 1
			FCL_AVERAGE = FCL_AVERAGE + FC_ADC_Sample_4(0);
			FCL_COUNT = FCL_COUNT + 1;


		}

	}

	// .Return = .average / .count
	FCR_RETVAL = FCL_AVERAGE / FCL_COUNT;

	return (FCR_RETVAL);

}

/*=----------------------------------------------------------------------=*\
   Use :Reads the ADC as a direct voltage and returns as a string
       :
       :Returns : MX_CHAR*
\*=----------------------------------------------------------------------=*/
void FCD_08f44_adc_base__GetString(MX_CHAR *FCR_RETVAL, MX_UINT16 FCRsz_RETVAL)
{
	//Local variable definitions
	MX_FLOAT FCL_SAMPLE;


	FCL_SAMPLE = FCD_08f44_adc_base__GetVoltage();

	// .Return = FloatToString$ (.sample)
	FCI_FLOAT_TO_STRING(FCL_SAMPLE, FCV_PRECISION, FCR_RETVAL, FCRsz_RETVAL);

}

/*=----------------------------------------------------------------------=*\
   Use :Function call to read the ADC as a byte average sample over time
       :
       :Parameters for macro GetAverageByte:
       :  NumSamples : MX_UINT8
       :  DelayUs : Number of micro seconds in between taking each sample
       :
       :Returns : MX_UINT8
\*=----------------------------------------------------------------------=*/
MX_UINT8 FCD_08f44_adc_base__GetAverageByte(MX_UINT8 FCL_NUMSAMPLES, MX_UINT8 FCL_DELAYUS)
{
	//Local variable definitions
	MX_UINT8 FCR_RETVAL;


	FCR_RETVAL = FCD_08f44_adc_base__RawAverageByte(FCL_NUMSAMPLES, FCL_DELAYUS);

	FC_ADC_Disable_4();

	return (FCR_RETVAL);

}

/*=----------------------------------------------------------------------=*\
   Use :Background call to read the ADC as a full width average sample over time

       :Call Enable() before this
       :
       :Parameters for macro RawAverageInt:
       :  NumSamples : MX_UINT8
       :  DelayUs : MX_UINT8
       :
       :Returns : MX_SINT16
\*=----------------------------------------------------------------------=*/
MX_SINT16 FCD_08f44_adc_base__RawAverageInt(MX_UINT8 FCL_NUMSAMPLES, MX_UINT8 FCL_DELAYUS)
{
	//Local variable definitions
	MX_UINT32 FCL_AVERAGE = (0x0);
	MX_UINT8 FCL_COUNT = (0x0);
	MX_SINT16 FCR_RETVAL;


	if (FCL_DELAYUS > 0)
	{

		while (FCL_COUNT < FCL_NUMSAMPLES)
		{

			FC_ADC_Enable_4(4, 3, 0, FCL_DELAYUS);

			// .average = .average + cal_adc :: Sample (cal_adc :: Sample_Full)
			// .count = .count + 1
			FCL_AVERAGE = FCL_AVERAGE + FC_ADC_Sample_4(1);
			FCL_COUNT = FCL_COUNT + 1;


		}

	} else {

		while (FCL_COUNT < FCL_NUMSAMPLES)
		{

			FC_ADC_Enable_4(4, 3, 0, 40);

			// .average = .average + cal_adc :: Sample (cal_adc :: Sample_Full)
			// .count = .count + 1
			FCL_AVERAGE = FCL_AVERAGE + FC_ADC_Sample_4(1);
			FCL_COUNT = FCL_COUNT + 1;


		}

	}

	// .Return = .average / .count
	FCR_RETVAL = FCL_AVERAGE / FCL_COUNT;

	return (FCR_RETVAL);

}

/*=----------------------------------------------------------------------=*\
   Use :Function call to read the ADC as a full width average sample over time
       :
       :Parameters for macro GetAverageInt:
       :  NumSamples : MX_UINT8
       :  DelayUs : Number of micro seconds in between taking each sample
       :
       :Returns : MX_UINT16
\*=----------------------------------------------------------------------=*/
MX_UINT16 FCD_08f44_adc_base__GetAverageInt(MX_UINT8 FCL_NUMSAMPLES, MX_UINT8 FCL_DELAYUS)
{
	//Local variable definitions
	MX_UINT16 FCR_RETVAL;


	FCR_RETVAL = FCD_08f44_adc_base__RawAverageInt(FCL_NUMSAMPLES, FCL_DELAYUS);

	FC_ADC_Disable_4();

	return (FCR_RETVAL);

}

/*=----------------------------------------------------------------------=*\
   Use :Reads the ADC as a direct voltage
       :
       :Returns : MX_FLOAT
\*=----------------------------------------------------------------------=*/
MX_FLOAT FCD_08f44_adc_base__GetVoltage()
{
	//Local variable definitions
	MX_UINT16 FCL_SAMPLE;
	MX_FLOAT FCR_RETVAL;


	FC_ADC_Enable_4(4, 3, 0, 40);

	FCL_SAMPLE = FC_ADC_Sample_4(1);

	// .Return = .sample * bitmul
	FCR_RETVAL = flt_mul(flt_fromi(FCL_SAMPLE), 0.000806);

	FC_ADC_Disable_4();

	return (FCR_RETVAL);

}

/*=----------------------------------------------------------------------=*\
   Use :Enables and configures the ADC channel to be an analogue input.

       :Only one ADC channel can be enabled at a time. Any RAW functions will reference the last enabled channel only.
\*=----------------------------------------------------------------------=*/
void FCD_08f44_adc_base__RawEnable()
{

	FC_ADC_Enable_4(4, 3, 0, 40);

}

/*=----------------------------------------------------------------------=*\
   Use :Background call to read the ADC as a byte

       :Call Enable() before this
       :
       :Returns : MX_UINT8
\*=----------------------------------------------------------------------=*/
MX_UINT8 FCD_08f44_adc_base__RawSampleByte()
{
	//Local variable definitions
	MX_UINT8 FCR_RETVAL;


	FCR_RETVAL = FC_ADC_Sample_4(0);

	return (FCR_RETVAL);

}

/*=----------------------------------------------------------------------=*\
   Use :Blocking call to read the ADC at full bit depth
       :
       :Returns : MX_UINT16
\*=----------------------------------------------------------------------=*/
MX_UINT16 FCD_08f44_adc_base__GetInt()
{
	//Local variable definitions
	MX_UINT16 FCR_RETVAL;


	FC_ADC_Enable_4(4, 3, 0, 40);

	FCR_RETVAL = FC_ADC_Sample_4(1);

	FC_ADC_Disable_4();

	return (FCR_RETVAL);

}

/*=----------------------------------------------------------------------=*\
   Use :Disables the previously enabled ADC channel and converts back to digital mode.
\*=----------------------------------------------------------------------=*/
void FCD_08f44_adc_base__RawDisable()
{

	FC_ADC_Disable_4();

}

/*=----------------------------------------------------------------------=*\
   Use :Blocking call to read the ADC as a byte
       :
       :Returns : MX_UINT8
\*=----------------------------------------------------------------------=*/
MX_UINT8 FCD_08f44_adc_base__GetByte()
{
	//Local variable definitions
	MX_UINT8 FCR_RETVAL;


	FC_ADC_Enable_4(4, 3, 0, 40);

	FCR_RETVAL = FC_ADC_Sample_4(0);

	FC_ADC_Disable_4();

	return (FCR_RETVAL);

}


/*========================================================================*\
   Use :adc_base
       :Macro implementations
\*========================================================================*/
/*=----------------------------------------------------------------------=*\
   Use :Background call to read the ADC at full bit depth

       :Call Enable() first
       :
       :Returns : MX_UINT16
\*=----------------------------------------------------------------------=*/
MX_UINT16 FCD_08f43_adc_base__RawSampleInt()
{
	//Local variable definitions
	MX_UINT16 FCR_RETVAL;


	FCR_RETVAL = FC_ADC_Sample_3(1);

	return (FCR_RETVAL);

}

/*=----------------------------------------------------------------------=*\
   Use :Background call to read the ADC as a byte average sample over time

       :Call Enable() before this
       :
       :Parameters for macro RawAverageByte:
       :  NumSamples : MX_UINT8
       :  DelayUs : Number of micro seconds in between taking each sample
       :
       :Returns : MX_UINT8
\*=----------------------------------------------------------------------=*/
MX_UINT8 FCD_08f43_adc_base__RawAverageByte(MX_UINT8 FCL_NUMSAMPLES, MX_UINT8 FCL_DELAYUS)
{
	//Local variable definitions
	MX_UINT16 FCL_AVERAGE = (0x0);
	MX_UINT8 FCL_COUNT = (0x0);
	MX_UINT8 FCR_RETVAL;


	if (FCL_DELAYUS > 0)
	{

		while (FCL_COUNT < FCL_NUMSAMPLES)
		{

			FC_ADC_Enable_3(2, 3, 0, FCL_DELAYUS);

			// .average = .average + cal_adc :: Sample (cal_adc :: Sample_Byte)
			// .count = .count + 1
			FCL_AVERAGE = FCL_AVERAGE + FC_ADC_Sample_3(0);
			FCL_COUNT = FCL_COUNT + 1;


		}

	} else {

		while (FCL_COUNT < FCL_NUMSAMPLES)
		{

			FC_ADC_Enable_3(2, 3, 0, 40);

			// .average = .average + cal_adc :: Sample (cal_adc :: Sample_Byte)
			// .count = .count + 1
			FCL_AVERAGE = FCL_AVERAGE + FC_ADC_Sample_3(0);
			FCL_COUNT = FCL_COUNT + 1;


		}

	}

	// .Return = .average / .count
	FCR_RETVAL = FCL_AVERAGE / FCL_COUNT;

	return (FCR_RETVAL);

}

/*=----------------------------------------------------------------------=*\
   Use :Reads the ADC as a direct voltage and returns as a string
       :
       :Returns : MX_CHAR*
\*=----------------------------------------------------------------------=*/
void FCD_08f43_adc_base__GetString(MX_CHAR *FCR_RETVAL, MX_UINT16 FCRsz_RETVAL)
{
	//Local variable definitions
	MX_FLOAT FCL_SAMPLE;


	FCL_SAMPLE = FCD_08f43_adc_base__GetVoltage();

	// .Return = FloatToString$ (.sample)
	FCI_FLOAT_TO_STRING(FCL_SAMPLE, FCV_PRECISION, FCR_RETVAL, FCRsz_RETVAL);

}

/*=----------------------------------------------------------------------=*\
   Use :Function call to read the ADC as a byte average sample over time
       :
       :Parameters for macro GetAverageByte:
       :  NumSamples : MX_UINT8
       :  DelayUs : Number of micro seconds in between taking each sample
       :
       :Returns : MX_UINT8
\*=----------------------------------------------------------------------=*/
MX_UINT8 FCD_08f43_adc_base__GetAverageByte(MX_UINT8 FCL_NUMSAMPLES, MX_UINT8 FCL_DELAYUS)
{
	//Local variable definitions
	MX_UINT8 FCR_RETVAL;


	FCR_RETVAL = FCD_08f43_adc_base__RawAverageByte(FCL_NUMSAMPLES, FCL_DELAYUS);

	FC_ADC_Disable_3();

	return (FCR_RETVAL);

}

/*=----------------------------------------------------------------------=*\
   Use :Background call to read the ADC as a full width average sample over time

       :Call Enable() before this
       :
       :Parameters for macro RawAverageInt:
       :  NumSamples : MX_UINT8
       :  DelayUs : MX_UINT8
       :
       :Returns : MX_SINT16
\*=----------------------------------------------------------------------=*/
MX_SINT16 FCD_08f43_adc_base__RawAverageInt(MX_UINT8 FCL_NUMSAMPLES, MX_UINT8 FCL_DELAYUS)
{
	//Local variable definitions
	MX_UINT32 FCL_AVERAGE = (0x0);
	MX_UINT8 FCL_COUNT = (0x0);
	MX_SINT16 FCR_RETVAL;


	if (FCL_DELAYUS > 0)
	{

		while (FCL_COUNT < FCL_NUMSAMPLES)
		{

			FC_ADC_Enable_3(2, 3, 0, FCL_DELAYUS);

			// .average = .average + cal_adc :: Sample (cal_adc :: Sample_Full)
			// .count = .count + 1
			FCL_AVERAGE = FCL_AVERAGE + FC_ADC_Sample_3(1);
			FCL_COUNT = FCL_COUNT + 1;


		}

	} else {

		while (FCL_COUNT < FCL_NUMSAMPLES)
		{

			FC_ADC_Enable_3(2, 3, 0, 40);

			// .average = .average + cal_adc :: Sample (cal_adc :: Sample_Full)
			// .count = .count + 1
			FCL_AVERAGE = FCL_AVERAGE + FC_ADC_Sample_3(1);
			FCL_COUNT = FCL_COUNT + 1;


		}

	}

	// .Return = .average / .count
	FCR_RETVAL = FCL_AVERAGE / FCL_COUNT;

	return (FCR_RETVAL);

}

/*=----------------------------------------------------------------------=*\
   Use :Function call to read the ADC as a full width average sample over time
       :
       :Parameters for macro GetAverageInt:
       :  NumSamples : MX_UINT8
       :  DelayUs : Number of micro seconds in between taking each sample
       :
       :Returns : MX_UINT16
\*=----------------------------------------------------------------------=*/
MX_UINT16 FCD_08f43_adc_base__GetAverageInt(MX_UINT8 FCL_NUMSAMPLES, MX_UINT8 FCL_DELAYUS)
{
	//Local variable definitions
	MX_UINT16 FCR_RETVAL;


	FCR_RETVAL = FCD_08f43_adc_base__RawAverageInt(FCL_NUMSAMPLES, FCL_DELAYUS);

	FC_ADC_Disable_3();

	return (FCR_RETVAL);

}

/*=----------------------------------------------------------------------=*\
   Use :Reads the ADC as a direct voltage
       :
       :Returns : MX_FLOAT
\*=----------------------------------------------------------------------=*/
MX_FLOAT FCD_08f43_adc_base__GetVoltage()
{
	//Local variable definitions
	MX_UINT16 FCL_SAMPLE;
	MX_FLOAT FCR_RETVAL;


	FC_ADC_Enable_3(2, 3, 0, 40);

	FCL_SAMPLE = FC_ADC_Sample_3(1);

	// .Return = .sample * bitmul
	FCR_RETVAL = flt_mul(flt_fromi(FCL_SAMPLE), 0.000806);

	FC_ADC_Disable_3();

	return (FCR_RETVAL);

}

/*=----------------------------------------------------------------------=*\
   Use :Enables and configures the ADC channel to be an analogue input.

       :Only one ADC channel can be enabled at a time. Any RAW functions will reference the last enabled channel only.
\*=----------------------------------------------------------------------=*/
void FCD_08f43_adc_base__RawEnable()
{

	FC_ADC_Enable_3(2, 3, 0, 40);

}

/*=----------------------------------------------------------------------=*\
   Use :Background call to read the ADC as a byte

       :Call Enable() before this
       :
       :Returns : MX_UINT8
\*=----------------------------------------------------------------------=*/
MX_UINT8 FCD_08f43_adc_base__RawSampleByte()
{
	//Local variable definitions
	MX_UINT8 FCR_RETVAL;


	FCR_RETVAL = FC_ADC_Sample_3(0);

	return (FCR_RETVAL);

}

/*=----------------------------------------------------------------------=*\
   Use :Blocking call to read the ADC at full bit depth
       :
       :Returns : MX_UINT16
\*=----------------------------------------------------------------------=*/
MX_UINT16 FCD_08f43_adc_base__GetInt()
{
	//Local variable definitions
	MX_UINT16 FCR_RETVAL;


	FC_ADC_Enable_3(2, 3, 0, 40);

	FCR_RETVAL = FC_ADC_Sample_3(1);

	FC_ADC_Disable_3();

	return (FCR_RETVAL);

}

/*=----------------------------------------------------------------------=*\
   Use :Disables the previously enabled ADC channel and converts back to digital mode.
\*=----------------------------------------------------------------------=*/
void FCD_08f43_adc_base__RawDisable()
{

	FC_ADC_Disable_3();

}

/*=----------------------------------------------------------------------=*\
   Use :Blocking call to read the ADC as a byte
       :
       :Returns : MX_UINT8
\*=----------------------------------------------------------------------=*/
MX_UINT8 FCD_08f43_adc_base__GetByte()
{
	//Local variable definitions
	MX_UINT8 FCR_RETVAL;


	FC_ADC_Enable_3(2, 3, 0, 40);

	FCR_RETVAL = FC_ADC_Sample_3(0);

	FC_ADC_Disable_3();

	return (FCR_RETVAL);

}


/*========================================================================*\
   Use :adc_base
       :Macro implementations
\*========================================================================*/
/*=----------------------------------------------------------------------=*\
   Use :Background call to read the ADC at full bit depth

       :Call Enable() first
       :
       :Returns : MX_UINT16
\*=----------------------------------------------------------------------=*/
MX_UINT16 FCD_08f42_adc_base__RawSampleInt()
{
	//Local variable definitions
	MX_UINT16 FCR_RETVAL;


	FCR_RETVAL = FC_ADC_Sample_2(1);

	return (FCR_RETVAL);

}

/*=----------------------------------------------------------------------=*\
   Use :Background call to read the ADC as a byte average sample over time

       :Call Enable() before this
       :
       :Parameters for macro RawAverageByte:
       :  NumSamples : MX_UINT8
       :  DelayUs : Number of micro seconds in between taking each sample
       :
       :Returns : MX_UINT8
\*=----------------------------------------------------------------------=*/
MX_UINT8 FCD_08f42_adc_base__RawAverageByte(MX_UINT8 FCL_NUMSAMPLES, MX_UINT8 FCL_DELAYUS)
{
	//Local variable definitions
	MX_UINT16 FCL_AVERAGE = (0x0);
	MX_UINT8 FCL_COUNT = (0x0);
	MX_UINT8 FCR_RETVAL;


	if (FCL_DELAYUS > 0)
	{

		while (FCL_COUNT < FCL_NUMSAMPLES)
		{

			FC_ADC_Enable_2(1, 3, 0, FCL_DELAYUS);

			// .average = .average + cal_adc :: Sample (cal_adc :: Sample_Byte)
			// .count = .count + 1
			FCL_AVERAGE = FCL_AVERAGE + FC_ADC_Sample_2(0);
			FCL_COUNT = FCL_COUNT + 1;


		}

	} else {

		while (FCL_COUNT < FCL_NUMSAMPLES)
		{

			FC_ADC_Enable_2(1, 3, 0, 40);

			// .average = .average + cal_adc :: Sample (cal_adc :: Sample_Byte)
			// .count = .count + 1
			FCL_AVERAGE = FCL_AVERAGE + FC_ADC_Sample_2(0);
			FCL_COUNT = FCL_COUNT + 1;


		}

	}

	// .Return = .average / .count
	FCR_RETVAL = FCL_AVERAGE / FCL_COUNT;

	return (FCR_RETVAL);

}

/*=----------------------------------------------------------------------=*\
   Use :Reads the ADC as a direct voltage and returns as a string
       :
       :Returns : MX_CHAR*
\*=----------------------------------------------------------------------=*/
void FCD_08f42_adc_base__GetString(MX_CHAR *FCR_RETVAL, MX_UINT16 FCRsz_RETVAL)
{
	//Local variable definitions
	MX_FLOAT FCL_SAMPLE;


	FCL_SAMPLE = FCD_08f42_adc_base__GetVoltage();

	// .Return = FloatToString$ (.sample)
	FCI_FLOAT_TO_STRING(FCL_SAMPLE, FCV_PRECISION, FCR_RETVAL, FCRsz_RETVAL);

}

/*=----------------------------------------------------------------------=*\
   Use :Function call to read the ADC as a byte average sample over time
       :
       :Parameters for macro GetAverageByte:
       :  NumSamples : MX_UINT8
       :  DelayUs : Number of micro seconds in between taking each sample
       :
       :Returns : MX_UINT8
\*=----------------------------------------------------------------------=*/
MX_UINT8 FCD_08f42_adc_base__GetAverageByte(MX_UINT8 FCL_NUMSAMPLES, MX_UINT8 FCL_DELAYUS)
{
	//Local variable definitions
	MX_UINT8 FCR_RETVAL;


	FCR_RETVAL = FCD_08f42_adc_base__RawAverageByte(FCL_NUMSAMPLES, FCL_DELAYUS);

	FC_ADC_Disable_2();

	return (FCR_RETVAL);

}

/*=----------------------------------------------------------------------=*\
   Use :Background call to read the ADC as a full width average sample over time

       :Call Enable() before this
       :
       :Parameters for macro RawAverageInt:
       :  NumSamples : MX_UINT8
       :  DelayUs : MX_UINT8
       :
       :Returns : MX_SINT16
\*=----------------------------------------------------------------------=*/
MX_SINT16 FCD_08f42_adc_base__RawAverageInt(MX_UINT8 FCL_NUMSAMPLES, MX_UINT8 FCL_DELAYUS)
{
	//Local variable definitions
	MX_UINT32 FCL_AVERAGE = (0x0);
	MX_UINT8 FCL_COUNT = (0x0);
	MX_SINT16 FCR_RETVAL;


	if (FCL_DELAYUS > 0)
	{

		while (FCL_COUNT < FCL_NUMSAMPLES)
		{

			FC_ADC_Enable_2(1, 3, 0, FCL_DELAYUS);

			// .average = .average + cal_adc :: Sample (cal_adc :: Sample_Full)
			// .count = .count + 1
			FCL_AVERAGE = FCL_AVERAGE + FC_ADC_Sample_2(1);
			FCL_COUNT = FCL_COUNT + 1;


		}

	} else {

		while (FCL_COUNT < FCL_NUMSAMPLES)
		{

			FC_ADC_Enable_2(1, 3, 0, 40);

			// .average = .average + cal_adc :: Sample (cal_adc :: Sample_Full)
			// .count = .count + 1
			FCL_AVERAGE = FCL_AVERAGE + FC_ADC_Sample_2(1);
			FCL_COUNT = FCL_COUNT + 1;


		}

	}

	// .Return = .average / .count
	FCR_RETVAL = FCL_AVERAGE / FCL_COUNT;

	return (FCR_RETVAL);

}

/*=----------------------------------------------------------------------=*\
   Use :Function call to read the ADC as a full width average sample over time
       :
       :Parameters for macro GetAverageInt:
       :  NumSamples : MX_UINT8
       :  DelayUs : Number of micro seconds in between taking each sample
       :
       :Returns : MX_UINT16
\*=----------------------------------------------------------------------=*/
MX_UINT16 FCD_08f42_adc_base__GetAverageInt(MX_UINT8 FCL_NUMSAMPLES, MX_UINT8 FCL_DELAYUS)
{
	//Local variable definitions
	MX_UINT16 FCR_RETVAL;


	FCR_RETVAL = FCD_08f42_adc_base__RawAverageInt(FCL_NUMSAMPLES, FCL_DELAYUS);

	FC_ADC_Disable_2();

	return (FCR_RETVAL);

}

/*=----------------------------------------------------------------------=*\
   Use :Reads the ADC as a direct voltage
       :
       :Returns : MX_FLOAT
\*=----------------------------------------------------------------------=*/
MX_FLOAT FCD_08f42_adc_base__GetVoltage()
{
	//Local variable definitions
	MX_UINT16 FCL_SAMPLE;
	MX_FLOAT FCR_RETVAL;


	FC_ADC_Enable_2(1, 3, 0, 40);

	FCL_SAMPLE = FC_ADC_Sample_2(1);

	// .Return = .sample * bitmul
	FCR_RETVAL = flt_mul(flt_fromi(FCL_SAMPLE), 0.000806);

	FC_ADC_Disable_2();

	return (FCR_RETVAL);

}

/*=----------------------------------------------------------------------=*\
   Use :Enables and configures the ADC channel to be an analogue input.

       :Only one ADC channel can be enabled at a time. Any RAW functions will reference the last enabled channel only.
\*=----------------------------------------------------------------------=*/
void FCD_08f42_adc_base__RawEnable()
{

	FC_ADC_Enable_2(1, 3, 0, 40);

}

/*=----------------------------------------------------------------------=*\
   Use :Background call to read the ADC as a byte

       :Call Enable() before this
       :
       :Returns : MX_UINT8
\*=----------------------------------------------------------------------=*/
MX_UINT8 FCD_08f42_adc_base__RawSampleByte()
{
	//Local variable definitions
	MX_UINT8 FCR_RETVAL;


	FCR_RETVAL = FC_ADC_Sample_2(0);

	return (FCR_RETVAL);

}

/*=----------------------------------------------------------------------=*\
   Use :Blocking call to read the ADC at full bit depth
       :
       :Returns : MX_UINT16
\*=----------------------------------------------------------------------=*/
MX_UINT16 FCD_08f42_adc_base__GetInt()
{
	//Local variable definitions
	MX_UINT16 FCR_RETVAL;


	FC_ADC_Enable_2(1, 3, 0, 40);

	FCR_RETVAL = FC_ADC_Sample_2(1);

	FC_ADC_Disable_2();

	return (FCR_RETVAL);

}

/*=----------------------------------------------------------------------=*\
   Use :Disables the previously enabled ADC channel and converts back to digital mode.
\*=----------------------------------------------------------------------=*/
void FCD_08f42_adc_base__RawDisable()
{

	FC_ADC_Disable_2();

}

/*=----------------------------------------------------------------------=*\
   Use :Blocking call to read the ADC as a byte
       :
       :Returns : MX_UINT8
\*=----------------------------------------------------------------------=*/
MX_UINT8 FCD_08f42_adc_base__GetByte()
{
	//Local variable definitions
	MX_UINT8 FCR_RETVAL;


	FC_ADC_Enable_2(1, 3, 0, 40);

	FCR_RETVAL = FC_ADC_Sample_2(0);

	FC_ADC_Disable_2();

	return (FCR_RETVAL);

}


/*========================================================================*\
   Use :adc_base
       :Macro implementations
\*========================================================================*/
/*=----------------------------------------------------------------------=*\
   Use :Background call to read the ADC at full bit depth

       :Call Enable() first
       :
       :Returns : MX_UINT16
\*=----------------------------------------------------------------------=*/
MX_UINT16 FCD_08f41_adc_base__RawSampleInt()
{
	//Local variable definitions
	MX_UINT16 FCR_RETVAL;


	FCR_RETVAL = FC_ADC_Sample_1(1);

	return (FCR_RETVAL);

}

/*=----------------------------------------------------------------------=*\
   Use :Background call to read the ADC as a byte average sample over time

       :Call Enable() before this
       :
       :Parameters for macro RawAverageByte:
       :  NumSamples : MX_UINT8
       :  DelayUs : Number of micro seconds in between taking each sample
       :
       :Returns : MX_UINT8
\*=----------------------------------------------------------------------=*/
MX_UINT8 FCD_08f41_adc_base__RawAverageByte(MX_UINT8 FCL_NUMSAMPLES, MX_UINT8 FCL_DELAYUS)
{
	//Local variable definitions
	MX_UINT16 FCL_AVERAGE = (0x0);
	MX_UINT8 FCL_COUNT = (0x0);
	MX_UINT8 FCR_RETVAL;


	if (FCL_DELAYUS > 0)
	{

		while (FCL_COUNT < FCL_NUMSAMPLES)
		{

			FC_ADC_Enable_1(0, 3, 0, FCL_DELAYUS);

			// .average = .average + cal_adc :: Sample (cal_adc :: Sample_Byte)
			// .count = .count + 1
			FCL_AVERAGE = FCL_AVERAGE + FC_ADC_Sample_1(0);
			FCL_COUNT = FCL_COUNT + 1;


		}

	} else {

		while (FCL_COUNT < FCL_NUMSAMPLES)
		{

			FC_ADC_Enable_1(0, 3, 0, 40);

			// .average = .average + cal_adc :: Sample (cal_adc :: Sample_Byte)
			// .count = .count + 1
			FCL_AVERAGE = FCL_AVERAGE + FC_ADC_Sample_1(0);
			FCL_COUNT = FCL_COUNT + 1;


		}

	}

	// .Return = .average / .count
	FCR_RETVAL = FCL_AVERAGE / FCL_COUNT;

	return (FCR_RETVAL);

}

/*=----------------------------------------------------------------------=*\
   Use :Reads the ADC as a direct voltage and returns as a string
       :
       :Returns : MX_CHAR*
\*=----------------------------------------------------------------------=*/
void FCD_08f41_adc_base__GetString(MX_CHAR *FCR_RETVAL, MX_UINT16 FCRsz_RETVAL)
{
	//Local variable definitions
	MX_FLOAT FCL_SAMPLE;


	FCL_SAMPLE = FCD_08f41_adc_base__GetVoltage();

	// .Return = FloatToString$ (.sample)
	FCI_FLOAT_TO_STRING(FCL_SAMPLE, FCV_PRECISION, FCR_RETVAL, FCRsz_RETVAL);

}

/*=----------------------------------------------------------------------=*\
   Use :Function call to read the ADC as a byte average sample over time
       :
       :Parameters for macro GetAverageByte:
       :  NumSamples : MX_UINT8
       :  DelayUs : Number of micro seconds in between taking each sample
       :
       :Returns : MX_UINT8
\*=----------------------------------------------------------------------=*/
MX_UINT8 FCD_08f41_adc_base__GetAverageByte(MX_UINT8 FCL_NUMSAMPLES, MX_UINT8 FCL_DELAYUS)
{
	//Local variable definitions
	MX_UINT8 FCR_RETVAL;


	FCR_RETVAL = FCD_08f41_adc_base__RawAverageByte(FCL_NUMSAMPLES, FCL_DELAYUS);

	FC_ADC_Disable_1();

	return (FCR_RETVAL);

}

/*=----------------------------------------------------------------------=*\
   Use :Background call to read the ADC as a full width average sample over time

       :Call Enable() before this
       :
       :Parameters for macro RawAverageInt:
       :  NumSamples : MX_UINT8
       :  DelayUs : MX_UINT8
       :
       :Returns : MX_SINT16
\*=----------------------------------------------------------------------=*/
MX_SINT16 FCD_08f41_adc_base__RawAverageInt(MX_UINT8 FCL_NUMSAMPLES, MX_UINT8 FCL_DELAYUS)
{
	//Local variable definitions
	MX_UINT32 FCL_AVERAGE = (0x0);
	MX_UINT8 FCL_COUNT = (0x0);
	MX_SINT16 FCR_RETVAL;


	if (FCL_DELAYUS > 0)
	{

		while (FCL_COUNT < FCL_NUMSAMPLES)
		{

			FC_ADC_Enable_1(0, 3, 0, FCL_DELAYUS);

			// .average = .average + cal_adc :: Sample (cal_adc :: Sample_Full)
			// .count = .count + 1
			FCL_AVERAGE = FCL_AVERAGE + FC_ADC_Sample_1(1);
			FCL_COUNT = FCL_COUNT + 1;


		}

	} else {

		while (FCL_COUNT < FCL_NUMSAMPLES)
		{

			FC_ADC_Enable_1(0, 3, 0, 40);

			// .average = .average + cal_adc :: Sample (cal_adc :: Sample_Full)
			// .count = .count + 1
			FCL_AVERAGE = FCL_AVERAGE + FC_ADC_Sample_1(1);
			FCL_COUNT = FCL_COUNT + 1;


		}

	}

	// .Return = .average / .count
	FCR_RETVAL = FCL_AVERAGE / FCL_COUNT;

	return (FCR_RETVAL);

}

/*=----------------------------------------------------------------------=*\
   Use :Function call to read the ADC as a full width average sample over time
       :
       :Parameters for macro GetAverageInt:
       :  NumSamples : MX_UINT8
       :  DelayUs : Number of micro seconds in between taking each sample
       :
       :Returns : MX_UINT16
\*=----------------------------------------------------------------------=*/
MX_UINT16 FCD_08f41_adc_base__GetAverageInt(MX_UINT8 FCL_NUMSAMPLES, MX_UINT8 FCL_DELAYUS)
{
	//Local variable definitions
	MX_UINT16 FCR_RETVAL;


	FCR_RETVAL = FCD_08f41_adc_base__RawAverageInt(FCL_NUMSAMPLES, FCL_DELAYUS);

	FC_ADC_Disable_1();

	return (FCR_RETVAL);

}

/*=----------------------------------------------------------------------=*\
   Use :Reads the ADC as a direct voltage
       :
       :Returns : MX_FLOAT
\*=----------------------------------------------------------------------=*/
MX_FLOAT FCD_08f41_adc_base__GetVoltage()
{
	//Local variable definitions
	MX_UINT16 FCL_SAMPLE;
	MX_FLOAT FCR_RETVAL;


	FC_ADC_Enable_1(0, 3, 0, 40);

	FCL_SAMPLE = FC_ADC_Sample_1(1);

	// .Return = .sample * bitmul
	FCR_RETVAL = flt_mul(flt_fromi(FCL_SAMPLE), 0.000806);

	FC_ADC_Disable_1();

	return (FCR_RETVAL);

}

/*=----------------------------------------------------------------------=*\
   Use :Enables and configures the ADC channel to be an analogue input.

       :Only one ADC channel can be enabled at a time. Any RAW functions will reference the last enabled channel only.
\*=----------------------------------------------------------------------=*/
void FCD_08f41_adc_base__RawEnable()
{

	FC_ADC_Enable_1(0, 3, 0, 40);

}

/*=----------------------------------------------------------------------=*\
   Use :Background call to read the ADC as a byte

       :Call Enable() before this
       :
       :Returns : MX_UINT8
\*=----------------------------------------------------------------------=*/
MX_UINT8 FCD_08f41_adc_base__RawSampleByte()
{
	//Local variable definitions
	MX_UINT8 FCR_RETVAL;


	FCR_RETVAL = FC_ADC_Sample_1(0);

	return (FCR_RETVAL);

}

/*=----------------------------------------------------------------------=*\
   Use :Blocking call to read the ADC at full bit depth
       :
       :Returns : MX_UINT16
\*=----------------------------------------------------------------------=*/
MX_UINT16 FCD_08f41_adc_base__GetInt()
{
	//Local variable definitions
	MX_UINT16 FCR_RETVAL;


	FC_ADC_Enable_1(0, 3, 0, 40);

	FCR_RETVAL = FC_ADC_Sample_1(1);

	FC_ADC_Disable_1();

	return (FCR_RETVAL);

}

/*=----------------------------------------------------------------------=*\
   Use :Disables the previously enabled ADC channel and converts back to digital mode.
\*=----------------------------------------------------------------------=*/
void FCD_08f41_adc_base__RawDisable()
{

	FC_ADC_Disable_1();

}

/*=----------------------------------------------------------------------=*\
   Use :Blocking call to read the ADC as a byte
       :
       :Returns : MX_UINT8
\*=----------------------------------------------------------------------=*/
MX_UINT8 FCD_08f41_adc_base__GetByte()
{
	//Local variable definitions
	MX_UINT8 FCR_RETVAL;


	FC_ADC_Enable_1(0, 3, 0, 40);

	FCR_RETVAL = FC_ADC_Sample_1(0);

	FC_ADC_Disable_1();

	return (FCR_RETVAL);

}


/*========================================================================*\
   Use :panel
       :Macro implementations
\*========================================================================*/
/*=----------------------------------------------------------------------=*\
   Use :
\*=----------------------------------------------------------------------=*/
void FCM_read_Inputs()
{

	// Name: Component Macro, Type: Component Macro: X_IN=pot_color_cap1::GetInt()
	FCV_X_IN = FCD_03521_pot_color_cap1__GetInt();

	// Name: Component Macro, Type: Component Macro: Y_IN=pot_color_cap2::GetInt()
	FCV_Y_IN = FCD_03522_pot_color_cap2__GetInt();

	// Name: Component Macro, Type: Component Macro: Z_IN=pot_color_cap3::GetInt()
	FCV_Z_IN = FCD_03523_pot_color_cap3__GetInt();

	// Name: Component Macro, Type: Component Macro: Sen=pot_color_cap4::GetInt()
	FCV_SEN = FCD_03524_pot_color_cap4__GetInt();

}



/*========================================================================*\
   Use :Main
\*========================================================================*/
void main()
{
	#ifdef INTOSCHELPER
		INTOSCHELPERCODE
	#endif
ANSELA = 0x00;
ANSELC = 0x00;


	// Name: C Code, Type: C Code:
	/*
	  Enter C code below this comment
	*/

	// Name: Delay, Type: Delay: 1 ms
	FCI_DELAYBYTE_MS(1);

	// Name: Read Inputs, Type: User Macro: read_Inputs()
	FCM_read_Inputs();

	// Name: Calculation, Type: Calculation:
	// In_X_0 = X_IN
	// In_Y_0 = Y_IN
	// In_Z_0 = Z_IN
	// First_time = 1
	FCV_IN_X_0 = FCV_X_IN;
	FCV_IN_Y_0 = FCV_Y_IN;
	FCV_IN_Z_0 = FCV_Z_IN;
	FCV_FIRST_TIME = 1;

	// Name: Loop, Type: Loop: While 1
	while (1)
	{

		// Name: User Macro, Type: User Macro: read_Inputs()
		FCM_read_Inputs();

		// Name: Calculation, Type: Calculation:
		// Sen = Sen / 4
		FCV_SEN = FCV_SEN / 4;

		// Name: Decision, Type: Decision: X_IN < In_X_0?
		if (FCV_X_IN < FCV_IN_X_0)
		{

			// Name: Calculation, Type: Calculation:
			// X_IN = In_X_0 - X_IN
			FCV_X_IN = FCV_IN_X_0 - FCV_X_IN;

		} else {

			// Name: Calculation, Type: Calculation:
			// X_IN = X_IN - In_X_0
			FCV_X_IN = FCV_X_IN - FCV_IN_X_0;

		}

		// Name: Decision, Type: Decision: Y_IN < In_Y_0?
		if (FCV_Y_IN < FCV_IN_Y_0)
		{

			// Name: Calculation, Type: Calculation:
			// Y_IN = In_Y_0 - Y_IN
			FCV_Y_IN = FCV_IN_Y_0 - FCV_Y_IN;

		} else {

			// Name: Calculation, Type: Calculation:
			// Y_IN = Y_IN - In_Y_0
			FCV_Y_IN = FCV_Y_IN - FCV_IN_Y_0;

		}

		// Name: Decision, Type: Decision: Z_IN < In_Z_0?
		if (FCV_Z_IN < FCV_IN_Z_0)
		{

			// Name: Calculation, Type: Calculation:
			// Z_IN = In_Z_0 - Z_IN
			FCV_Z_IN = FCV_IN_Z_0 - FCV_Z_IN;

		} else {

			// Name: Calculation, Type: Calculation:
			// Z_IN = Z_IN - In_Z_0
			FCV_Z_IN = FCV_Z_IN - FCV_IN_Z_0;

		}

		// Name: set xyz old, Type: Decision: First_time = 1?
		if (FCV_FIRST_TIME == 1)
		{

			// Name: Calculation, Type: Calculation:
			// X_Old = X_IN
			// Y_Old = Y_IN
			// Z_Old = Z_IN
			// First_time = 0
			FCV_X_OLD = FCV_X_IN;
			FCV_Y_OLD = FCV_Y_IN;
			FCV_Z_OLD = FCV_Z_IN;
			FCV_FIRST_TIME = 0;

		// } else {

		}

		// Name: trip level, Type: Decision: X_IN > X_Old + Sen || X_IN < X_Old - Sen || Y_IN > Y_Old + Sen || Y_IN < Y_Old - Sen || Z_IN > Z_Old + Sen || Z_IN < Z_Old - Sen?
		if (FCV_X_IN > FCV_X_OLD + FCV_SEN || FCV_X_IN < FCV_X_OLD - FCV_SEN || FCV_Y_IN > FCV_Y_OLD + FCV_SEN || FCV_Y_IN < FCV_Y_OLD - FCV_SEN || FCV_Z_IN > FCV_Z_OLD + FCV_SEN || FCV_Z_IN < FCV_Z_OLD - FCV_SEN)
		{

			// Name: Output, Type: Output: 1 -> A5
			SET_PORT_PIN(A,5,(1));

			// Name: Delay, Type: Delay: 1 s
			FCI_DELAYBYTE_S(1);

			// Name: Output, Type: Output: 0 -> A5
			SET_PORT_PIN(A,5,(0));

		// } else {

		}

		// Name: Calculation, Type: Calculation:
		// X_Old = X_IN
		// Y_Old = Y_IN
		// Z_Old = Z_IN
		FCV_X_OLD = FCV_X_IN;
		FCV_Y_OLD = FCV_Y_IN;
		FCV_Z_OLD = FCV_Z_IN;


	}

	mainendloop: goto mainendloop;
}



/*========================================================================*\
   Use :Interrupt
\*========================================================================*/
void MX_INTERRUPT_MACRO(void)
{

}