//************************************************************************************
//**  
//**  File name:     E:\Mes Documents\Flowcode\DS1820\DS18B20 temp_3_v5.c
//**  Title:         
//**  Description:   
//**  
//**  Generated by:  Flowcode v5.5.2.1
//**  Date:          Wednesday, June 19, 2013 09:51:34
//**  Licence:       Professional
//**  Registered to: LYCEE-TRUFFAUT
//**  Licence key:   V08XEC
//**  
//**  
//**  http://www.matrixmultimedia.com
//**  
//************************************************************************************


#define MX_PIC

#define MX_USES_UINT8 1
#define MX_USES_SINT16 1
#define MX_USES_CHAR 2
#define MX_USES_FLOAT 0
#define MX_USES_SINT32 0
#define MX_USES_BOOL 0
#define MX_USES_UINT16 0
#define MX_USES_UINT32 0
//Définir pour microcontrôleur
#define P16F88
#define FC_CAL_PIC
#define MX_ADC
#define MX_ADC_TYPE_2
#define MX_ADC_BITS_10
#define MX_EE
#define MX_EE_TYPE2
#define MX_EE_SIZE 256
#define MX_SPI_1
#define MX_SPI_1_MISO_PORT portb
#define MX_SPI_1_MISO_TRIS trisb
#define MX_SPI_1_MISO_PIN 1
#define MX_SPI_1_MOSI_PORT portb
#define MX_SPI_1_MOSI_TRIS trisb
#define MX_SPI_1_MOSI_PIN 2
#define MX_SPI_1_CLK_PORT portb
#define MX_SPI_1_CLK_TRIS trisb
#define MX_SPI_1_CLK_PIN 4
#define MX_SPI_1_SS_PORT portb
#define MX_SPI_1_SS_TRIS trisb
#define MX_UART_1
#define MX_UART_1_TX_PORT portb
#define MX_UART_1_TX_TRIS trisb
#define MX_UART_1_TX_PIN 5
#define MX_UART_1_RX_PORT portb
#define MX_UART_1_RX_TRIS trisb
#define MX_UART_1_RX_PIN 2
#define MX_I2C
#define MX_I2C_1
#define MX_I2C_1_SDA_PORT portb
#define MX_I2C_1_SDA_TRIS trisb
#define MX_I2C_1_SDA_PIN 1
#define MX_I2C_1_SCL_PORT portb
#define MX_I2C_1_SCL_TRIS trisb
#define MX_I2C_1_SCL_PIN 4
#define MX_PWM
#define MX_PWM_CNT 1
#define MX_PWM_PSCA1
#define MX_PWM_PSCA4
#define MX_PWM_PSCA16
#define MX_PWM_1_PORT portb
#define MX_PWM_1_TRIS trisb
#define MX_PWM_1_PIN 0
#define MX_PWM_1_PORT_A portb
#define MX_PWM_1_TRIS_A trisb
#define MX_PWM_1_PIN_A 3

//Fonctions
#define MX_CLK_SPEED 8000000
#ifdef _BOOSTC
#include <system.h>
#endif
#ifdef HI_TECH_C
#include <pic.h>
#endif

//Données de Configuration
#ifdef _BOOSTC
#pragma DATA 0x2007, 0x3f38
#endif
#ifdef HI_TECH_C
__CONFIG(0x3f38);
#endif
#ifdef _BOOSTC
#pragma DATA 0x2008, 0x3ffc
#endif
#ifdef HI_TECH_C
__CONFIG(0x3ffc);
#endif

//Fonctions internes
#include "C:\Program Files (x86)\Flowcode\v5\FCD\internals.c"

//Déclarations de fonction Macro
void FCM_Initialisation();
void FCM_Capteurs();
void FCM_batt();


//Déclarations de Variable
#define FCSZ_TEMPERATURE 20
#define FCSZ_TEMP 8
MX_CHAR FCV_TEMPERATURE[FCSZ_TEMPERATURE];
MX_SINT16 FCV_GET_TEMP;
MX_SINT16 FCV_SIGNE;
MX_CHAR FCV_TEMP[FCSZ_TEMP];
MX_UINT8 FCV_NBCAPTEUR;
MX_SINT16 FCV_DECIMALE;
MX_UINT8 FCV_CAPTEUR;
MX_SINT16 FCV_ENTIER;
MX_UINT8 FCV_BATT;

MX_UINT8 FCLV_LOOP1;



//One_Wire(0): //Defines:

/**** Macro Substitutions ****
a = Unique Reference
b = CRC Check Enable (0-Off / 1-On)
c = One Wire Port Register
d = One Wire Pin
******************************/

//Global Definitions

#define 	ONEWIRE_1_OO_CRC_EN  			1
#define 	ONEWIRE_1_OO_PORT  			porta
#define 	ONEWIRE_1_OO_TRIS 				trisa
#define 	ONEWIRE_1_OO_PIN  				0

//I/O for the OO
#define 	ONEWIRE_1_Float_OO 			FC_CAL_Bit_In_DDR( ONEWIRE_1_OO_PORT , ONEWIRE_1_OO_TRIS , ONEWIRE_1_OO_PIN )
#define 	ONEWIRE_1_Clear_OO				FC_CAL_Bit_Low_DDR( ONEWIRE_1_OO_PORT , ONEWIRE_1_OO_TRIS , ONEWIRE_1_OO_PIN )

#ifndef OO_DEFS
 #define OO_DEFS

 // 1. ROM function commands
 #define		OO_READROM        	0x33
 #define   		OO_MATCHROM       	0x55
 #define  		OO_SKIPROM        	0xCC
 #define		OO_SEARCHROM      	0xF0
 #define		OO_ALARMSEARCH    	0xEC

 // 2. Memory Command Functions
 #define		OO_WRITEPAD       	0x4E
 #define		OO_READPAD        	0xBE
 #define		OO_COPYPAD        	0x48
 #define		OO_CONVERTT       	0x44
 #define		OO_RECALLE2			0xB8
 #define		OO_READSUPPLY		0xB4

#endif

//CRC lookup table for the OO - Only include once for all 1-wire components
#if OO_CRC_EN == 1
  #ifndef OO_CRC_ROM
	#define OO_CRC_ROM

	ROMARRAY_S OO_CRC_ROM ROMARRAY_E = {0, 94, 188, 226, 97, 63, 221, 131, 194, 156, 126, 32, 163, 253, 31, 65,
									157, 195, 33, 127, 252, 162, 64, 30, 95, 1, 227, 189, 62, 96, 130, 220,
									35, 125, 159, 193, 66, 28, 254, 160, 225, 191, 93, 3, 128, 222, 60, 98,
									190, 224, 2, 92, 223, 129, 99, 61, 124, 34, 192, 158, 29, 67, 161, 255,
									70, 24, 250, 164, 39, 121, 155, 197, 132, 218, 56, 102, 229, 187, 89, 7,
									219, 133, 103, 57, 186, 228, 6, 88, 25, 71, 165, 251, 120, 38, 196, 154,
									101, 59, 217, 135, 4, 90, 184, 230, 167, 249, 27, 69, 198, 152, 122, 36,
									248, 166, 68, 26, 153, 199, 37, 123, 58, 100, 134, 216, 91, 5, 231, 185,
									140, 210, 48, 110, 237, 179, 81, 15, 78, 16, 242, 172, 47, 113, 147, 205,
									17, 79, 173, 243, 112, 46, 204, 146, 211, 141, 111, 49, 178, 236, 14, 80,
									175, 241, 19, 77, 206, 144, 114, 44, 109, 51, 209, 143, 12, 82, 176, 238,
									50, 108, 142, 208, 83, 13, 239, 177, 240, 174, 76, 18, 145, 207, 45, 115,
									202, 148, 118, 40, 171, 245, 23, 73, 8, 86, 180, 234, 105, 55, 213, 139,
									87, 9, 235, 181, 54, 104, 138, 212, 149, 203, 41, 119, 244, 170, 72, 22,
									233, 183, 85, 11, 136, 214, 52, 106, 43, 117, 151, 201, 74, 20, 246, 168,
									116, 42, 200, 150, 21, 75, 169, 247, 182, 232, 10, 84, 215, 137, 107, 53};
  #endif

	// CRC working variable
	MX_UINT8 		ONEWIRE_1_oo_crc = 0;

#endif

//Global Variables

// Internal variables
MX_UINT8        ONEWIRE_1_oo_id[8];
MX_SINT8 		ONEWIRE_1_oo_conflict;
MX_UINT8        ONEWIRE_1_oo_new_conflict;

// Device ID Variables
MX_UINT8 		ONEWIRE_1_oo_num_devices = 0;
MX_UINT8 		ONEWIRE_1_oo_DevID[64] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
								0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};

// Scratchpad Variables
MX_UINT8 		ONEWIRE_1_oo_scratchpad[9];

// Scratchpad contents DS1820
// 0	Temperature LSB
// 1	Temperature MSB
// 2	Hi alarm temperature
// 3	Lo alarm temperature
// 4	Reserved, 0xFF
// 5	Reserved, 0xFF
// 6	Remainder register
// 7	Nr of counts per degree
// 8	CRC of pad contents




//One_Wire(0): //Déclarations de fonction Macro

void FCD_One_Wire0_oo_crc_shuffle_byte(MX_UINT8 input);
void FCD_One_Wire0_oo_crc_init();
MX_UINT8 FCD_One_Wire0_rx_bit();
void FCD_One_Wire0_tx_bit(MX_UINT8 out);
MX_UINT8 FCD_One_Wire0_oo_get_next_id();
MX_UINT8 FCD_One_Wire0_oo_busreset();
MX_UINT8 FCD_One_Wire0_oo_get_pad_byte(MX_UINT8 index);
void FCD_One_Wire0_oo_tx_byte(MX_UINT8 data);
MX_UINT8 FCD_One_Wire0_oo_rx_byte();
MX_UINT8 FCD_One_Wire0_oo_scanbus();
MX_UINT8 FCD_One_Wire0_oo_get_devicecount();
MX_UINT8 FCD_One_Wire0_oo_read_device(MX_UINT8 count);
MX_UINT8 FCD_One_Wire0_oo_get_IDByte(MX_UINT8 device, MX_UINT8 octet);
MX_UINT8 FCD_One_Wire0_DS1820_start_conversion();
MX_UINT8 FCD_One_Wire0_DS1820_read_scratchpad();
MX_UINT16 FCD_One_Wire0_DS1820_get_temp();


//LCDDisplay(0): //Defines:

/**** Macro Substitutions ****
a = Unique Component Reference Number
b = D1 Port Letter
c = D2 Port Letter
d = D3 Port Letter
e = D4 Port Letter
f = RS Port Letter
g = E Port Letter
h = Data 1_Pin
i = Data 2 Pin
j = Data 3 Pin
k = Data 4 Pin
l = RS Pin
m = Enable Pin
n = Row Count
o = Column Count
******************************/

	//component connections
	//Port pin lat workaround for 8-bit PIC devices running >= 32MHz
	//seems we need this mod for 19660800 16F1937 so changed to >= 16MHz

  #ifdef FC_CAL_PIC
   #if MX_CLK_SPEED >= 32000000
	#define LCD_2__PORT0    latb
	#define LCD_2__PORT1    latb
	#define LCD_2__PORT2    latb
	#define LCD_2__PORT3    latb
	#define LCD_2__PORT4    latb
	#define LCD_2__PORT5    latb
   #else
    #ifdef MX_LCD_PORT_LAT
	 #define LCD_2__PORT0    latb
	 #define LCD_2__PORT1    latb
	 #define LCD_2__PORT2    latb
	 #define LCD_2__PORT3    latb
	 #define LCD_2__PORT4    latb
	 #define LCD_2__PORT5    latb
    #else
	 #define LCD_2__PORT0    portb
	 #define LCD_2__PORT1    portb
	 #define LCD_2__PORT2    portb
	 #define LCD_2__PORT3    portb
	 #define LCD_2__PORT4    portb
	 #define LCD_2__PORT5    portb
	#endif
   #endif
  #else
	#define LCD_2__PORT0    portb
	#define LCD_2__PORT1    portb
	#define LCD_2__PORT2    portb
	#define LCD_2__PORT3    portb
	#define LCD_2__PORT4    portb
	#define LCD_2__PORT5    portb
  #endif

	#define LCD_2__TRIS0    trisb
	#define LCD_2__TRIS1    trisb
	#define LCD_2__TRIS2    trisb
	#define LCD_2__TRIS3    trisb
	#define LCD_2__TRIS4    trisb
	#define LCD_2__TRIS5    trisb
	#define LCD_2__BIT0    	0
	#define LCD_2__BIT1    	1
	#define LCD_2__BIT2    	2
	#define LCD_2__BIT3    	3
	#define LCD_2__RS      	4
	#define LCD_2__E       	5
	#define LCD_2__ROWCNT	4
	#define LCD_2__COLCNT	20

	#ifdef _BOOSTC
	  #define LCD_2__DELAY   delay_10us(10)
	#endif
	#ifdef _C2C_
	  #define LCD_2__DELAY   delay_us(100)
	#endif
	#ifdef HI_TECH_C
	  #define LCD_2__DELAY   __delay_us(120)
	#endif
	#ifndef LCD_2__DELAY
	  #define LCD_2__DELAY   delay_us(100)
	#endif




//LCDDisplay(0): //Déclarations de fonction Macro

void FCD_LCDDisplay0_RawSend(MX_UINT8 in, MX_UINT8 mask);
void FCD_LCDDisplay0_Start();
void FCD_LCDDisplay0_Clear();
void FCD_LCDDisplay0_PrintASCII(MX_UINT8 Character);
void FCD_LCDDisplay0_Command(MX_UINT8 in);
void FCD_LCDDisplay0_Cursor(MX_UINT8 x, MX_UINT8 y);
void FCD_LCDDisplay0_PrintNumber(MX_SINT16 Number);
void FCD_LCDDisplay0_PrintString(MX_STRING String, MX_UINT8 MSZ_String);
void FCD_LCDDisplay0_ScrollDisplay(MX_UINT8 Direction, MX_UINT8 Num_Positions);
void FCD_LCDDisplay0_ClearLine(MX_UINT8 Line);
void FCD_LCDDisplay0_RAM_Write(MX_UINT8 nIdx, MX_UINT8 d0, MX_UINT8 d1, MX_UINT8 d2, MX_UINT8 d3, MX_UINT8 d4, MX_UINT8 d5, MX_UINT8 d6, MX_UINT8 d7);


//ADC(0): //Defines:

/**** Macro Substitutions ****
a = Unique Reference
b = Which ADC Channel
c = Acquisition time
d = Conversion Speed
e = VRef+ Option
f = VRef Voltage x 0.01V
******************************/

//Common Defines

#define ADC_3_MX_ADC_CHANNEL	1
#define ADC_3_MX_ADC_ACTIME	40
#define ADC_3_MX_ADC_CONVSP	3
#define ADC_3_MX_ADC_VREFOP	0
#define ADC_3_MX_ADC_VREFVOL	500

#ifndef MX_ADC_CHANNEL_1
 #define MX_ADC_CHANNEL_1			//Inform CAL ADC channel 1 is now in use.
#endif

#ifndef MX_ADC_REF					//Inform CAL ADC peripheral is now in use
 #define MX_ADC_REF
#endif

extern void FC_CAL_Enable_ADC (MX_UINT8 Channel, MX_UINT8 Conv_Speed, MX_UINT8 Vref, MX_UINT8 T_Charge);
extern MX_UINT16 FC_CAL_Sample_ADC (MX_UINT8 Sample_Mode);
extern void FC_CAL_Disable_ADC (void);




//ADC(0): //Déclarations de fonction Macro

void FCD_ADC0_SampleADC();
MX_UINT8 FCD_ADC0_ReadAsByte();
MX_UINT16 FCD_ADC0_ReadAsInt();
MX_FLOAT FCD_ADC0_ReadAsVoltage();
void FCD_ADC0_ReadAsString(MX_CHAR* FCR_RETVAL, MX_UINT8 FCR_RETVAL_SIZE);
void FCD_ADC0_ADC_RAW_Configure_Channel();
MX_UINT8 FCD_ADC0_ADC_RAW_Sample_Channel_Byte();
MX_UINT16 FCD_ADC0_ADC_RAW_Sample_Channel_Int();
MX_UINT8 FCD_ADC0_ADC_RAW_Average_Channel_Byte(MX_UINT8 NumSamples, MX_UINT8 DelayUs);
MX_UINT16 FCD_ADC0_ADC_RAW_Average_Channel_Int(MX_UINT8 NumSamples, MX_UINT8 DelayUs);
void FCD_ADC0_ADC_RAW_Disable_Channel();



//One_Wire(0): //Implémentations Macro


void FCD_One_Wire0_oo_crc_shuffle_byte(MX_UINT8 input)
{
	
		#if OO_CRC_EN == 1
			ONEWIRE_1_oo_crc = OO_CRC_ROM[ONEWIRE_1_oo_crc ^ input];
		#endif

}

void FCD_One_Wire0_oo_crc_init()
{
	
		#if OO_CRC_EN == 1
			ONEWIRE_1_oo_crc = 0;
		#endif

}

MX_UINT8 FCD_One_Wire0_rx_bit()
{
	
		MX_UINT8 oo_bit;

		ONEWIRE_1_Clear_OO;						//Clear Output Pin
		delay_us(1);						//Delay 1us
		ONEWIRE_1_Float_OO;						//Float Output Pin
		delay_us(10);						//Delay 10us
		oo_bit = FC_CAL_Bit_In( ONEWIRE_1_OO_PORT , ONEWIRE_1_OO_PIN );				//Test Input
		delay_us(50);						//Delay 50us
		return oo_bit;

}

void FCD_One_Wire0_tx_bit(MX_UINT8 out)
{
	
		ONEWIRE_1_Clear_OO;						//Clear Output Pin
		delay_us(1);						//Delay 1us
		if (out & 0x01)
			ONEWIRE_1_Float_OO;					//Float Output Pin
		delay_us(60);						//Delay 60us
		ONEWIRE_1_Float_OO;						//Float Output Pin
		delay_us(10);						//Delay 10us

}

MX_UINT8 FCD_One_Wire0_oo_get_next_id()
{
	
		MX_UINT8 val0 = 0;
		MX_UINT8 val1 = 0;
		MX_UINT8 counter    = 0;
		MX_UINT8 bit_index  = 0;
		MX_UINT8 byte_index = 0;
		MX_UINT8 data_in_byte = 0;
		//MX_UINT8 current_ONEWIRE_1_oo_conflict = -1;

		//added JCMB 10/01/09
		MX_UINT8 lz_selected = 0;
		MX_UINT8 go_on = 0;
		MX_UINT8 bit_test;

		ONEWIRE_1_oo_new_conflict = 0;

		if ( FCD_One_Wire0_oo_busreset() )	// Reset the bus
		{
			return 1; // -> error
		}
		// Issue the search ROM command
		FCD_One_Wire0_oo_tx_byte(OO_SEARCHROM);

		// Start the search for the sensor
		for (byte_index = 0; byte_index < 8; byte_index++)
		{
			data_in_byte = 0;
			for (bit_index = 0; bit_index < 8; bit_index++)
			{
				// Read 2 consecutive bits from the One Wire bus
				val0 = FCD_One_Wire0_rx_bit();						//Test Input
				val1 = FCD_One_Wire0_rx_bit();						//Test Input

				// Evaluate the result
				if ((val0 == 0) && (val1 == 0))
				{
					//current_ONEWIRE_1_oo_conflict = counter;
					// if ONEWIRE_1_oo_conflict occurs earlier than the previous ONEWIRE_1_oo_conflict, then use the previous value
					if (counter < ONEWIRE_1_oo_conflict)
					{
						// use previous value
						bit_test = ONEWIRE_1_oo_id[byte_index] >> bit_index;		//added JCMB 10/01/09
						if (bit_test & 0x01)
						{
							val0 = 1;
						}
						else
						{
							val0 = 0;
							lz_selected = counter;				//added JCMB 10/01/09
							go_on = 1;							//added JCMB 10/01/09
						}
					}
					else if (counter == ONEWIRE_1_oo_conflict)
					{
						// use 1
						val0 = 1;
					}
					else
					{
						// use zero on new ONEWIRE_1_oo_conflicts
						val0 = 0;
						ONEWIRE_1_oo_conflict = counter;
						ONEWIRE_1_oo_new_conflict = 1;
					}
				}
				else if (val0 && val1) // 1 et 1 impossible
				{
					return 2;
				}
				// Store the bit in the ID array
				data_in_byte = data_in_byte >> 1;
				if (val0)
				{
					data_in_byte |= 0x80;
				}

				FCD_One_Wire0_tx_bit(val0);

				counter++;
			}
			ONEWIRE_1_oo_id[byte_index] = data_in_byte;
		}

	        //added JCMB 10/01/09
		if ((ONEWIRE_1_oo_new_conflict == 0) && go_on)
		{
			ONEWIRE_1_oo_new_conflict = 1;
			ONEWIRE_1_oo_conflict = lz_selected ;
		}

		// Verify ID CRC
		#if OO_CRC_EN == 1
			FCD_One_Wire0_oo_crc_init();
		#endif

		for (byte_index = 0; byte_index < 8; byte_index++)
		{
			#if OO_CRC_EN == 1
					FCD_One_Wire0_oo_crc_shuffle_byte(ONEWIRE_1_oo_id[byte_index]);
			#endif
		}
		// Bail on CRC errors
	  #if OO_CRC_EN == 1
		if (ONEWIRE_1_oo_crc) return ONEWIRE_1_oo_crc;
	  #endif
		return 0;

}

MX_UINT8 FCD_One_Wire0_oo_busreset()
{
	
		ONEWIRE_1_Float_OO; 					// Release bus
		ONEWIRE_1_Clear_OO;					// Send the reset pulse
		delay_us(200);					// Wait for 600 µs, this is the reset pulse
		delay_us(200);
		delay_us(200);
		ONEWIRE_1_Float_OO; 					// Release bus
		delay_us(60);					// Wait 60 us (release) let device drive the bus
		if (FC_CAL_Bit_In( ONEWIRE_1_OO_PORT, ONEWIRE_1_OO_PIN ) == 1)			// Now sample, if there is a sensor on the bus, the line should be low
			return 1; 					// <<-error
		delay_us(140);					// Wait another 540 us to complete the reset sequence
		delay_us(200);
		delay_us(200);
		return 0;

}

MX_UINT8 FCD_One_Wire0_oo_get_pad_byte(MX_UINT8 index)
{
	
		return ONEWIRE_1_oo_scratchpad[index];

}

void FCD_One_Wire0_oo_tx_byte(MX_UINT8 data)
{
	
		MX_UINT8 counter = 0;
		while (counter < 8)
		{
			FCD_One_Wire0_tx_bit(data);
			data = data >> 1;				//Rotate to next bit of data
			counter++;						//Increment Counter
		}

}

MX_UINT8 FCD_One_Wire0_oo_rx_byte()
{
	
		MX_UINT8 counter = 0;
		MX_UINT8 data    = 0;
		MX_UINT8 oo_bit  = 0;
		while (counter < 8)
		{
			oo_bit = FCD_One_Wire0_rx_bit();
			data = data >> 1;					//Shift incoming data to next bit
			if (oo_bit > 0)
			{
				data = data | 0x80;				//Append incoming bit to data byte
			}
			counter++;							//Increment Counter
		}
		#ifdef OO_OO_CRC_EN
			FCD_One_Wire0_oo_crc_shuffle_byte(data);			//Check CRC
		#endif
		return data;

}

MX_UINT8 FCD_One_Wire0_oo_scanbus()
{
	
		MX_UINT8 retval = 0;
		MX_UINT8 device_count = 0;
		MX_UINT8 loper;
		ONEWIRE_1_oo_conflict = -1;
		ONEWIRE_1_oo_new_conflict = 1;
		// Reset the bus, wake up devices.
		retval = FCD_One_Wire0_oo_busreset();
		if (retval == 1)
		{
			return 255; // -> error
		}
		// ONEWIRE_1_oo_new_conflict gets updated in the FCD_One_Wire0_oo_get_next_id() function.
		while (ONEWIRE_1_oo_new_conflict)
		{
			retval = FCD_One_Wire0_oo_get_next_id();
			// Bail in case of errors
			if (retval) return retval;
			// Add the device ONEWIRE_1_oo_id to EEPROM
			for (loper=0; loper < 8; loper++)
			{
				ONEWIRE_1_oo_DevID[loper+(device_count<<3)] = ONEWIRE_1_oo_id[loper];
			}
			device_count++;
		}
		// Write number of devices to the EEPROM
		ONEWIRE_1_oo_num_devices = device_count;
		return 0;

}

MX_UINT8 FCD_One_Wire0_oo_get_devicecount()
{
	
		return ONEWIRE_1_oo_num_devices;

}

MX_UINT8 FCD_One_Wire0_oo_read_device(MX_UINT8 count)
{
	
		MX_UINT8 loper = 0;
		MX_UINT8 counter = 0;
		MX_UINT8 temp;

		FCD_One_Wire0_oo_busreset();
		FCD_One_Wire0_oo_tx_byte(OO_MATCHROM);
		for (loper=0; loper < 8; loper++)
		{
			ONEWIRE_1_oo_DevID[loper] = ONEWIRE_1_oo_id[loper+(count<<3)];
			FCD_One_Wire0_oo_tx_byte(ONEWIRE_1_oo_id[loper]);
		}
		FCD_One_Wire0_oo_tx_byte(OO_READPAD);
		#if OO_CRC_EN == 1
			FCD_One_Wire0_oo_crc_init();			//Reset the CRC register, CRC is updated in the FCD_One_Wire0_oo_rx_byte() function.
		#endif
		while (counter < 9)
		{
			temp = FCD_One_Wire0_oo_rx_byte();
			ONEWIRE_1_oo_scratchpad[counter] = temp;
			counter++;
		}
		#if OO_CRC_EN == 1
			return ONEWIRE_1_oo_crc;				//Verify the CRC
		#endif
		return 0;

}

MX_UINT8 FCD_One_Wire0_oo_get_IDByte(MX_UINT8 device, MX_UINT8 octet)
{
	
		MX_UINT8 retval = 255;

		if ((device >= ONEWIRE_1_oo_num_devices) | (octet > 7))
		{
			return retval ; //error
		}
	        retval = ONEWIRE_1_oo_DevID[octet+(device<<3)];
		return retval ;

}

MX_UINT8 FCD_One_Wire0_DS1820_start_conversion()
{
	
		MX_UINT8 in = 0;
		MX_UINT8 counter = 0;

		FCD_One_Wire0_oo_busreset();
		FCD_One_Wire0_oo_tx_byte(OO_SKIPROM);		// Command all temp sensors on the bus to start a conversion
		FCD_One_Wire0_oo_tx_byte(OO_CONVERTT);	// Convert temperature
		while (in == 0)
		{
			in = FCD_One_Wire0_oo_rx_byte();
			delay_ms(4);
			counter++;
			if (counter == 0xFF)		// Security: if the conversion is not completed
				return 1;				// after > 1 sec -> break.
		}
		return 0;

}

MX_UINT8 FCD_One_Wire0_DS1820_read_scratchpad()
{
	
		MX_UINT8 temp;
		MX_UINT8 counter = 0;

		if ( FCD_One_Wire0_oo_busreset() )
			return (1);
		FCD_One_Wire0_oo_tx_byte(OO_SKIPROM);		//Command all temp sensors on the bus to start a conversion
		FCD_One_Wire0_oo_tx_byte(OO_READPAD);		//Convert temperature
		#if OO_CRC_EN == 1
			FCD_One_Wire0_oo_crc_init();			//Reset the CRC register, CRC is updated in the FCD_One_Wire0_oo_rx_byte() function.
		#endif
		while (counter < 9)
		{
			temp = FCD_One_Wire0_oo_rx_byte();
			ONEWIRE_1_oo_scratchpad[counter] = temp;
			counter++;
		}
		#if OO_CRC_EN == 1
			return ONEWIRE_1_oo_crc;				//Verify the CRC
		#endif
		return 0;

}

MX_UINT16 FCD_One_Wire0_DS1820_get_temp()
{
	
		MX_UINT16 retval;
		retval = ONEWIRE_1_oo_scratchpad[1];
		retval = retval << 8;
		retval = retval | ONEWIRE_1_oo_scratchpad[0];
		return retval;

}



//LCDDisplay(0): //Implémentations Macro


void FCD_LCDDisplay0_RawSend(MX_UINT8 in, MX_UINT8 mask)
{
	
		MX_UINT8 pt;

		FC_CAL_Bit_Low(LCD_2__PORT0, LCD_2__BIT0);
		FC_CAL_Bit_Low(LCD_2__PORT1, LCD_2__BIT1);
		FC_CAL_Bit_Low(LCD_2__PORT2, LCD_2__BIT2);
		FC_CAL_Bit_Low(LCD_2__PORT3, LCD_2__BIT3);
		FC_CAL_Bit_Low(LCD_2__PORT4, LCD_2__RS);
		FC_CAL_Bit_Low(LCD_2__PORT5, LCD_2__E);
		pt = ((in >> 4) & 0x0f);
		if (pt & 0x01)
		    FC_CAL_Bit_High(LCD_2__PORT0, LCD_2__BIT0);
		if (pt & 0x02)
		    FC_CAL_Bit_High(LCD_2__PORT1, LCD_2__BIT1);
		if (pt & 0x04)
		    FC_CAL_Bit_High(LCD_2__PORT2, LCD_2__BIT2);
		if (pt & 0x08)
		    FC_CAL_Bit_High(LCD_2__PORT3, LCD_2__BIT3);
		if (mask)
		    FC_CAL_Bit_High(LCD_2__PORT4, LCD_2__RS);
		LCD_2__DELAY;
		FC_CAL_Bit_High (LCD_2__PORT5, LCD_2__E);
		LCD_2__DELAY;
		FC_CAL_Bit_Low (LCD_2__PORT5, LCD_2__E);
		pt = (in & 0x0f);
		LCD_2__DELAY;
		FC_CAL_Bit_Low(LCD_2__PORT0, LCD_2__BIT0);
		FC_CAL_Bit_Low(LCD_2__PORT1, LCD_2__BIT1);
		FC_CAL_Bit_Low(LCD_2__PORT2, LCD_2__BIT2);
		FC_CAL_Bit_Low(LCD_2__PORT3, LCD_2__BIT3);
		FC_CAL_Bit_Low(LCD_2__PORT4, LCD_2__RS);
		FC_CAL_Bit_Low(LCD_2__PORT5, LCD_2__E);
		if (pt & 0x01)
		    FC_CAL_Bit_High(LCD_2__PORT0, LCD_2__BIT0);
		if (pt & 0x02)
		    FC_CAL_Bit_High(LCD_2__PORT1, LCD_2__BIT1);
		if (pt & 0x04)
		    FC_CAL_Bit_High(LCD_2__PORT2, LCD_2__BIT2);
		if (pt & 0x08)
		    FC_CAL_Bit_High(LCD_2__PORT3, LCD_2__BIT3);
		if (mask)
		    FC_CAL_Bit_High(LCD_2__PORT4, LCD_2__RS);
		LCD_2__DELAY;
		FC_CAL_Bit_High (LCD_2__PORT5, LCD_2__E);
		LCD_2__DELAY;
		FC_CAL_Bit_Low (LCD_2__PORT5, LCD_2__E);
		LCD_2__DELAY;

}

void FCD_LCDDisplay0_Start()
{
	
		FC_CAL_Bit_Low_DDR(LCD_2__PORT0, LCD_2__TRIS0, LCD_2__BIT0);
		FC_CAL_Bit_Low_DDR(LCD_2__PORT1, LCD_2__TRIS1, LCD_2__BIT1);
		FC_CAL_Bit_Low_DDR(LCD_2__PORT2, LCD_2__TRIS2, LCD_2__BIT2);
		FC_CAL_Bit_Low_DDR(LCD_2__PORT3, LCD_2__TRIS3, LCD_2__BIT3);
		FC_CAL_Bit_Low_DDR(LCD_2__PORT4, LCD_2__TRIS4, LCD_2__RS);
		FC_CAL_Bit_Low_DDR(LCD_2__PORT5, LCD_2__TRIS5, LCD_2__E);

		Wdt_Delay_Ms(12);

		FCD_LCDDisplay0_RawSend(0x33, 0);
		Wdt_Delay_Ms(2);
		FCD_LCDDisplay0_RawSend(0x33, 0);
		Wdt_Delay_Ms(2);
		FCD_LCDDisplay0_RawSend(0x32, 0);
		Wdt_Delay_Ms(2);
		FCD_LCDDisplay0_RawSend(0x2c, 0);
		Wdt_Delay_Ms(2);
		FCD_LCDDisplay0_RawSend(0x06, 0);
		Wdt_Delay_Ms(2);
		FCD_LCDDisplay0_RawSend(0x0c, 0);
		Wdt_Delay_Ms(2);

		//clear the display
		FCD_LCDDisplay0_RawSend(0x01, 0);
		Wdt_Delay_Ms(2);
		FCD_LCDDisplay0_RawSend(0x02, 0);
		Wdt_Delay_Ms(2);

}

void FCD_LCDDisplay0_Clear()
{
	
		FCD_LCDDisplay0_RawSend(0x01, 0);
		Wdt_Delay_Ms(2);
		FCD_LCDDisplay0_RawSend(0x02, 0);
		Wdt_Delay_Ms(2);

}

void FCD_LCDDisplay0_PrintASCII(MX_UINT8 Character)
{
	
		FCD_LCDDisplay0_RawSend(Character, 0x10);

}

void FCD_LCDDisplay0_Command(MX_UINT8 in)
{
	
		FCD_LCDDisplay0_RawSend(in, 0);
		Wdt_Delay_Ms(2);

}

void FCD_LCDDisplay0_Cursor(MX_UINT8 x, MX_UINT8 y)
{
	
	  #if (LCD_2__ROWCNT == 1)
	    y=0x80;
	  #endif

	  #if (LCD_2__ROWCNT == 2)
		if (y==0)
			y=0x80;
		else
			y=0xc0;
	  #endif

	  #if (LCD_2__ROWCNT == 4)
		if (y==0)
			y=0x80;
		else if (y==1)
			y=0xc0;

		#if (LCD_2__COLCNT == 16)
			else if (y==2)
				y=0x90;
			else
				y=0xd0;
		#endif

		#if (LCD_2__COLCNT == 20)
			else if (y==2)
				y=0x94;
			else
				y=0xd4;
		#endif
	  #endif

		FCD_LCDDisplay0_RawSend(y+x, 0);
		Wdt_Delay_Ms(2);

}

void FCD_LCDDisplay0_PrintNumber(MX_SINT16 Number)
{
	
		MX_SINT16 tmp_int;
		MX_UINT8 tmp_byte;

		if (Number < 0)
		{
			FCD_LCDDisplay0_RawSend('-', 0x10);
			Number = 0 - Number;
		}

		tmp_int = Number;
		if (Number >= 10000)
		{
			tmp_byte = tmp_int / 10000;
			FCD_LCDDisplay0_RawSend('0' + tmp_byte, 0x10);

			while (tmp_byte > 0)
			{
				tmp_int = tmp_int - 10000;
				tmp_byte--;
			}
		}
		if (Number >= 1000)
		{
			tmp_byte = tmp_int / 1000;
			FCD_LCDDisplay0_RawSend('0' + tmp_byte, 0x10);

			while (tmp_byte > 0)
			{
				tmp_int = tmp_int - 1000;
				tmp_byte--;
			}
		}
		if (Number >= 100)
		{
			tmp_byte = tmp_int / 100;
			FCD_LCDDisplay0_RawSend('0' + tmp_byte, 0x10);

			while (tmp_byte > 0)
			{
				tmp_int = tmp_int - 100;
				tmp_byte--;
			}
		}
		if (Number >= 10)
		{
			tmp_byte = tmp_int / 10;
			FCD_LCDDisplay0_RawSend('0' + tmp_byte, 0x10);

			while (tmp_byte > 0)
			{
				tmp_int = tmp_int - 10;
				tmp_byte--;
			}
		}
		FCD_LCDDisplay0_RawSend('0' + tmp_int, 0x10);

}

void FCD_LCDDisplay0_PrintString(MX_STRING String, MX_UINT8 MSZ_String)
{
	
		MX_UINT8 idx = 0;

		for (idx=0; idx<MSZ_String; idx++)
		{
			if (String[idx] == 0)
			{
				break;
			}
			FCD_LCDDisplay0_RawSend(String[idx], 0x10);
		}

}

void FCD_LCDDisplay0_ScrollDisplay(MX_UINT8 Direction, MX_UINT8 Num_Positions)
{
	
		MX_UINT8 cmd = 0;
		MX_UINT8 count;

		//Choose the direction
		switch (Direction)
		{
			case 0:
			case 'l':
			case 'L':

				cmd = 0x18;
				break;

			case 1:
			case 'r':
			case 'R':

				cmd = 0x1C;
				break;

			default:
				break;
		}

		//If direction accepted then scroll the specified amount
		if (cmd)
		{
			for (count = 0; count < Num_Positions; count++)
				FCD_LCDDisplay0_Command(cmd);
		}

}

void FCD_LCDDisplay0_ClearLine(MX_UINT8 Line)
{
	
		MX_UINT8 count;
		MX_UINT8 rowcount;

		//Define number of columns per line
		#if (LCD_2__ROWCNT == 1)
			rowcount=80;
		#endif

		#if (LCD_2__ROWCNT == 2)
			rowcount=40;
		#endif

		#if (LCD_2__ROWCNT == 4)
			#if (LCD_2__COLCNT == 16)
				rowcount=16;
			#endif
			#if (LCD_2__COLCNT == 20)
				rowcount=20;
			#endif
		#endif

		//Start at beginning of the line
		FCD_LCDDisplay0_Cursor (0, Line);

		//Send out spaces to clear line
		for (count = 0; count < rowcount; count++)
			FCD_LCDDisplay0_RawSend(' ', 0x10);

		//Move back to the beginning of the line.
		FCD_LCDDisplay0_Cursor (0, Line);

}

void FCD_LCDDisplay0_RAM_Write(MX_UINT8 nIdx, MX_UINT8 d0, MX_UINT8 d1, MX_UINT8 d2, MX_UINT8 d3, MX_UINT8 d4, MX_UINT8 d5, MX_UINT8 d6, MX_UINT8 d7)
{
	   //set CGRAM address

	   FCD_LCDDisplay0_RawSend(64 + (nIdx << 3), 0);
	   delay_ms(2);

	   //write CGRAM data
	   FCD_LCDDisplay0_RawSend(d0, 0x10);
	   FCD_LCDDisplay0_RawSend(d1, 0x10);
	   FCD_LCDDisplay0_RawSend(d2, 0x10);
	   FCD_LCDDisplay0_RawSend(d3, 0x10);
	   FCD_LCDDisplay0_RawSend(d4, 0x10);
	   FCD_LCDDisplay0_RawSend(d5, 0x10);
	   FCD_LCDDisplay0_RawSend(d6, 0x10);
	   FCD_LCDDisplay0_RawSend(d7, 0x10);

	   //Clear the display
	   FCD_LCDDisplay0_RawSend(0x01, 0);
	   delay_ms(2);
	   FCD_LCDDisplay0_RawSend(0x02, 0);
	   delay_ms(2);

}



//ADC(0): //Implémentations Macro


void FCD_ADC0_SampleADC()
{
	
	    //unused

}

MX_UINT8 FCD_ADC0_ReadAsByte()
{
	
		MX_UINT8 retVal;

		//Configure & Enable ADC Channel
		FC_CAL_Enable_ADC ( ADC_3_MX_ADC_CHANNEL , ADC_3_MX_ADC_CONVSP , ADC_3_MX_ADC_VREFOP , ADC_3_MX_ADC_ACTIME );

		retVal = FC_CAL_Sample_ADC( 0 );				//Perform Sample - Return as byte

		FC_CAL_Disable_ADC ();

		return (retVal);

}

MX_UINT16 FCD_ADC0_ReadAsInt()
{
	
		MX_UINT16 retVal;

		//Configure & Enable ADC Channel
		FC_CAL_Enable_ADC ( ADC_3_MX_ADC_CHANNEL , ADC_3_MX_ADC_CONVSP , ADC_3_MX_ADC_VREFOP , ADC_3_MX_ADC_ACTIME );

		retVal = FC_CAL_Sample_ADC( 1 );				//Perform Sample - Return as MX_UINT16

		FC_CAL_Disable_ADC ();

		return (retVal);

}

MX_FLOAT FCD_ADC0_ReadAsVoltage()
{
	
		MX_UINT16 iSample;
		MX_FLOAT fSample, fVoltage, fVperDiv;

		//Configure & Enable ADC Channel
		FC_CAL_Enable_ADC ( ADC_3_MX_ADC_CHANNEL , ADC_3_MX_ADC_CONVSP , ADC_3_MX_ADC_VREFOP , ADC_3_MX_ADC_ACTIME );

	  #ifdef MX_ADC_BITS_8
		iSample = FC_CAL_Sample_ADC( 0 );								//Perform Sample - Return as byte
	  #else
		iSample = FC_CAL_Sample_ADC( 1 );								//Perform Sample - Return as MX_UINT16
	  #endif

	  	FC_CAL_Disable_ADC ();											//Switch off ADC peripheral
		fVoltage = flt_fromi( ADC_3_MX_ADC_VREFVOL );						//Convert reference voltage count to floating point (0 - 500 x 10mV)
		fVoltage = flt_mul(fVoltage, 0.01);								//Convert reference voltage count to actual voltage (0 - 5)

	  #ifdef MX_ADC_BITS_8
		fVperDiv = flt_mul(fVoltage, 0.00390625);						//Convert actual voltage to voltage per division (VRef / 256)
	  #endif
	  #ifdef MX_ADC_BITS_10
		fVperDiv = flt_mul(fVoltage, 0.000976);							//Convert actual voltage to voltage per division (VRef / 1024)
	  #endif
	  #ifdef MX_ADC_BITS_12
		fVperDiv = flt_mul(fVoltage, 0.00024414);						//Convert actual voltage to voltage per division (VRef / 4096)
	  #endif

		fSample = flt_fromi(iSample);									//Convert to floating point variable
		fVoltage = flt_mul(fSample, fVperDiv);							//Calculate floating point voltage

		return (fVoltage);

}

void FCD_ADC0_ReadAsString(MX_CHAR* FCR_RETVAL, MX_UINT8 FCR_RETVAL_SIZE)
{
	
		MX_FLOAT fVoltage;

		fVoltage = FCD_ADC0_ReadAsVoltage();
		FCI_FLOAT_TO_STRING(fVoltage, 2, FCR_RETVAL, FCR_RETVAL_SIZE);	//Convert to String

}

void FCD_ADC0_ADC_RAW_Configure_Channel()
{
	
		//Configure & Enable ADC Channel
		FC_CAL_Enable_ADC ( ADC_3_MX_ADC_CHANNEL , ADC_3_MX_ADC_CONVSP , ADC_3_MX_ADC_VREFOP , ADC_3_MX_ADC_ACTIME );

}

MX_UINT8 FCD_ADC0_ADC_RAW_Sample_Channel_Byte()
{
	
		return FC_CAL_Sample_ADC( 0 );									//Perform Sample - Return as byte

}

MX_UINT16 FCD_ADC0_ADC_RAW_Sample_Channel_Int()
{
	
		return FC_CAL_Sample_ADC( 1 );									//Perform Sample - Return as MX_UINT16

}

MX_UINT8 FCD_ADC0_ADC_RAW_Average_Channel_Byte(MX_UINT8 NumSamples, MX_UINT8 DelayUs)
{
	
		MX_UINT32 average = 0;
		MX_UINT8 count;

		for (count=0; count<NumSamples; count++)
		{
			average = average + FC_CAL_Sample_ADC( 0 );					//Perform Sample - Return as byte - add to average

			if (DelayUs)
				delay_us(DelayUs);										//If delay is not 0 then pause between samples
		}
		average = average / count;

		return (average & 0xFF);										//Return average as byte

}

MX_UINT16 FCD_ADC0_ADC_RAW_Average_Channel_Int(MX_UINT8 NumSamples, MX_UINT8 DelayUs)
{
	
		MX_UINT32 average = 0;
		MX_UINT8 count;

		for (count=0; count<NumSamples; count++)
		{
			average = average + FC_CAL_Sample_ADC( 1 );					//Perform Sample - Return as MX_UINT16 - add to average

			if (DelayUs)
				delay_us(DelayUs);										//If delay is not 0 then pause between samples
		}
		average = average / count;

		return (average & 0x1FFF);										//Return average as MX_SINT16

}

void FCD_ADC0_ADC_RAW_Disable_Channel()
{
	
		FC_CAL_Disable_ADC ();											//Disable ADC Channel

}

#include "C:\Program Files (x86)\Flowcode\v5\CAL\includes.c"

//Implémentations Macro


void FCM_Initialisation()
{

	//Code C
	//Code C:
	osccon=0x7E;/* 8MHz */


	//Appel de la Routine Composant
	//Appel de la Routine Composant: Init()
	FCD_LCDDisplay0_Start();

	//Appel de la Routine Composant
	//Appel de la Routine Composant: Effacer()
	FCD_LCDDisplay0_Clear();

	//Batterie_100
	//Appel de la Routine Composant: Écriture_en_RAM(0x00, 0x04, 0x1F, 0x11, 0x11, 0x11, 0x11, 0x1f, 0x00)
	FCD_LCDDisplay0_RAM_Write(0x00, 0x04, 0x1F, 0x11, 0x11, 0x11, 0x11, 0x1f, 0x00);

	//Appel de la Routine Composant
	//Appel de la Routine Composant: Écriture_en_RAM(0x01, 0x04, 0x1F, 0x11, 0x11, 0x11, 0x1F, 0x1f, 0x00)
	FCD_LCDDisplay0_RAM_Write(0x01, 0x04, 0x1F, 0x11, 0x11, 0x11, 0x1F, 0x1f, 0x00);

	//Appel de la Routine Composant
	//Appel de la Routine Composant: Écriture_en_RAM(0x02, 0x04, 0x1F, 0x11, 0x11, 0x1f, 0x1f, 0x1f, 0x00)
	FCD_LCDDisplay0_RAM_Write(0x02, 0x04, 0x1F, 0x11, 0x11, 0x1f, 0x1f, 0x1f, 0x00);

	//Appel de la Routine Composant
	//Appel de la Routine Composant: Écriture_en_RAM(0x03, 0x04, 0x1F, 0x11, 0x1f, 0x1f, 0x1f, 0x1f, 0x00)
	FCD_LCDDisplay0_RAM_Write(0x03, 0x04, 0x1F, 0x11, 0x1f, 0x1f, 0x1f, 0x1f, 0x00);

	//Batterie_vide
	//Appel de la Routine Composant: Écriture_en_RAM(0x04, 0x04, 0x1F, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x00)
	FCD_LCDDisplay0_RAM_Write(0x04, 0x04, 0x1F, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x00);

	//accent_grave
	//Appel de la Routine Composant: Écriture_en_RAM(0x5, 0b00000010, 0b00000100, 0b00001110, 0b00010001, 0b00011111, 0b000010000, 0b00001110, 0b0000000)
	FCD_LCDDisplay0_RAM_Write(0x5, 2, 4, 14, 17, 31, 16, 14, 0);

	//Determination du nombre de capteurs
	//Appel de la Routine Composant: oo_busreset()
	FCD_One_Wire0_oo_busreset();

	//Appel de la Routine Composant
	//Appel de la Routine Composant: oo_scanbus()
	FCD_One_Wire0_oo_scanbus();

	//Appel de la Routine Composant
	//Appel de la Routine Composant: NBcapteur=oo_get_devicecount()
	FCV_NBCAPTEUR = FCD_One_Wire0_oo_get_devicecount();

	//Décision
	//Décision: NBcapteur = 0?
	if (FCV_NBCAPTEUR == 0)
	{

		//Calcul
		//Calcul:
		//  NBcapteur = 0
		FCV_NBCAPTEUR = 0;

	// } else {

	}

	//Décision
	//Décision: NBcapteur > 3?
	if (FCV_NBCAPTEUR > 3)
	{

		//Calcul
		//Calcul:
		//  NBcapteur = 4
		FCV_NBCAPTEUR = 4;

	// } else {

	}

	//Appel de la Routine Composant
	//Appel de la Routine Composant: Curseur(15, 3)
	FCD_LCDDisplay0_Cursor(15, 3);

	//Appel de la Routine Composant
	//Appel de la Routine Composant: Écrit_Nombre(NBcapteur)
	FCD_LCDDisplay0_PrintNumber(FCV_NBCAPTEUR);

	//Appel de la Routine Composant
	//Appel de la Routine Composant: Écrit_Chaîne(" Cap")
	FCD_LCDDisplay0_PrintString(" Cap", 4);

}


void FCM_Capteurs()
{

	//1820
	//Appel de la Routine Composant: DS1820_start_conversion()
	FCD_One_Wire0_DS1820_start_conversion();

	//Appel de la Routine Composant
	//Appel de la Routine Composant: oo_read_device(capteur)
	FCD_One_Wire0_oo_read_device(FCV_CAPTEUR);

	//DS1820
	//Appel de la Routine Composant: Get_Temp=DS1820_get_temp()
	FCV_GET_TEMP = FCD_One_Wire0_DS1820_get_temp();

	//Calcul
	//Calcul:
	//  signe = Get_Temp AND 0x8000
	FCV_SIGNE = FCV_GET_TEMP & 0x8000;

	//Décision
	//Décision: signe = -32768?
	if (FCV_SIGNE == -32768)
	{

		//Calculation
		//Calcul:
		//  Get_Temp = NOT Get_Temp
		FCV_GET_TEMP = ~FCV_GET_TEMP;

	// } else {

	}

	//Calculation
	//Calcul:
	//  decimale = ( Get_Temp MOD 16 ) * 6
	//  entier = Get_Temp >> 4
	FCV_DECIMALE = (FCV_GET_TEMP % 16) * 6;
	FCV_ENTIER = FCV_GET_TEMP >> 4;

	//Affiche temp numero
	//Calcul:
	//  temperature = "T"
	//  temp = ToString$ (capteur)
	//  temperature = temperature + temp
	//  temperature = temperature + " "
	FCI_SCOPY("T",1, FCV_TEMPERATURE,FCSZ_TEMPERATURE);
	FCI_TOSTRING(FCV_CAPTEUR, FCV_TEMP,FCSZ_TEMP);
	FCI_SHEAD(FCV_TEMPERATURE,FCSZ_TEMPERATURE, FCV_TEMP,FCSZ_TEMP, FCV_TEMPERATURE,FCSZ_TEMPERATURE);
	FCI_SHEAD(FCV_TEMPERATURE,FCSZ_TEMPERATURE, " ",1, FCV_TEMPERATURE,FCSZ_TEMPERATURE);

	//Décision
	//Décision: signe = -32768?
	if (FCV_SIGNE == -32768)
	{

		//negatif
		//Calcul:
		//  temperature = temperature + "-"
		FCI_SHEAD(FCV_TEMPERATURE,FCSZ_TEMPERATURE, "-",1, FCV_TEMPERATURE,FCSZ_TEMPERATURE);

	} else {

		//positif
		//Calcul:
		//  temperature = temperature + "+"
		FCI_SHEAD(FCV_TEMPERATURE,FCSZ_TEMPERATURE, "+",1, FCV_TEMPERATURE,FCSZ_TEMPERATURE);

	}

	//Décision
	//Décision: decimale < 10?
	if (FCV_DECIMALE < 10)
	{

		//genere chaine temperature
		//Calcul:
		//  temp = ToString$ (entier)
		//  temperature = temperature + temp
		//  temperature = temperature + ","
		//  temperature = temperature + "0"
		FCI_TOSTRING(FCV_ENTIER, FCV_TEMP,FCSZ_TEMP);
		FCI_SHEAD(FCV_TEMPERATURE,FCSZ_TEMPERATURE, FCV_TEMP,FCSZ_TEMP, FCV_TEMPERATURE,FCSZ_TEMPERATURE);
		FCI_SHEAD(FCV_TEMPERATURE,FCSZ_TEMPERATURE, ",",1, FCV_TEMPERATURE,FCSZ_TEMPERATURE);
		FCI_SHEAD(FCV_TEMPERATURE,FCSZ_TEMPERATURE, "0",1, FCV_TEMPERATURE,FCSZ_TEMPERATURE);

	} else {

		//genere chaine temperature
		//Calcul:
		//  temp = ToString$ (entier)
		//  temperature = temperature + temp
		//  temperature = temperature + ","
		FCI_TOSTRING(FCV_ENTIER, FCV_TEMP,FCSZ_TEMP);
		FCI_SHEAD(FCV_TEMPERATURE,FCSZ_TEMPERATURE, FCV_TEMP,FCSZ_TEMP, FCV_TEMPERATURE,FCSZ_TEMPERATURE);
		FCI_SHEAD(FCV_TEMPERATURE,FCSZ_TEMPERATURE, ",",1, FCV_TEMPERATURE,FCSZ_TEMPERATURE);

	}

	//genere chaine temperature
	//Calcul:
	//  temp = ToString$ (decimale)
	//  temperature = temperature + temp
	FCI_TOSTRING(FCV_DECIMALE, FCV_TEMP,FCSZ_TEMP);
	FCI_SHEAD(FCV_TEMPERATURE,FCSZ_TEMPERATURE, FCV_TEMP,FCSZ_TEMP, FCV_TEMPERATURE,FCSZ_TEMPERATURE);

	//Multi-Décision
	//Multi-Décision: capteur?
	switch (FCV_CAPTEUR)
	{
		case 0:
		{
			//Manipulation de Chaîne de caractères
			//Calcul:
			//  temperature = temperature + " Interieure"
			FCI_SHEAD(FCV_TEMPERATURE,FCSZ_TEMPERATURE, " Interieure",11, FCV_TEMPERATURE,FCSZ_TEMPERATURE);

			break;
		}
		case 1:
		{
			//Manipulation de Chaîne de caractères
			//Calcul:
			//  temperature = temperature + " Au sol   "
			FCI_SHEAD(FCV_TEMPERATURE,FCSZ_TEMPERATURE, " Au sol   ",10, FCV_TEMPERATURE,FCSZ_TEMPERATURE);

			break;
		}
		case 2:
		{
			//Manipulation de Chaîne de caractères
			//Calcul:
			//  temperature = temperature + " Exterieure"
			FCI_SHEAD(FCV_TEMPERATURE,FCSZ_TEMPERATURE, " Exterieure",11, FCV_TEMPERATURE,FCSZ_TEMPERATURE);

			break;
		}
		case 3:
		{
			//Manipulation de Chaîne de caractères
			//Calcul:
			//  temperature = temperature + " ??   "
			FCI_SHEAD(FCV_TEMPERATURE,FCSZ_TEMPERATURE, " ??   ",6, FCV_TEMPERATURE,FCSZ_TEMPERATURE);

			break;
		}
		// default:

	}

}


void FCM_batt()
{

	//Appel de la Routine Composant
	//Appel de la Routine Composant: batt=Lire_comme_Octet()
	FCV_BATT = FCD_ADC0_ReadAsByte();

	//Appel de la Routine Composant
	//Appel de la Routine Composant: Curseur(13, 3)
	FCD_LCDDisplay0_Cursor(13, 3);

	//Décision
	//Décision: batt > 159?
	if (FCV_BATT > 159)
	{

		//Décision
		//Décision: batt > 166?
		if (FCV_BATT > 166)
		{

			//Décision
			//Décision: batt > 172?
			if (FCV_BATT > 172)
			{

				//Décision
				//Décision: batt > 180?
				if (FCV_BATT > 180)
				{

					//Appel de la Routine Composant
					//Appel de la Routine Composant: Écrit_Caractère(0)
					FCD_LCDDisplay0_PrintASCII(0);

				} else {

					//Appel de la Routine Composant
					//Appel de la Routine Composant: Écrit_Caractère(1)
					FCD_LCDDisplay0_PrintASCII(1);

				}

			} else {

				//Appel de la Routine Composant
				//Appel de la Routine Composant: Écrit_Caractère(2)
				FCD_LCDDisplay0_PrintASCII(2);

			}

		} else {

			//Appel de la Routine Composant
			//Appel de la Routine Composant: Écrit_Caractère(3)
			FCD_LCDDisplay0_PrintASCII(3);

		}

	} else {

		//Appel de la Routine Composant
		//Appel de la Routine Composant: Écrit_Caractère(4)
		FCD_LCDDisplay0_PrintASCII(4);

	}

}



void main()
{
	//Initialisation
	ansel = 0;
	cmcon = 0x07;


	//Code Initialisation Interruption
	option_reg = 0xC0;


	//Appel d'une Macro
	//Appel d'une Macro: Initialisation()
	FCM_Initialisation();

	//Boucle
	//Boucle: Tant que 1
	while (1)
	{

		//Boucle
		//Boucle: Boucle 10 fois
		for (FCLV_LOOP1=0; FCLV_LOOP1<10; FCLV_LOOP1++)
		{

			//Calcul
			//Calcul:
			//  capteur = 0
			FCV_CAPTEUR = 0;

			//Boucle
			//Boucle: Tant que capteur = NBcapteur
			while (1)
			{

				//Appel d'une Macro
				//Appel d'une Macro: Capteurs()
				FCM_Capteurs();

				//Appel de la Routine Composant
				//Appel de la Routine Composant: Curseur(0, capteur)
				FCD_LCDDisplay0_Cursor(0, FCV_CAPTEUR);

				//Appel de la Routine Composant
				//Appel de la Routine Composant: Écrit_Chaîne(temperature)
				FCD_LCDDisplay0_PrintString(FCV_TEMPERATURE, FCSZ_TEMPERATURE);

				//Calcul
				//Calcul:
				//  capteur = capteur +1
				FCV_CAPTEUR = FCV_CAPTEUR + 1;


				if ((FCV_CAPTEUR == FCV_NBCAPTEUR) != 0) break;
			}


		}

		//Appel d'une Macro
		//Appel d'une Macro: batt()
		FCM_batt();


	}

	mainendloop: goto mainendloop;
}

void MX_INTERRUPT_MACRO(void)
{
}



