Picproje Elektronik Sitesi

DERLEYİCİLER => Diğer Derleyiciler => FLOWCODE => Konuyu başlatan: Epsilon - 25 Ekim 2019, 22:21:45

Başlık: FLOWCODE da FCFX uzantı nedir?
Gönderen: Epsilon - 25 Ekim 2019, 22:21:45
Araştırdığım bir konuda program flowcode ile yazılmış.
Elimde hex ve fcfx uzantılı 2 dosya var fcfx uzantıdan kaynak kodlara ulaşılabilirmiyiz?
Başlık: Ynt: FLOWCODE da FCFX uzantı nedir?
Gönderen: Mehmet Salim GÜLLÜCE - 01 Kasım 2019, 02:19:51
Alıntı yapılan: Epsilon - 25 Ekim 2019, 22:21:45Araştırdığım bir konuda program flowcode ile yazılmış.
Elimde hex ve fcfx uzantılı 2 dosya var fcfx uzantıdan kaynak kodlara ulaşılabilirmiyiz?
Yanılmıyorsam fcfx V5 ten sonraki versiyonlar için flowcode un oluşturduğu dosya.
V5 te fcf diye oluşturuyordu.
Eğer flowcode 7 veya 8 kuruluysa bilgisayarınızda açık kaynak kodu olarak kullanabilmeniz lazım.
Kurulu değilse o şansınız yok.
Kaldıki Flowcode kendi kütüphanelerini kullandığından sadece orada derlemek zorundasınız.
Derlendiğinde C çıktısınıda oluşturur ama pek işinize yaramaz.
Lakin genede program main alanını C dosyada görme şansına sahip olursunuz.
Aşağıdaki örnekteki gibi.

//************************************************************************************
//**  
//**  File name:     C:\Users\Dede\Documents\FlowCode\Dede\1 LED On-Off\1 LED On-Off.c
//**  Title:         
//**  Description:   
//**  
//**  Generated by:  Flowcode v5.5.2.1
//**  Date:          Thursday, October 31, 2019 23:11:39
//**  Licence:       Professional
//**  Registered to: xyz
//**  Licence key:   WUK7B9
//**  
//**  
//**  http://www.matrixmultimedia.com
//**  
//************************************************************************************


#define MX_PIC

#define MX_USES_UINT8 1
#define MX_USES_SINT16 0
#define MX_USES_CHAR 0
#define MX_USES_FLOAT 0
#define MX_USES_SINT32 0
#define MX_USES_BOOL 1
#define MX_USES_UINT16 0
#define MX_USES_UINT32 0
//Mikrodenetleyici için tan?mlamalar
#define P16F628A
#define FC_CAL_PIC
#define MX_EE
#define MX_EE_SIZE 128
#define MX_UART_1
#define MX_UART_1_TX_PORT portb
#define MX_UART_1_TX_TRIS trisb
#define MX_UART_1_TX_PIN 2
#define MX_UART_1_RX_PORT portb
#define MX_UART_1_RX_TRIS trisb
#define MX_UART_1_RX_PIN 1
#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 3

//Fonksiyonlar
#define MX_CLK_SPEED 19660800
#ifdef _BOOSTC
#include <system.h>
#endif
#ifdef HI_TECH_C
#include <pic.h>
#endif

//Dosya yap?land?rmas?

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

//Makro fonksiyon bildirileri


//De?i?ken bildirileri
#define FCV_TRUE (1)
#define FCV_FALSE (0)



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

//Makro uygulamas?



void main()
{
	
//Initialization
	
cmcon 0x07;


	
//Interrupt initialization code
	
option_reg 0xC0;


	
//Döngü
	
//Döngü: ?ken 1
	
while (
1)
	
{

	
	
//Ç?kt?  
	
	
//Ç?kt?  : 1 -> A0
	
	
trisa trisa 0xFE;
	
	
if ((
1))
	
	
	
porta = (porta 0xFE) | 0x01;
	
	
else
	
	
	
porta porta 0xFE;

	
	
//Gecikme   
	
	
//Gecikme   : 1 s
	
	
delay_s(1);

	
	
//Ç?kt?  
	
	
//Ç?kt?  : 0 -> A0
	
	
trisa trisa 0xFE;
	
	
if ((
0))
	
	
	
porta = (porta 0xFE) | 0x01;
	
	
else
	
	
	
porta porta 0xFE;

	
	
//Gecikme   
	
	
//Gecikme   : 1 s
	
	
delay_s(1);


	
}

	
mainendloop: goto mainendloop;
}

void MX_INTERRUPT_MACRO(void)
{
}



Oysa hepi topu code bu kadarcık bişey.
yukarıdaki bi çuval koda karşılık fcf dosyasını açtığınızda bunu görürsünüz.
(https://i.ibb.co/HNZ8S4w/resim.png) (https://ibb.co/HNZ8S4w)
Başlık: Ynt: FLOWCODE da FCFX uzantı nedir?
Gönderen: Epsilon - 01 Kasım 2019, 02:58:51
Yani kaynak koda ulaşılamıyor.Gerçi kodlar karmaşık şeyler değildir ama olsaydı iyi olurdu.

Başlık: Ynt: FLOWCODE da FCFX uzantı nedir?
Gönderen: Mehmet Salim GÜLLÜCE - 01 Kasım 2019, 17:54:36
Alıntı yapılan: Epsilon - 01 Kasım 2019, 02:58:51Yani kaynak koda ulaşılamıyor.Gerçi kodlar karmaşık şeyler değildir ama olsaydı iyi olurdu.


Ama FCF nin kendisi kaynakki..
Sadece derleyicisini kurmanız gerek
Başlık: Ynt: FLOWCODE da FCFX uzantı nedir?
Gönderen: Epsilon - 01 Kasım 2019, 18:58:10
Hocam mesaj gönderdim.
Başlık: Ynt: FLOWCODE da FCFX uzantı nedir?
Gönderen: Mehmet Salim GÜLLÜCE - 03 Kasım 2019, 00:32:03
C kod dökümanı şöyle
//************************************************************************************
//**  
//**  Source name:   C:\Users\Dede\Documents\FlowCode V8\Accu_Activator_Elektor_V2.fcfx
//**  Title:         
//**  Description:   
//**  Device:        PIC.16F.16F1847
//**  
//**  Generated by:  Flowcode v8.0.0.6
//**  Date:          Saturday, November 02, 2019 21:40:30
//**  Users:         1
//**  Registered to: 
//**  License key: *****
//**  
//**  http://www.matrixtsl.com
//**  
//************************************************************************************


#define MX_PIC

#define MX_CAL_PIC

#define MX_CLK_SPEED 16000000

#define FCP_NULL Unconnected_Port


#include <xc.h>
#include <math.h>
//Chip Configuration Settings
__PROG_CONFIG(0x10x9A4);
__PROG_CONFIG(0x20x1CFF);

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





/*========================================================================*\
   Use :panel
       :Variable declarations
       :Macro function declarations
\*========================================================================*/
#define FCVsz_STRTEMP 5
#define FCV_FALSE (0)
#define FCV_TRUE (1)
MX_GLOBAL MX_UINT8 FCV_HB0;
MX_GLOBAL MX_UINT16 FCV_VACC_HIGH;
MX_GLOBAL MX_FLOAT FCV_FV0;
MX_GLOBAL MX_UINT8 FCV_TAQUISITION_USEC;
MX_GLOBAL MX_UINT8 FCV_II;
MX_GLOBAL MX_FLOAT FCV_FR_INTERNAL;
MX_GLOBAL MX_UINT8 FCV_LB3;
MX_GLOBAL MX_UINT8 FCV_LB2;
MX_GLOBAL MX_UINT8 FCV_LB1;
MX_GLOBAL MX_UINT16 FCV_V0_MIN;
MX_GLOBAL MX_UINT8 FCV_LED_NUMBER;
MX_GLOBAL MX_UINT8 FCV_TIMER0_COUNTER;
MX_GLOBAL MX_UINT8 FCV_LB0;
MX_GLOBAL MX_UINT16 FCV_VACC_LOW;
MX_GLOBAL MX_FLOAT FCV_TEMP_FLOAT;
MX_GLOBAL MX_FLOAT FCV_CURRENT;
MX_GLOBAL MX_UINT8 FCV_TDELAY_USEC;
MX_GLOBAL MX_UINT8 FCV_WAIT_SECONDS;
MX_GLOBAL MX_UINT8 FCV_CALCULATIONS_WITHOUT_ERROR;
MX_GLOBAL MX_FLOAT FCV_FVSHUNT_TOPSIDE;
MX_GLOBAL MX_UINT8 FCV_TEMP;
MX_GLOBAL MX_FLOAT FCV_FVSHUNT_BOTTOMSIDE;
MX_GLOBAL MX_FLOAT FCV_FV0_MIN;
MX_GLOBAL MX_UINT16 FCV_VLEAD_LOW;
MX_GLOBAL MX_UINT16 FCV_TEMP_Z;
MX_GLOBAL MX_UINT8 FCV_STATUSA5;
MX_GLOBAL MX_UINT8 FCV_RSHUNT_MOHM;
MX_GLOBAL MX_CHAR FCV_STRTEMP[FCVsz_STRTEMP];
MX_GLOBAL MX_UINT8 FCV_CHANGE_SECONDS;
MX_GLOBAL MX_UINT8 FCV_VOLTAGE_PART;
MX_GLOBAL MX_FLOAT FCV_RSHUNT;
MX_GLOBAL MX_UINT16 FCV_VLEAD_HIGH;
MX_GLOBAL MX_UINT8 FCV_ERRORNUMBER;
MX_GLOBAL MX_UINT8 FCV_SECONDS;
MX_GLOBAL MX_FLOAT FCV_CURRENT_MAX;
MX_GLOBAL MX_UINT8 FCV_ACTUAL_LED_NUMBER;
MX_GLOBAL MX_UINT8 FCV_PULSESENT;
MX_GLOBAL MX_UINT8 FCV_HB3;
MX_GLOBAL MX_UINT8 FCV_HB2;
MX_GLOBAL MX_UINT16 FCV_ADC_READING;
MX_GLOBAL MX_UINT8 FCV_LED_NUMBER_PREVIOUS;
MX_GLOBAL MX_FLOAT FCV_FV_TERMINAL;
MX_GLOBAL MX_UINT8 FCV_HB1;

void FCM_FloatTo4Char(MX_FLOAT FCL_FLOATTOPRINT);
void FCM_Test_Voltage_V0();
void FCM_Timer0_Interrupt();
void FCM_Dead_end();
MX_UINT8 FCM_TriState_Input_ports_B(MX_UINT8 FCL_B_PORT_NUMBER);
void FCM_Init();
MX_UINT16 FCM_Voltage_to_ADC(MX_FLOAT FCL_FV_IN);
MX_FLOAT FCM_ADC_to_Voltage(MX_UINT8 FCL_HIGH_BYTEMX_UINT8 FCL_LOW_BYTE);
void FCM_TriState_Output_Ports_A(MX_UINT8 FCL_LED_NUM);
MX_UINT8 FCM_Current_and_Internal_resistance();
void FCM_ADC_AN1();

/*========================================================================*\
   Use :fcdhelper
       :Variable declarations
       :Macro function declarations
\*========================================================================*/

/*========================================================================*\
   Use :cal_adc
       :Variable declarations
       :Macro function declarations
\*========================================================================*/
#define ADC_3_MX_ADC_ACTIME 10
#define MX_ADC_REF 
#define ADC_3_MX_ADC_VREFVOL 500
#define MX_ADC_CHANNEL_1 
#define MX_ADC_TYPE_23 
#define ADC_3_MX_ADC_VREFOP 0
#define ADC_3_MX_ADC_CONVSP 5
#define MX_ADC_BITS_10 
#define ADC_3_MX_ADC_CHANNEL 1

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

void FC_CAL_ADC_Disable();
void FC_CAL_ADC_Enable(MX_UINT8 FCL_CHANNELMX_UINT8 FCL_CONV_SPEEDMX_UINT8 FCL_VREFMX_UINT8 FCL_T_CHARGE);
MX_UINT16 FC_CAL_ADC_Sample(MX_UINT8 FCL_SAMPLE_MODE);

/*========================================================================*\
   Use :fcdhelper
       :Variable declarations
       :Macro function declarations
\*========================================================================*/

/*========================================================================*\
   Use :cal_adc
       :Variable declarations
       :Macro function declarations
\*========================================================================*/
#define ADC_2_MX_ADC_ACTIME 10
#define MX_ADC_REF 
#define ADC_2_MX_ADC_VREFVOL 500
#define MX_ADC_CHANNEL_0 
#define MX_ADC_TYPE_23 
#define ADC_2_MX_ADC_VREFOP 0
#define ADC_2_MX_ADC_CONVSP 5
#define MX_ADC_BITS_10 
#define ADC_2_MX_ADC_CHANNEL 0

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

void FC_CAL_ADC_Disable();
void FC_CAL_ADC_Enable(MX_UINT8 FCL_CHANNELMX_UINT8 FCL_CONV_SPEEDMX_UINT8 FCL_VREFMX_UINT8 FCL_T_CHARGE);
MX_UINT16 FC_CAL_ADC_Sample(MX_UINT8 FCL_SAMPLE_MODE);

/*========================================================================*\
   Use :fcdhelper
       :Variable declarations
       :Macro function declarations
\*========================================================================*/

/*========================================================================*\
   Use :cal_adc
       :Variable declarations
       :Macro function declarations
\*========================================================================*/
#define ADC_1_MX_ADC_ACTIME 10
#define MX_ADC_REF 
#define ADC_1_MX_ADC_VREFVOL 500
#define MX_ADC_CHANNEL_6 
#define MX_ADC_TYPE_23 
#define ADC_1_MX_ADC_VREFOP 0
#define ADC_1_MX_ADC_CONVSP 5
#define MX_ADC_BITS_10 
#define ADC_1_MX_ADC_CHANNEL 6

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

void FC_CAL_ADC_Disable();
void FC_CAL_ADC_Enable(MX_UINT8 FCL_CHANNELMX_UINT8 FCL_CONV_SPEEDMX_UINT8 FCL_VREFMX_UINT8 FCL_T_CHARGE);
MX_UINT16 FC_CAL_ADC_Sample(MX_UINT8 FCL_SAMPLE_MODE);

/*========================================================================*\
   Use :ctrl_lcd
       :Variable declarations
       :Macro function declarations
\*========================================================================*/

/*========================================================================*\
   Use :LCD
       :Variable declarations
       :Macro function declarations
\*========================================================================*/
void FCD_04071_LCD__Clear();
void FCD_04071_LCD__PrintString(MX_CHAR *FCL_TEXTMX_UINT16 FCLsz_TEXT);
void FCD_04071_LCD__PrintAscii(MX_UINT8 FCL_CHARACTER);
void FCD_04071_LCD__PrintNumber(MX_SINT16 FCL_NUMBER);
void FCD_04071_LCD__RAMWrite(MX_UINT8 FCL_INDEXMX_UINT8 FCL_D0MX_UINT8 FCL_D1MX_UINT8 FCL_D2MX_UINT8 FCL_D3MX_UINT8 FCL_D4MX_UINT8 FCL_D5MX_UINT8 FCL_D6MX_UINT8 FCL_D7);
void FCD_04071_LCD__ClearLine(MX_UINT8 FCL_LINE);
void FCD_04071_LCD__Cursor(MX_UINT8 FCL_XMX_UINT8 FCL_Y);
void FCD_04071_LCD__Command(MX_UINT8 FCL_INSTRUCTION);
void FCD_04071_LCD__PrintFormattedNumber(MX_UINT32 FCL_NUMBERMX_BOOL FCL_FORMAT);
void FCD_04071_LCD__ScrollDisplay(MX_UINT8 FCL_POSITIONMX_UINT8 FCL_DIRECTION);
void FCD_04071_LCD__RawSend(MX_UINT8 FCL_DATAMX_BOOL FCL_TYPE);
void FCD_04071_LCD__RemapCharacter(MX_UINT8 FCL_REMAPIDXMX_UINT8 FCL_SEARCHCHARACTERMX_UINT8 FCL_REPLACEMENTCHARACTER);
void FCD_04071_LCD__Start();

/*========================================================================*\
   Use :lcd_eb005
       :Variable declarations
       :Macro function declarations
\*========================================================================*/
void FCD_0ad31_lcd_eb005__Clear();
void FCD_0ad31_lcd_eb005__PrintString(MX_CHAR *FCL_TEXTMX_UINT16 FCLsz_TEXT);
void FCD_0ad31_lcd_eb005__PrintAscii(MX_UINT8 FCL_CHARACTER);
void FCD_0ad31_lcd_eb005__PrintNumber(MX_SINT16 FCL_NUMBER);
void FCD_0ad31_lcd_eb005__RAMWrite(MX_UINT8 FCL_INDEXMX_UINT8 FCL_D0MX_UINT8 FCL_D1MX_UINT8 FCL_D2MX_UINT8 FCL_D3MX_UINT8 FCL_D4MX_UINT8 FCL_D5MX_UINT8 FCL_D6MX_UINT8 FCL_D7);
void FCD_0ad31_lcd_eb005__ClearLine(MX_UINT8 FCL_LINE);
void FCD_0ad31_lcd_eb005__Cursor(MX_UINT8 FCL_XMX_UINT8 FCL_Y);
void FCD_0ad31_lcd_eb005__Command(MX_UINT8 FCL_INSTRUCTION);
void FCD_0ad31_lcd_eb005__PrintFormattedNumber(MX_UINT32 FCL_NUMBERMX_BOOL FCL_FORMAT);
void FCD_0ad31_lcd_eb005__ScrollDisplay(MX_UINT8 FCL_POSITIONMX_UINT8 FCL_DIRECTION);
void FCD_0ad31_lcd_eb005__RawSend(MX_UINT8 FCL_DATAMX_BOOL FCL_TYPE);
void FCD_0ad31_lcd_eb005__RemapCharacter(MX_UINT8 FCL_REMAPIDXMX_UINT8 FCL_SEARCHCHARACTERMX_UINT8 FCL_REPLACEMENTCHARACTER);
void FCD_0ad31_lcd_eb005__Start();

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


/*========================================================================*\
   Use :fcdhelper
       :Macro implementations
\*========================================================================*/

/*========================================================================*\
   Use :cal_adc
       :Macro implementations
\*========================================================================*/

/*========================================================================*\
   Use :fcdhelper
       :Macro implementations
\*========================================================================*/

/*========================================================================*\
   Use :cal_adc
       :Macro implementations
\*========================================================================*/

/*========================================================================*\
   Use :fcdhelper
       :Macro implementations
\*========================================================================*/

/*========================================================================*\
   Use :cal_adc
       :Macro implementations
\*========================================================================*/

/*========================================================================*\
   Use :ctrl_lcd
       :Macro implementations
\*========================================================================*/

/*========================================================================*\
   Use :LCD
       :Macro implementations
\*========================================================================*/
/*=----------------------------------------------------------------------=*\
   Use :Clears the entire contents of the display.
\*=----------------------------------------------------------------------=*/
void FCD_04071_LCD__Clear()
{




	
FCD_04071_LCD__RawSend(0x010);

	
FCI_DELAYBYTE_MS(2);

	
FCD_04071_LCD__RawSend(0x020);

	
FCI_DELAYBYTE_MS(2);

}

/*=----------------------------------------------------------------------=*\
   Use :Breaks down a string of text and sends it to the LCD via the private RawSend(byte, mask) macro
       :
       :Parameters for macro PrintString:
       :  Text[20] : Enter the text or variable to print to the LCD
\*=----------------------------------------------------------------------=*/
void FCD_04071_LCD__PrintString(MX_CHAR *FCL_TEXTMX_UINT16 FCLsz_TEXT)
{
	
//Local variable definitions
	
MX_UINT8 FCL_IDX = (0x0);
	
MX_UINT8 FCL_COUNT;


	
FCL_COUNT FCI_GETLENGTH(FCL_TEXTFCLsz_TEXT);

	
while (
FCL_IDX FCL_COUNT)
	
{

	
	
#if (0) // 0 > 0

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


	
	
	
FCD_04071_LCD__RawSend(FCL_TEXT[FCL_IDX], 0x10);

	
	
#endif

	
	
FCL_IDX FCL_IDX 1;


	
}


}

/*=----------------------------------------------------------------------=*\
   Use :Takes the ascii value for a character and prints the character
       :
       :Parameters for macro PrintAscii:
       :  character : Holds an ascii value.
\*=----------------------------------------------------------------------=*/
void FCD_04071_LCD__PrintAscii(MX_UINT8 FCL_CHARACTER)
{

	
FCD_04071_LCD__RawSend(FCL_CHARACTER0x10);



}

/*=----------------------------------------------------------------------=*\
   Use :Based on v5 macro, will allow you to print a number. This is limited to a signed-INT, -32768 to 32767
       :
       :Parameters for macro PrintNumber:
       :  Number : Enter the number or variable to print to the LCD
\*=----------------------------------------------------------------------=*/
void FCD_04071_LCD__PrintNumber(MX_SINT16 FCL_NUMBER)
{
	
//Local variable definitions
#define FCLsz_S 10
	
MX_CHAR FCL_S[FCLsz_S];


	
FCI_TOSTRING(FCL_NUMBERFCL_S,10);

	
FCD_04071_LCD__PrintString(FCL_SFCLsz_S);

	
//Local variable definitions
#undef FCLsz_S
}

/*=----------------------------------------------------------------------=*\
   Use :Modifies the internal memory of the LCD to allow for up to 8 customised characters to be created and stored in the device memory
       :
       :Parameters for macro RAMWrite:
       :  Index : Values 0 to 7
       :  d0 : MX_UINT8
       :  d1 : MX_UINT8
       :  d2 : MX_UINT8
       :  d3 : MX_UINT8
       :  d4 : MX_UINT8
       :  d5 : MX_UINT8
       :  d6 : MX_UINT8
       :  d7 : MX_UINT8
\*=----------------------------------------------------------------------=*/
void FCD_04071_LCD__RAMWrite(MX_UINT8 FCL_INDEXMX_UINT8 FCL_D0MX_UINT8 FCL_D1MX_UINT8 FCL_D2MX_UINT8 FCL_D3MX_UINT8 FCL_D4MX_UINT8 FCL_D5MX_UINT8 FCL_D6MX_UINT8 FCL_D7)
{

	
FCD_04071_LCD__RawSend(64 + (FCL_INDEX << 3), 0);

	
FCI_DELAYBYTE_MS(2);

	
FCD_04071_LCD__RawSend(FCL_D00x10);

	
FCD_04071_LCD__RawSend(FCL_D10x10);

	
FCD_04071_LCD__RawSend(FCL_D20x10);

	
FCD_04071_LCD__RawSend(FCL_D30x10);

	
FCD_04071_LCD__RawSend(FCL_D40x10);

	
FCD_04071_LCD__RawSend(FCL_D50x10);

	
FCD_04071_LCD__RawSend(FCL_D60x10);

	
FCD_04071_LCD__RawSend(FCL_D70x10);

	
FCD_04071_LCD__Clear();

}

/*=----------------------------------------------------------------------=*\
   Use :Clears a single line on the display and then moves the cursor to the start of the line to allow you to start populating the line with data.
       :
       :Parameters for macro ClearLine:
       :  Line : The line to clear, zero being the first (top) line of the display
\*=----------------------------------------------------------------------=*/
void FCD_04071_LCD__ClearLine(MX_UINT8 FCL_LINE)
{
	
//Local variable definitions
	
MX_UINT8 FCL_X;


	
if (
FCL_LINE 2)
	
{

	
	
FCD_04071_LCD__Cursor(0FCL_LINE);

	
	
FCL_X 0;

	
	
while (
FCL_X 16)
	
	
{


	
	
	
FCD_04071_LCD__RawSend(' '0x10);

	
	
	
FCL_X FCL_X 1;


	
	
}

	
	
FCD_04071_LCD__Cursor(0FCL_LINE);

	
// } else {

	
}

}

/*=----------------------------------------------------------------------=*\
   Use :Moves the cursor on the LCD Display
       :
       :Parameters for macro Cursor:
       :  x : Set the cursor position in the X plane, 0 is the left most cell
       :  y : Set the cursor position in the Y plane, 0 is the top most cell
\*=----------------------------------------------------------------------=*/
void FCD_04071_LCD__Cursor(MX_UINT8 FCL_XMX_UINT8 FCL_Y)
{



	
#if (0) // 2 == 1

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

	
#endif

	
#if (1) // 2 == 2

	
	
if (
FCL_Y == 0)
	
	
{

	
	
	
FCL_Y 0x80;

	
	
} else {

	
	
	
FCL_Y 0xC0;

	
	
}

	
// #else

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

	
#if (0) // 2 == 4

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

	
#endif

	
FCD_04071_LCD__RawSend(FCL_Y FCL_X0);

	
FCI_DELAYBYTE_MS(2);

}

/*=----------------------------------------------------------------------=*\
   Use :Use this method/macro to send a specific command to the LCD. Refer to the Matrix Multimedia EB006 datasheet for a list of supported instructions. For Non-Matrix LCD's refer to the manufacturers datasheet.
       :
       :Parameters for macro Command:
       :  instruction : Send a defined command to the LCD Screen. See datasheet for supported commands.
\*=----------------------------------------------------------------------=*/
void FCD_04071_LCD__Command(MX_UINT8 FCL_INSTRUCTION)
{

	
FCD_04071_LCD__RawSend(FCL_INSTRUCTION0);

	
FCI_DELAYBYTE_MS(2);

}

/*=----------------------------------------------------------------------=*\
   Use :Will allow you to print a number up to 32-bits with signed or unsigned formatting.

       :Signed = -2147483648 to 2147483647

       :Unsigned = 0 to 4294967295
       :
       :Parameters for macro PrintFormattedNumber:
       :  Number : Enter the number or variable to print to the LCD
       :  Format : 0=Signed, 1=Unsigned
\*=----------------------------------------------------------------------=*/
void FCD_04071_LCD__PrintFormattedNumber(MX_UINT32 FCL_NUMBERMX_BOOL FCL_FORMAT)
{
	
//Local variable definitions
#define FCLsz_S 15
	
MX_CHAR FCL_S[FCLsz_S];


	
if (
FCL_FORMAT == 1)
	
{

	
	
FCI_UTOS32(FCL_NUMBERFCL_S,15);

	
} else {

	
	
FCI_ITOS32((MX_SINT32)(FCL_NUMBER), FCL_S,15);

	
}

	
FCD_04071_LCD__PrintString(FCL_SFCLsz_S);

	
//Local variable definitions
#undef FCLsz_S
}

/*=----------------------------------------------------------------------=*\
   Use :Scrolls the display left or right by a number of given positions.
       :
       :Parameters for macro ScrollDisplay:
       :  Position : Holds the number of positions to shift the display
       :  Direction : 0 = left, 1 = right
\*=----------------------------------------------------------------------=*/
void FCD_04071_LCD__ScrollDisplay(MX_UINT8 FCL_POSITIONMX_UINT8 FCL_DIRECTION)
{
	
//Local variable definitions
	
MX_UINT8 FCL_CMD = (0x0);


	
FCL_CMD 0;

	
if (
FCL_DIRECTION == 0)
	
{

	
	
FCL_CMD 0x18;


	
} else {

	
	
FCL_CMD 0x1C;


	
}

	
if (
FCL_CMD != && FCL_POSITION != 0)
	
{

	
	
while (
FCL_POSITION != 0)
	
	
{

	
	
	
FCD_04071_LCD__RawSend(FCL_CMD0);

	
	
	
FCL_POSITION FCL_POSITION 1;


	
	
}

	
// } else {

	
}

}

/*=----------------------------------------------------------------------=*\
   Use :Sends data to the LCD display
       :
       :Parameters for macro RawSend:
       :  data : The data byte to send to the LCD
       :  type : A boolean to indicate command type: true to write data, false to write a command
\*=----------------------------------------------------------------------=*/
void FCD_04071_LCD__RawSend(MX_UINT8 FCL_DATAMX_BOOL FCL_TYPE)
{
	
//Local variable definitions
	
MX_UINT8 FCL_NIBBLE;


	
//Comment:
	
//Output upper nibble of the byte

	
#if (1) // 0 == 0

	
	
SET_PORT_PIN(A30);
	
	
SET_PORT_PIN(B60);
	
	
SET_PORT_PIN(B00);
	
	
SET_PORT_PIN(B10);
	
	
SET_PORT_PIN(B20);
	
	
SET_PORT_PIN(A40);

	
	
#if (0)

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

	
	
#endif

	
	
FCL_NIBBLE = (FCL_DATA >> 4);
	
	
SET_PORT_PIN(A3, (FCL_NIBBLE 0x01));
	
	
FCL_NIBBLE FCL_NIBBLE >> 1;
	
	
SET_PORT_PIN(B6, (FCL_NIBBLE 0x01));
	
	
FCL_NIBBLE FCL_NIBBLE >> 1;
	
	
SET_PORT_PIN(B0, (FCL_NIBBLE 0x01));
	
	
FCL_NIBBLE FCL_NIBBLE >> 1;
	
	
SET_PORT_PIN(B1, (FCL_NIBBLE 0x01));

	
// #else

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

	
//Comment:
	
//Output byte to pins

	
#if (0) // 0 == 1

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

	
#endif

	
//Comment:
	
//Output byte to port

	
#if (0) // 0 == 2

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

	
#endif

	
if (
FCL_TYPE)
	
{

	
	
SET_PORT_PIN(B21);

	
// } else {

	
}

	
FCI_DELAYBYTE_US(100);

	
//Comment:
	
//Set Enable high, pause then set low

	
//to acknowledge the data has been 
	
//submitted.

	
SET_PORT_PIN(A41);

	
FCI_DELAYBYTE_US(100);

	
SET_PORT_PIN(A40);

	
FCI_DELAYBYTE_US(100);

	
#if (1) // 0 == 0

	
	
SET_PORT_PIN(A30);
	
	
SET_PORT_PIN(B60);
	
	
SET_PORT_PIN(B00);
	
	
SET_PORT_PIN(B10);
	
	
SET_PORT_PIN(B20);

	
	
FCL_NIBBLE = (FCL_DATA 0xf);
	
	
SET_PORT_PIN(A3, (FCL_NIBBLE 0x01));
	
	
FCL_NIBBLE FCL_NIBBLE >> 1;
	
	
SET_PORT_PIN(B6, (FCL_NIBBLE 0x01));
	
	
FCL_NIBBLE FCL_NIBBLE >> 1;
	
	
SET_PORT_PIN(B0, (FCL_NIBBLE 0x01));
	
	
FCL_NIBBLE FCL_NIBBLE >> 1;
	
	
SET_PORT_PIN(B1, (FCL_NIBBLE 0x01));

	
	
if (
FCL_TYPE)
	
	
{

	
	
	
SET_PORT_PIN(B21);

	
	
// } else {

	
	
}

	
	
FCI_DELAYBYTE_US(100);

	
	
SET_PORT_PIN(A41);

	
	
FCI_DELAYBYTE_US(100);

	
	
SET_PORT_PIN(A40);

	
	
FCI_DELAYBYTE_US(100);

	
// #else

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

}

/*=----------------------------------------------------------------------=*\
   Use :Assigns a remap character allowing the PrintString function to automatically swap between pre-defined characters. 

       :The characters can be custom (in the range 0-9) or can point to an existing character in the LCD character map.
       :
       :Parameters for macro RemapCharacter:
       :  RemapIdx : Remap Index, Range: 0 to (Remap Characters - 1)
       :  SearchCharacter : Character to look for a replace
       :  ReplacementCharacter : New character value to use in place of the search character.
\*=----------------------------------------------------------------------=*/
void FCD_04071_LCD__RemapCharacter(MX_UINT8 FCL_REMAPIDXMX_UINT8 FCL_SEARCHCHARACTERMX_UINT8 FCL_REPLACEMENTCHARACTER)
{

	
#if (0) // 0 > 0

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

	
#endif

}

/*=----------------------------------------------------------------------=*\
   Use :Startup routine required by the hardware device.

       :Automatically clears the display after initialising.
\*=----------------------------------------------------------------------=*/
void FCD_04071_LCD__Start()
{




	
#if (1) // 0 == 0

	
	
SET_PORT_PIN(A30);
	
	
SET_PORT_PIN(B60);
	
	
SET_PORT_PIN(B00);
	
	
SET_PORT_PIN(B10);
	
	
SET_PORT_PIN(B20);
	
	
SET_PORT_PIN(A40);

	
// #else

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

	
#if (0) // 0 == 1

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

	
#endif

	
#if (0) // 0 == 2

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

	
#endif

	
#if (0)

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

	
#endif

	
FCI_DELAYBYTE_MS(12);

	
FCD_04071_LCD__RawSend(0x330);

	
FCI_DELAYBYTE_MS(2);

	
FCD_04071_LCD__RawSend(0x330);

	
FCI_DELAYBYTE_MS(2);

	
#if (0) // 0 > 0

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

	
	
FCD_04071_LCD__RawSend(0x320);

	
	
FCI_DELAYBYTE_MS(2);

	
	
FCD_04071_LCD__RawSend(0x2c0);

	
#endif

	
FCI_DELAYBYTE_MS(2);

	
FCD_04071_LCD__RawSend(0x060);

	
FCI_DELAYBYTE_MS(2);

	
FCD_04071_LCD__RawSend(0x0c0);

	
FCI_DELAYBYTE_MS(2);

	
FCD_04071_LCD__RawSend(0x010);

	
FCI_DELAYBYTE_MS(2);

	
FCD_04071_LCD__RawSend(0x020);

	
FCI_DELAYBYTE_MS(2);

	
FCD_04071_LCD__Clear();

	
#if (0) // 0 > 0

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

	
#endif

}


/*========================================================================*\
   Use :lcd_eb005
       :Macro implementations
\*========================================================================*/
/*=----------------------------------------------------------------------=*\
   Use :Clears the entire contents of the display.
\*=----------------------------------------------------------------------=*/
void FCD_0ad31_lcd_eb005__Clear()
{

	
FCD_04071_LCD__Clear();

}

/*=----------------------------------------------------------------------=*\
   Use :Breaks down a string of text and sends it to the LCD via the private RawSend(byte, mask) macro
       :
       :Parameters for macro PrintString:
       :  Text[20] : Enter the text or variable to print to the LCD
\*=----------------------------------------------------------------------=*/
void FCD_0ad31_lcd_eb005__PrintString(MX_CHAR *FCL_TEXTMX_UINT16 FCLsz_TEXT)
{

	
FCD_04071_LCD__PrintString(FCL_TEXTFCLsz_TEXT);

}

/*=----------------------------------------------------------------------=*\
   Use :Takes the ascii value for a character and prints the character
       :
       :Parameters for macro PrintAscii:
       :  character : Holds an ascii value.
\*=----------------------------------------------------------------------=*/
void FCD_0ad31_lcd_eb005__PrintAscii(MX_UINT8 FCL_CHARACTER)
{

	
FCD_04071_LCD__PrintAscii(FCL_CHARACTER);

}

/*=----------------------------------------------------------------------=*\
   Use :Based on v5 macro, will allow you to print a number. This is limited to a signed-INT, -32768 to 32767
       :
       :Parameters for macro PrintNumber:
       :  Number : Enter the number or variable to print to the LCD
\*=----------------------------------------------------------------------=*/
void FCD_0ad31_lcd_eb005__PrintNumber(MX_SINT16 FCL_NUMBER)
{

	
FCD_04071_LCD__PrintNumber(FCL_NUMBER);

}

/*=----------------------------------------------------------------------=*\
   Use :Modifies the internal memory of the LCD to allow for up to 8 customised characters to be created and stored in the device memory
       :
       :Parameters for macro RAMWrite:
       :  Index : Values 0 to 7
       :  d0 : MX_UINT8
       :  d1 : MX_UINT8
       :  d2 : MX_UINT8
       :  d3 : MX_UINT8
       :  d4 : MX_UINT8
       :  d5 : MX_UINT8
       :  d6 : MX_UINT8
       :  d7 : MX_UINT8
\*=----------------------------------------------------------------------=*/
void FCD_0ad31_lcd_eb005__RAMWrite(MX_UINT8 FCL_INDEXMX_UINT8 FCL_D0MX_UINT8 FCL_D1MX_UINT8 FCL_D2MX_UINT8 FCL_D3MX_UINT8 FCL_D4MX_UINT8 FCL_D5MX_UINT8 FCL_D6MX_UINT8 FCL_D7)
{

	
FCD_04071_LCD__RAMWrite(FCL_INDEXFCL_D0FCL_D1FCL_D2FCL_D3FCL_D4FCL_D5FCL_D6FCL_D7);

}

/*=----------------------------------------------------------------------=*\
   Use :Clears a single line on the display and then moves the cursor to the start of the line to allow you to start populating the line with data.
       :
       :Parameters for macro ClearLine:
       :  Line : The line to clear, zero being the first (top) line of the display
\*=----------------------------------------------------------------------=*/
void FCD_0ad31_lcd_eb005__ClearLine(MX_UINT8 FCL_LINE)
{

	
FCD_04071_LCD__ClearLine(FCL_LINE);

}

/*=----------------------------------------------------------------------=*\
   Use :Moves the cursor on the LCD Display
       :
       :Parameters for macro Cursor:
       :  x : Set the cursor position in the X plane, 0 is the left most cell
       :  y : Set the cursor position in the Y plane, 0 is the top most cell
\*=----------------------------------------------------------------------=*/
void FCD_0ad31_lcd_eb005__Cursor(MX_UINT8 FCL_XMX_UINT8 FCL_Y)
{

	
FCD_04071_LCD__Cursor(FCL_XFCL_Y);

}

/*=----------------------------------------------------------------------=*\
   Use :Use this method/macro to send a specific command to the LCD. Refer to the Matrix Multimedia EB006 datasheet for a list of supported instructions. For Non-Matrix LCD's refer to the manufacturers datasheet.
       :
       :Parameters for macro Command:
       :  instruction : Send a defined command to the LCD Screen. See datasheet for supported commands.
\*=----------------------------------------------------------------------=*/
void FCD_0ad31_lcd_eb005__Command(MX_UINT8 FCL_INSTRUCTION)
{

	
FCD_04071_LCD__Command(FCL_INSTRUCTION);

}

/*=----------------------------------------------------------------------=*\
   Use :Will allow you to print a number up to 32-bits with signed or unsigned formatting.

       :Signed = -2147483648 to 2147483647

       :Unsigned = 0 to 4294967295
       :
       :Parameters for macro PrintFormattedNumber:
       :  Number : Enter the number or variable to print to the LCD
       :  Format : 0=Signed, 1=Unsigned
\*=----------------------------------------------------------------------=*/
void FCD_0ad31_lcd_eb005__PrintFormattedNumber(MX_UINT32 FCL_NUMBERMX_BOOL FCL_FORMAT)
{

	
FCD_04071_LCD__PrintFormattedNumber(FCL_NUMBERFCL_FORMAT);

}

/*=----------------------------------------------------------------------=*\
   Use :Scrolls the display left or right by a number of given positions.
       :
       :Parameters for macro ScrollDisplay:
       :  Position : Holds the number of positions to shift the display
       :  Direction : 0 = left, 1 = right
\*=----------------------------------------------------------------------=*/
void FCD_0ad31_lcd_eb005__ScrollDisplay(MX_UINT8 FCL_POSITIONMX_UINT8 FCL_DIRECTION)
{

	
FCD_04071_LCD__ScrollDisplay(FCL_POSITIONFCL_DIRECTION);

}

/*=----------------------------------------------------------------------=*\
   Use :Sends data to the LCD display
       :
       :Parameters for macro RawSend:
       :  data : The data byte to send to the LCD
       :  type : A boolean to indicate command type: true to write data, false to write a command
\*=----------------------------------------------------------------------=*/
void FCD_0ad31_lcd_eb005__RawSend(MX_UINT8 FCL_DATAMX_BOOL FCL_TYPE)
{

	
FCD_04071_LCD__RawSend(FCL_DATAFCL_TYPE);

}

/*=----------------------------------------------------------------------=*\
   Use :Assigns a remap character allowing the PrintString function to automatically swap between pre-defined characters. 

       :The characters can be custom (in the range 0-9) or can point to an existing character in the LCD character map.
       :
       :Parameters for macro RemapCharacter:
       :  RemapIdx : Remap Index, Range: 0 to (Remap Characters - 1)
       :  SearchCharacter : Character to look for a replace
       :  ReplacementCharacter : New character value to use in place of the search character.
\*=----------------------------------------------------------------------=*/
void FCD_0ad31_lcd_eb005__RemapCharacter(MX_UINT8 FCL_REMAPIDXMX_UINT8 FCL_SEARCHCHARACTERMX_UINT8 FCL_REPLACEMENTCHARACTER)
{

	
FCD_04071_LCD__RemapCharacter(FCL_REMAPIDXFCL_SEARCHCHARACTERFCL_REPLACEMENTCHARACTER);

}

/*=----------------------------------------------------------------------=*\
   Use :Startup routine required by the hardware device.

       :Automatically clears the display after initialising.
\*=----------------------------------------------------------------------=*/
void FCD_0ad31_lcd_eb005__Start()
{

	
FCD_04071_LCD__Start();

}


/*========================================================================*\
   Use :panel
       :Macro implementations
\*========================================================================*/
/*=----------------------------------------------------------------------=*\
   Use :Parameters for macro FloatTo4Char:
       :  FloatToPrint : MX_FLOAT
\*=----------------------------------------------------------------------=*/
void FCM_FloatTo4Char(MX_FLOAT FCL_FLOATTOPRINT)
{

	
//Comment:
	
//Transforms floating point variable into string with 4 digits

	
// Name: Beslissing, Type: Decision: .FloatToPrint < 10000?
	
if (
flt_lt(FCL_FLOATTOPRINT10000))
	
{

	
	
// Name: Converse floating point to string, Type: Calculation:
	
	
// Name: Converse floating point to string, Type:  StrTemp = FloatToString$ (.FloatToPrint)
	
	
FCI_FLOAT_TO_STRING(FCL_FLOATTOPRINTFCV_PRECISIONFCV_STRTEMPFCVsz_STRTEMP);

	
	
// Name: The first 4 characters, Type: Calculation:
	
	
// Name: The first 4 characters, Type:  StrTemp = Left$ (StrTemp,4)
	
	
FCI_LEFTSTRING(FCV_STRTEMPFCVsz_STRTEMP4FCV_STRTEMP,5);

	
} else {

	
	
// Name: Set string to max value, Type: Calculation:
	
	
// Name: Set string to max value, Type:  StrTemp = "9999"
	
	
FCI_SCOPY("9999",5FCV_STRTEMP,FCVsz_STRTEMP);

	
}

}

/*=----------------------------------------------------------------------=*\
   Use :
\*=----------------------------------------------------------------------=*/
void FCM_Test_Voltage_V0()
{

	
//Comment:
	
//Test V0 > V0_min and
	
//Test V_ADC >1019 (out of range)

	
// Name: Save LED#, Type: Calculation:
	
// Name: Save LED#, Type:  LED_Number_Previous = LED_Number
	
FCV_LED_NUMBER_PREVIOUS FCV_LED_NUMBER;

	
// Name: Reset Voltage, Type: Calculation:
	
// Name: Reset Voltage, Type:  ADC_reading = 0
	
FCV_ADC_READING 0;

	
// Name: Disable Timer0 , Type: Interrupt: Disable TMR0
	
cr_bit(INTCONTMR0IE);

	
//Comment:
	
//Test V0 is present? 
	
//And is V0 not to high (out of range)?

	
//Comment:
	
//ADC  (AN0....AN11)
	
//Register ADCON1 for PIC16F1847:
	
//bit7:   ADFM=1 with the 2 bits of ADRESH right justified
	
//bit6-4: ADCS =5 for Fosc/16 conversion clock
	
//bit3:   x
	
//bit2:   ADNREF= 0 with Vref- = Vss
	
//bit1-0: ADPREF= 0 with Vref+ = Vdd
	
//Resulting into:
	
//ADCON1= 0xD0

	
// Name: Set register ADCON1 (V0) for all ADC's, Type: C Code:
	
adcon10xD0;

	
// Name: Set ports A0, A1 and B7 (ADC's) as analog input ports , Type: C Code:
	
trisa=trisa 0x03;  // set ports A0 and A1 as input
	
trisb=trisb 0x80;  // set B7 as input
	
ansela 0x03;       // set ports A0 and A1 as analog ports
	
anselb 0x80;       // set B7 as analog input

	
// Name: Reset temp counter, Type: Calculation:
	
// Name: Reset temp counter, Type:  Temp = 0
	
// Name: Reset temp counter, Type:  LED_Number = 4 // green
	
FCV_TEMP 0;
	
FCV_LED_NUMBER 4;

	
// Name: Until Vt >= minimum allowed voltage, Type: Loop: While ADC_reading >= V0_min
	
while (!(
FCV_ADC_READING >= FCV_V0_MIN))
	
{

	
	
// Name: Not the first time, Type: Decision: Temp > 0?
	
	
if (
FCV_TEMP 0)
	
	
{

	
	
	
// Name: Flicker green LED  on/off, Type: Calculation:
	
	
	
// Name: Flicker green LED  on/off, Type:  LED_Number = 4 - LED_Number
	
	
	
FCV_LED_NUMBER FCV_LED_NUMBER;

	
	
	
// Name: Show green LED, Type: Call Macro: TriState_Output_Ports_A(LED_Number)
	
	
	
FCM_TriState_Output_Ports_A(FCV_LED_NUMBER);

	
	
	
// Name: Vertraging, Type: Delay: 400 ms
	
	
	
FCI_DELAYINT_MS(400);

	
	
// } else {

	
	
}

	
	
// Name: second loop, Type: Decision: Temp = 1?
	
	
if (
FCV_TEMP == 1)
	
	
{

	
	
	
//Comment:
	
	
	
//Condition will be met only once
	
	
	
//to prevent LCD flickering

	
	
	
// Name: Clear LCD, Type: Call Component Macro: lcd_eb005::Clear()
	
	
	
FCD_0ad31_lcd_eb005__Clear();

	
	
	
// Name: show text, Type: Call Component Macro: lcd_eb005::PrintString("Waiting for")
	
	
	
FCD_0ad31_lcd_eb005__PrintString("Waiting for"12);

	
	
	
// Name: 2nd line, Type: Call Component Macro: lcd_eb005::Cursor(0, 1)
	
	
	
FCD_0ad31_lcd_eb005__Cursor(01);

	
	
	
// Name: show text, Type: Call Component Macro: lcd_eb005::PrintString("Voltage >= ")
	
	
	
FCD_0ad31_lcd_eb005__PrintString("Voltage >= "12);

	
	
	
// Name: Floating to string, Type: Call Macro: FloatTo4Char(FV0_min)
	
	
	
FCM_FloatTo4Char(FCV_FV0_MIN);

	
	
	
// Name: show text, Type: Call Component Macro: lcd_eb005::PrintString(StrTemp)
	
	
	
FCD_0ad31_lcd_eb005__PrintString(FCV_STRTEMPFCVsz_STRTEMP);

	
	
	
// Name: show text, Type: Call Component Macro: lcd_eb005::PrintString("V")
	
	
	
FCD_0ad31_lcd_eb005__PrintString("V"2);

	
	
// } else {

	
	
}

	
	
// Name: Read ACD AN1 (V0), Type: Call Macro: ADC_AN1()
	
	
FCM_ADC_AN1();

	
	
// Name: Voltage out of range (within 0.5%)?, Type: Decision: ADC_reading > 1019?
	
	
if (
FCV_ADC_READING 1019)
	
	
{

	
	
	
// Name: Change maximum voltage into string, Type: Calculation:
	
	
	
// Name: Change maximum voltage into string, Type:  Temp = 5 * Voltage_Part
	
	
	
// Name: Change maximum voltage into string, Type:  Temp_Float = int2float (temp)
	
	
	
FCV_TEMP FCV_VOLTAGE_PART;
	
	
	
FCV_TEMP_FLOAT flt_fromi(FCV_TEMP);

	
	
	
// Name: Output string, Type: Call Macro: FloatTo4Char(Temp_Float)
	
	
	
FCM_FloatTo4Char(FCV_TEMP_FLOAT);

	
	
	
// Name: High voltage error#, Type: Calculation:
	
	
	
// Name: High voltage error#, Type:  ErrorNumber = 2
	
	
	
FCV_ERRORNUMBER 2;

	
	
	
// Name: DEAD END , Type: Call Macro: Dead_end()
	
	
	
FCM_Dead_end();

	
	
// } else {

	
	
}

	
	
// Name: Increase temp counter, Type: Calculation:
	
	
// Name: Increase temp counter, Type:  Temp = Temp + 1
	
	
FCV_TEMP FCV_TEMP 1;

	
	
// Name: Prevent overflow, Type: Decision: Temp = 255?
	
	
if (
FCV_TEMP == 255)
	
	
{

	
	
	
//Comment:
	
	
	
//Temp=1 is reserved for the LCD output only

	
	
	
// Name: Reset to 1, Type: Calculation:
	
	
	
// Name: Reset to 1, Type:  Temp = 2
	
	
	
FCV_TEMP 2;

	
	
// } else {

	
	
}


	
}

	
//Comment:
	
//If V was less then Vo_min for a while, 
	
//it is possible that at certain moment
	
//V becomes larger compared to V0_min. 
	
//In that case V can change a little bit (unstable)
	
//due to the fact that the contacts has not been set.
	
//Therefor we test for stable input voltages.

	
// Name: waited for input?, Type: Decision: Temp > 1?
	
if (
FCV_TEMP 1)
	
{

	
	
//Comment:
	
	
//Assumed is that after 1 seconds the input voltage is stable.

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

	
// } else {

	
}

	
// Name: (Re)start Timer0 at 61 Hz, Type: Interrupt: Enable TMR0
	
cr_bit(OPTION_REG,T0CS);
	
st_bit(OPTION_REG,T0SE);
	
OPTION_REG = (OPTION_REG 0xF0) | 0x07;
	
st_bit(INTCON,GIE);
	
st_bit(INTCONTMR0IE);

	
// Name: set previous LED, Type: Call Macro: TriState_Output_Ports_A(LED_Number_Previous)
	
FCM_TriState_Output_Ports_A(FCV_LED_NUMBER_PREVIOUS);

}

/*=----------------------------------------------------------------------=*\
   Use :
\*=----------------------------------------------------------------------=*/
void FCM_Timer0_Interrupt()
{

	
//Comment:
	
//61 Hz timer, used as count down counter

	
// Name: counter=0, Type: Decision: Timer0_Counter = 0?
	
if (
FCV_TIMER0_COUNTER == 0)
	
{

	
	
// Name: Reset counter en decrease seconds, Type: Calculation:
	
	
// Name: Reset counter en decrease seconds, Type:  Timer0_Counter = 61 // 61 Hz timer0
	
	
// Name: Reset counter en decrease seconds, Type:  Seconds = Seconds - 1
	
	
// Name: Reset counter en decrease seconds, Type:  Change_seconds = 1
	
	
FCV_TIMER0_COUNTER 61;
	
	
FCV_SECONDS FCV_SECONDS 1;
	
	
FCV_CHANGE_SECONDS 1;

	
} else {

	
	
// Name: decrease counter, Type: Calculation:
	
	
// Name: decrease counter, Type:  Timer0_Counter = Timer0_Counter - 1
	
	
FCV_TIMER0_COUNTER FCV_TIMER0_COUNTER 1;

	
}

}

/*=----------------------------------------------------------------------=*\
   Use :
\*=----------------------------------------------------------------------=*/
void FCM_Dead_end()
{

	
//Comment:
	
//DEAD END 
	
//With errornumber 1 or 2 a real dead end.
	
//Errornumber=3 only a warning
	
//Remark: Low voltage/current will be checked in Test_Voltage_V0  and not in dead_end.
	
//Error#=0 default value.

	
// Name: Reset gate MOSFET, Type: Output: 0 -> B3
	
SET_PORT_PIN(B,3,(0));

	
//Comment:
	
//For safety 2 times reset of the gate

	
// Name: Reset gate MOSFET, Type: Output: 0 -> B3
	
SET_PORT_PIN(B,3,(0));

	
//Comment:
	
//Disabling comparator on A2 (NTC) has been removed 
	
//Not used anymore

	
// Name: Stop Timer0 Interrupts, Type: Interrupt: Disable TMR0
	
cr_bit(INTCONTMR0IE);

	
//Comment:
	
//Start LCD has been added here, incase there is directly
	
//at the startup an comparator interrupt, before passing
	
//the first LCD START in the Init macro.

	
// Name: Start LCD, Type: Call Component Macro: lcd_eb005::Start()
	
FCD_0ad31_lcd_eb005__Start();

	
// Name: Vertraging, Type: Delay: 100 ms
	
FCI_DELAYBYTE_MS(100);

	
// Name: Clear LCD, Type: Call Component Macro: lcd_eb005::Clear()
	
FCD_0ad31_lcd_eb005__Clear();

	
// Name: Special cases, Type: Switch: ErrorNumber?
	
switch (
FCV_ERRORNUMBER)
	
{
	
	
case 
1:
	
	
{
	
	
	
//Comment:
	
	
	
//High current dead end

	
	
	
// Name: Show text, Type: Call Component Macro: lcd_eb005::PrintString("Current > 250")
	
	
	
FCD_0ad31_lcd_eb005__PrintString("Current > 250"14);

	
	
	
// Name: Set paramters, Type: Calculation:
	
	
	
// Name: Set paramters, Type:  LED_Number = 2 // red
	
	
	
// Name: Set paramters, Type:  temp_Z = 100 // msec  fast flickering
	
	
	
FCV_LED_NUMBER 2;
	
	
	
FCV_TEMP_Z 100;

	
	
	
break;
	
	
}
	
	
case 
2:
	
	
{
	
	
	
//Comment:
	
	
	
//High Voltage dead end

	
	
	
// Name: Show text, Type: Call Component Macro: lcd_eb005::PrintString("Voltage > ")
	
	
	
FCD_0ad31_lcd_eb005__PrintString("Voltage > "11);

	
	
	
// Name: Show maximum voltage of the range, Type: Call Component Macro: lcd_eb005::PrintString(StrTemp)
	
	
	
FCD_0ad31_lcd_eb005__PrintString(FCV_STRTEMPFCVsz_STRTEMP);

	
	
	
// Name: Set paramters, Type: Calculation:
	
	
	
// Name: Set paramters, Type:  LED_Number = 3 // orange
	
	
	
// Name: Set paramters, Type:  temp_Z = 100 // msec  fast flickering
	
	
	
FCV_LED_NUMBER 3;
	
	
	
FCV_TEMP_Z 100;

	
	
	
break;
	
	
}
	
	
case 
3:
	
	
{
	
	
	
//Comment:
	
	
	
//Possible open circuit

	
	
	
// Name: Show text, Type: Call Component Macro: lcd_eb005::PrintString("Probably open")
	
	
	
FCD_0ad31_lcd_eb005__PrintString("Probably open"14);

	
	
	
// Name: 2nd line, Type: Call Component Macro: lcd_eb005::Cursor(0, 1)
	
	
	
FCD_0ad31_lcd_eb005__Cursor(01);

	
	
	
// Name: Show text, Type: Call Component Macro: lcd_eb005::PrintString("circuit")
	
	
	
FCD_0ad31_lcd_eb005__PrintString("circuit"8);

	
	
	
// Name: Set paramters, Type: Calculation:
	
	
	
// Name: Set paramters, Type:  LED_Number = 4 // green
	
	
	
// Name: Set paramters, Type:  // flickering rate will be 1 seconds in the main macro
	
	
	
FCV_LED_NUMBER 4;

	
	
	
break;
	
	
}
	
	
// default:

	
}

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

	
// Name: Error# 1, 2, Type: Decision: (ErrorNumber = 1) OR (ErrorNumber = 2)?
	
if ((
FCV_ERRORNUMBER == 1) | (FCV_ERRORNUMBER == 2))
	
{

	
	
// Name: 2nd line, Type: Call Component Macro: lcd_eb005::Cursor(0, 1)
	
	
FCD_0ad31_lcd_eb005__Cursor(01);

	
	
// Name: show text, Type: Call Component Macro: lcd_eb005::PrintString("------RESTART-----")
	
	
FCD_0ad31_lcd_eb005__PrintString("------RESTART-----"19);

	
} else {

	
	
//Comment:
	
	
//Skip DEAD END
	
	
//Warning only

	
}

	
// Name: Endless loop for error# 1 and 2, Type: Loop: While (ErrorNumber = 0) OR (ErrorNumber > 2)
	
while (
1)
	
{

	
	
//Comment:
	
	
//LED#:
	
	
//0= all off
	
	
//1= blue
	
	
//2= red
	
	
//3= orange
	
	
//4= green

	
	
// Name: Show LED, Type: Call Macro: TriState_Output_Ports_A(LED_Number)
	
	
FCM_TriState_Output_Ports_A(FCV_LED_NUMBER);

	
	
// Name: Vertraging, Type: Delay: Temp_Z ms
	
	
FCI_DELAYINT_MS(FCV_TEMP_Z);

	
	
// Name: LEDs off, Type: Call Macro: TriState_Output_Ports_A(0)
	
	
FCM_TriState_Output_Ports_A(0);

	
	
// Name: Vertraging, Type: Delay: Temp_Z ms
	
	
FCI_DELAYINT_MS(FCV_TEMP_Z);


	
	
if (((
FCV_ERRORNUMBER == 0) | (FCV_ERRORNUMBER 2)) != 0) break;
	
}

	
// Name: Vertraging, Type: Delay: 300 ms
	
FCI_DELAYINT_MS(300);

	
// Name: Enable Timer0 on 61 Hz, Type: Interrupt: Enable TMR0
	
cr_bit(OPTION_REG,T0CS);
	
st_bit(OPTION_REG,T0SE);
	
OPTION_REG = (OPTION_REG 0xF0) | 0x07;
	
st_bit(INTCON,GIE);
	
st_bit(INTCONTMR0IE);

	
// Name: Reset error# to default value, Type: Calculation:
	
// Name: Reset error# to default value, Type:  ErrorNumber = 0
	
FCV_ERRORNUMBER 0;

}

/*=----------------------------------------------------------------------=*\
   Use :Parameters for macro TriState_Input_ports_B:
       :  B_Port_Number : MX_UINT8
       :
       :Returns : MX_UINT8
\*=----------------------------------------------------------------------=*/
MX_UINT8 FCM_TriState_Input_ports_B(MX_UINT8 FCL_B_PORT_NUMBER)
{
	
//Local variable definitions
	
MX_UINT8 FCL_IN_LOW;
	
MX_UINT8 FCL_IN_HIGH;
	
MX_UINT8 FCR_RETVAL;


	
//Comment:
	
//Read the status of portB i with i=0...7.

	
//Comment:
	
//WARNING!!!!!!
	
//Requirements for the port is equal for output-ports.
	
//That means there should always an applicale resistance between the port
	
//and Vss or Vdd. (recommended 10k).
	
//This input may NEVER be used on B3

	
// Name: B3 not allowed, Type: Decision: .B_Port_Number <> 3?
	
if (
FCL_B_PORT_NUMBER != 3)
	
{

	
	
//Comment:
	
	
//Get and Set:
	
	
//   Type: M= Mask methode
	
	
//   Port: B
	
	
//   Mask:  (1<<Port#)
	
	
//   Shift: Port#
	
	
//Set only:
	
	
//   Source: 0x00 (low) or 0xFF (high)

	
	
// Name: Set Output-Port Bi to low (0), Type: C Code:
	
	
FCP_SET(M,B,(1<<FCL_B_PORT_NUMBER),FCL_B_PORT_NUMBER,(0x00));

	
	
//Comment:
	
	
//Small delay is necessary to 'power' the output
	
	
//If to small the next ready of the input can be 
	
	
//found to be not correct

	
	
// Name: Vertraging, Type: Delay: 10 us
	
	
FCI_DELAYBYTE_US(10);

	
	
// Name: Get status Port Bi, Type: C Code:
	
	
FCL_IN_LOW=FCP_GET(M,B,(1<<FCL_B_PORT_NUMBER),FCL_B_PORT_NUMBER);

	
	
// Name: Set Output-Port Bi to high (1), Type: C Code:
	
	
FCP_SET(M,B,(1<<FCL_B_PORT_NUMBER),FCL_B_PORT_NUMBER,(0xFF));

	
	
// Name: Vertraging, Type: Delay: 10 us
	
	
FCI_DELAYBYTE_US(10);

	
	
// Name: Get status Port Bi, Type: C Code:
	
	
FCL_IN_HIGH=FCP_GET(M,B,(1<<FCL_B_PORT_NUMBER),FCL_B_PORT_NUMBER);

	
	
//Comment:
	
	
//Return 0=low, 1=open or 2=high for the 
	
	
//B-port B_Port_Number

	
	
// Name: Calculate status Bi (0=low,1=open, 2= high), Type: Calculation:
	
	
// Name: Calculate status Bi (0=low,1=open, 2= high), Type:  .Return = .IN_low + .IN_high
	
	
FCR_RETVAL FCL_IN_LOW FCL_IN_HIGH;

	
} else {

	
	
// Name: Software error# , Type: Calculation:
	
	
// Name: Software error# , Type:  ErrorNumber = 0
	
	
FCV_ERRORNUMBER 0;

	
	
// Name: Stop input on B3, Type: Call Macro: Dead_end()
	
	
FCM_Dead_end();

	
}

	
return (
FCR_RETVAL);

}

/*=----------------------------------------------------------------------=*\
   Use :
\*=----------------------------------------------------------------------=*/
void FCM_Init()
{

	
//Comment:
	
//B3 is output to MOSFET gate which activates the SHUNT.
	
//DO NOT USE this port for other reasons!

	
//Comment:
	
//Tristate Input on B6 is not used. 
	
//Open for future extensions.
	
//But for safety reasons connect 10K in serie to B6

	
//Comment:
	
//STEPS:
	
//1. Reset B3 
	
//5. Prepare comparator on A2. This checks high temperature of the shunt
	
//   and start NTC temperature control
	
//2. Set default values
	
//3. Start Timer0 at 61 Hz, as countdown counter between pulses
	
//4. Start blicking LEDs showing progress of the program
	
//6. Show LCD with start text
	
//7. Read status input B4 (shunt resistance) and B5 (Division Voltages)
	
//   and in case B5 low: A5 input low will change 
	
//   the shunt activation each 10 seconds
	
//8. Set ADC start settings

	
//Comment:
	
//1. Reset B3 

	
// Name: Prevent Shunt on. Set B3  low!, Type: Output: 0 -> B3
	
SET_PORT_PIN(B,3,(0));

	
//Comment:
	
//5.Comparator on A2 has been removed to detect the NTC temperature
	
//Error_number was 9 (not used anymore)

	
// Name: Prevent Shunt on. Set B3  low! (for safety a second time), Type: Output: 0 -> B3
	
SET_PORT_PIN(B,3,(0));

	
//Comment:
	
//2. Set default values

	
// Name: Set default values, Type: Calculation:
	
// Name: Set default values, Type:  FVshunt_bottomside = 0.0
	
// Name: Set default values, Type:  FVshunt_topside = 0.0
	
// Name: Set default values, Type:  Tdelay_usec = 10
	
// Name: Set default values, Type:  // Tc = 1.4 usec with 10k external load
	
// Name: Set default values, Type:  // Tc = 8.2 usec with 100k extrenal load
	
// Name: Set default values, Type:  Taquisition_usec = 11 // = 2 + Tc + 0.05 (T-25 oC) usec
	
// Name: Set default values, Type:  ErrorNumber = 0 // default value
	
// Name: Set default values, Type:  Seconds = 30 // default start time of the count down counter
	
// Name: Set default values, Type:  Timer0_counter = 1 // must >0
	
// Name: Set default values, Type:  Wait_seconds = 30 // activate shunt each 30 seconds
	
// Name: Set default values, Type:  Rshunt_mOhm = 50 // 50 mOhm shunt
	
// Name: Set default values, Type:  Current_max = 250 // Amp. Max pulse current 280A for diode SR1203/4 and 250A for MOSFET IRFB7828
	
// Name: Set default values, Type:  //Remark: Set max. current also in Dead_end macro
	
// Name: Set default values, Type:  FV0_min = 0.2 // volt. Lowest voltage allowed
	
FCV_FVSHUNT_BOTTOMSIDE 0.0;
	
FCV_FVSHUNT_TOPSIDE 0.0;
	
FCV_TDELAY_USEC 10;
	
FCV_TAQUISITION_USEC 11;
	
FCV_ERRORNUMBER 0;
	
FCV_SECONDS 30;
	
FCV_TIMER0_COUNTER 1;
	
FCV_WAIT_SECONDS 30;
	
FCV_RSHUNT_MOHM 50;
	
FCV_CURRENT_MAX 250;
	
FCV_FV0_MIN 0.2;

	
// Name: Start LCD, Type: Call Component Macro: lcd_eb005::Start()
	
FCD_0ad31_lcd_eb005__Start();

	
//Comment:
	
//During setup this will shows the scrollings LEDs each second

	
//Comment:
	
//3. Start Timer0 at 61 Hz, as countdown counter between pulses

	
// Name: Interrupt, Type: Interrupt: Enable TMR0
	
cr_bit(OPTION_REG,T0CS);
	
st_bit(OPTION_REG,T0SE);
	
OPTION_REG = (OPTION_REG 0xF0) | 0x07;
	
st_bit(INTCON,GIE);
	
st_bit(INTCONTMR0IE);

	
//Comment:
	
//4. Start red LEDs showing progress of the program

	
// Name: Show red LED, Type: Call Macro: TriState_Output_Ports_A(2)
	
FCM_TriState_Output_Ports_A(2);

	
//Comment:
	
//6. Show LCD with start text

	
// Name: Clear LCD, Type: Call Component Macro: lcd_eb005::Clear()
	
FCD_0ad31_lcd_eb005__Clear();

	
// Name: print text, Type: Call Component Macro: lcd_eb005::PrintString(" E L E K T O R ")
	
FCD_0ad31_lcd_eb005__PrintString(" E L E K T O R "16);

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

	
// Name: Clear LCD, Type: Call Component Macro: lcd_eb005::Clear()
	
FCD_0ad31_lcd_eb005__Clear();

	
// Name: print text, Type: Call Component Macro: lcd_eb005::PrintString("Internal")
	
FCD_0ad31_lcd_eb005__PrintString("Internal"9);

	
// Name: 2nd line, Type: Call Component Macro: lcd_eb005::Cursor(0, 1)
	
FCD_0ad31_lcd_eb005__Cursor(01);

	
//Comment:
	
//Version #

	
// Name: print text, Type: Call Component Macro: lcd_eb005::PrintString("resistance V2")
	
FCD_0ad31_lcd_eb005__PrintString("resistance V2"14);

	
// Name: Vertraging, Type: Delay: 2 s
	
FCI_DELAYBYTE_S(2);

	
// Name: Show orange LED, Type: Call Macro: TriState_Output_Ports_A(3)
	
FCM_TriState_Output_Ports_A(3);

	
//Comment:
	
//Tristate input:
	
//-Set output 0, 
	
//-read input status, 
	
//-set output 1, 
	
//-read input status
	
//The sum status will be:
	
//0 is B3=0            Rshunt=50 mOhm
	
//1 if B3 undefined    Rshunt= 100 mOhm
	
//2 if B3=1            Rshunt= 220 mOhm

	
// Name: Clear LCD, Type: Call Component Macro: lcd_eb005::Clear()
	
FCD_0ad31_lcd_eb005__Clear();

	
//Comment:
	
//7. Read status input B4 (shunt resistance), B5 (Voltage ratios) and A5 (Offtime)

	
//Comment:
	
//Input for different shunts has been removed 
	
//and replaced by default value of 50 mOhm

	
// Name: Calculate Rshunt in Ohm's, Type: Calculation:
	
// Name: Calculate Rshunt in Ohm's, Type:  Rshunt = int2float (Rshunt_mOhm)
	
// Name: Calculate Rshunt in Ohm's, Type:  Rshunt = fdiv (Rshunt,1000.0)
	
FCV_RSHUNT flt_fromi(FCV_RSHUNT_MOHM);
	
FCV_RSHUNT flt_div(FCV_RSHUNT1000.0);

	
// Name: Get tri-state status B5 (Conn5B) Vratio, Type: Call Macro: Temp=TriState_Input_ports_B(5)
	
FCV_TEMP FCM_TriState_Input_ports_B(5);

	
// Name: B5 low (Conn5B) Ratio valtage Vin/Vout, Type: Switch: Temp?
	
switch (
FCV_TEMP)
	
{
	
	
case 
1:
	
	
{
	
	
	
//Comment:
	
	
	
//B5 open

	
	
	
// Name: Show text, Type: Call Component Macro: lcd_eb005::PrintString("0.2 / 5.5-30V")
	
	
	
FCD_0ad31_lcd_eb005__PrintString("0.2 / 5.5-30V"14);

	
	
	
// Name: Vadc= V/6, Type: Calculation:
	
	
	
// Name: Vadc= V/6, Type:  Voltage_Part = 6
	
	
	
FCV_VOLTAGE_PART 6;

	
	
	
//Comment:
	
	
	
//Green, Orange and Red LED's:
	
	
	
//24V Lead accumulators (6 cells) have in good conditions
	
	
	
//a voltage of 25-25.8 Volt
	
	
	
//low condition between 23.8-25 Volt
	
	
	
//bad condition below 23.8 Volt
	
	
	
//Vhigh= 25V 
	
	
	
//Vlow= 23.8 V 
	
	
	
//24V accumulators will never get a voltage > 30 Volt
	
	
	
//Vmax = 30V 

	
	
	
// Name: Set values accumulator , Type: Calculation:
	
	
	
// Name: Set values accumulator , Type:  FVshunt_bottomside = 23.8 // temp variable for Vlow
	
	
	
// Name: Set values accumulator , Type:  FVshunt_topside = 25.0 // temp variable for Vhigh
	
	
	
FCV_FVSHUNT_BOTTOMSIDE 23.8;
	
	
	
FCV_FVSHUNT_TOPSIDE 25.0;

	
	
	
break;
	
	
}
	
	
case 
2:
	
	
{
	
	
	
//Comment:
	
	
	
//B5 high

	
	
	
// Name: Show text, Type: Call Component Macro: lcd_eb005::PrintString(" 0.2-10V")
	
	
	
FCD_0ad31_lcd_eb005__PrintString(" 0.2-10V"9);

	
	
	
// Name: Vadc= V/2, Type: Calculation:
	
	
	
// Name: Vadc= V/2, Type:  Voltage_Part = 2
	
	
	
FCV_VOLTAGE_PART 2;

	
	
	
//Comment:
	
	
	
//Green, Orange and Red LED's:
	
	
	
//Lead accumulators (3 cells) have in good conditions
	
	
	
//a voltage of 6.25-6.45 Volt
	
	
	
//low condition between 5.95-6.25 Volt
	
	
	
//bad condition below <5.95 Volt
	
	
	
//Vhigh= 6.25V 
	
	
	
//Vlow= 5.95V 
	
	
	
//6V accumulators will never get a voltage > 7.5 Volt
	
	
	
//Vmax = 7.5V 

	
	
	
// Name: Set values accumulator , Type: Calculation:
	
	
	
// Name: Set values accumulator , Type:  FVshunt_bottomside = 5.95 // temp variable for Vlow
	
	
	
// Name: Set values accumulator , Type:  FVshunt_topside = 6.25 // temp variable for Vhigh
	
	
	
FCV_FVSHUNT_BOTTOMSIDE 5.95;
	
	
	
FCV_FVSHUNT_TOPSIDE 6.25;

	
	
	
break;
	
	
}
	
	
default:
	
	
{
	
	
	
//Comment:
	
	
	
//B5 low

	
	
	
// Name: Show text, Type: Call Component Macro: lcd_eb005::PrintString("0.2 / 5.5-20V")
	
	
	
FCD_0ad31_lcd_eb005__PrintString("0.2 / 5.5-20V"14);

	
	
	
// Name: Vadc= V/4, Type: Calculation:
	
	
	
// Name: Vadc= V/4, Type:  Voltage_Part = 4
	
	
	
FCV_VOLTAGE_PART 4;

	
	
	
//Comment:
	
	
	
//Green, Orange and Red LED's:
	
	
	
//Lead accumulators (12 cells) have in good conditions
	
	
	
//a voltage of 12.5-12.9 Volt
	
	
	
//low condition between 11.9-12.5 Volt
	
	
	
//bad condition below 11.9 Volt
	
	
	
//Vhigh= 12.5V 
	
	
	
//Vlow= 11.9V 
	
	
	
//12V accumulators will never get a voltage > 15 Volt
	
	
	
//Vmax = 15V 

	
	
	
// Name: Set values accumulator , Type: Calculation:
	
	
	
// Name: Set values accumulator , Type:  FVshunt_bottomside = 11.9 // temp variable for Vlow
	
	
	
// Name: Set values accumulator , Type:  FVshunt_topside = 12.5 // temp variable for Vhigh
	
	
	
FCV_FVSHUNT_BOTTOMSIDE 11.9;
	
	
	
FCV_FVSHUNT_TOPSIDE 12.5;

	
	
}
	
}

	
//Comment:
	
//Offtime on A5
	
//High/Open: 30 sec
	
//Low: 10 sec.

	
// Name: Get status A5 (Conn5C) Offtime, Type: Input: A5 -> StatusA5
	
FCV_STATUSA5 GET_PORT_PIN(A,5);

	
// Name: Input A5 high (Conn5C)?, Type: Decision: StatusA5 = 1?
	
if (
FCV_STATUSA5 == 1)
	
{

	
	
//Comment:
	
	
//Default 30 seconds offtime

	
} else {

	
	
// Name: (Re)set shunt activation frequency, Type: Calculation:
	
	
// Name: (Re)set shunt activation frequency, Type:  Wait_seconds = 10 // activate shunt each 10 seconds
	
	
FCV_WAIT_SECONDS 10;

	
}

	
// Name: Change Voltage FV0_min into V0_min ADC units, Type: Call Macro: V0_min=Voltage_to_ADC(FV0_min)
	
FCV_V0_MIN FCM_Voltage_to_ADC(FCV_FV0_MIN);

	
// Name: Change Voltage FVshunt_bottomside into Vacc_low with ADC units, Type: Call Macro: Vacc_low=Voltage_to_ADC(FVshunt_bottomside)
	
FCV_VACC_LOW FCM_Voltage_to_ADC(FCV_FVSHUNT_BOTTOMSIDE);

	
// Name: Change Voltage FVshunt_topside into Vacc_high with ADC units, Type: Call Macro: Vacc_high=Voltage_to_ADC(FVshunt_topside)
	
FCV_VACC_HIGH FCM_Voltage_to_ADC(FCV_FVSHUNT_TOPSIDE);

	
// Name: 2nd line, Type: Call Component Macro: lcd_eb005::Cursor(0, 1)
	
FCD_0ad31_lcd_eb005__Cursor(01);

	
// Name: Show text, Type: Call Component Macro: lcd_eb005::PrintString("Rshunt = ")
	
FCD_0ad31_lcd_eb005__PrintString("Rshunt = "10);

	
// Name: Show Rshunt, Type: Call Component Macro: lcd_eb005::PrintNumber(Rshunt_mOhm)
	
FCD_0ad31_lcd_eb005__PrintNumber(FCV_RSHUNT_MOHM);

	
// Name: Show text, Type: Call Component Macro: lcd_eb005::PrintString(" m")
	
FCD_0ad31_lcd_eb005__PrintString(" m"3);

	
// Name: Print greek omega for Ohm, Type: Call Component Macro: lcd_eb005::PrintAscii(0xF4)
	
FCD_0ad31_lcd_eb005__PrintAscii(0xF4);

	
// Name: Vertraging, Type: Delay: 2 s
	
FCI_DELAYBYTE_S(2);

	
// Name: Show green LED, Type: Call Macro: TriState_Output_Ports_A(4)
	
FCM_TriState_Output_Ports_A(4);

	
// Name: Clear LCD, Type: Call Component Macro: lcd_eb005::Clear()
	
FCD_0ad31_lcd_eb005__Clear();

	
// Name: Show text, Type: Call Component Macro: lcd_eb005::PrintString("Offtime ")
	
FCD_0ad31_lcd_eb005__PrintString("Offtime "9);

	
// Name: Show number, Type: Call Component Macro: lcd_eb005::PrintNumber(Wait_seconds)
	
FCD_0ad31_lcd_eb005__PrintNumber(FCV_WAIT_SECONDS);

	
// Name: Show text, Type: Call Component Macro: lcd_eb005::PrintString(" sec")
	
FCD_0ad31_lcd_eb005__PrintString(" sec"5);

	
// Name: Vertraging, Type: Delay: 2 s
	
FCI_DELAYBYTE_S(2);

	
// Name: All LEDs off, Type: Call Macro: TriState_Output_Ports_A(0)
	
FCM_TriState_Output_Ports_A(0);

	
//Comment:
	
//8. Set ADC start settings

	
//Comment:
	
//ADC  (AN0....AN11)
	
//Register ADCON1 for PIC16F1847:
	
//bit7:   ADFM=1 with the 2 bits of ADRESH right justified
	
//bit6-4: ADCS =5 for Fosc/16 conversion clock
	
//bit3:   x
	
//bit2:   ADNREF= 0 with Vref- = Vss
	
//bit1-0: ADPREF= 0 with Vref+ = Vdd
	
//Resulting into:
	
//ADCON1= 0xD0

	
// Name: Set register ADCON1 for all ADC's (V0 and Vt), Type: C Code:
	
adcon10xD0;

	
// Name: Set ports A0, A1 and B7 as analog input ports, Type: C Code:
	
trisa=trisa 0x03;  // set ports A0 and A1 as input
	
trisb=trisb 0x80;  // set B7 as input
	
ansela ansela|0x03;       // set ports A0 and A1 as analog ports
	
anselb anselb|0x80;       // set B7 as analog input

}

/*=----------------------------------------------------------------------=*\
   Use :Parameters for macro Voltage_to_ADC:
       :  FV_in : MX_FLOAT
       :
       :Returns : MX_UINT16
\*=----------------------------------------------------------------------=*/
MX_UINT16 FCM_Voltage_to_ADC(MX_FLOAT FCL_FV_IN)
{
	
//Local variable definitions
	
MX_FLOAT FCL_TEMP;
	
MX_UINT16 FCR_RETVAL;


	
// Name: Calculate FV_in in ADC units (max 1024), Type: Calculation:
	
// Name: Calculate FV_in in ADC units (max 1024), Type:  .Temp = fmul (.FV_in,1024.0)
	
// Name: Calculate FV_in in ADC units (max 1024), Type:  .Return = float2int (.Temp)
	
// Name: Calculate FV_in in ADC units (max 1024), Type:  .Return = .Return / (5 * Voltage_Part)
	
FCL_TEMP flt_mul(FCL_FV_IN1024.0);
	
FCR_RETVAL flt_toi(FCL_TEMP);
	
FCR_RETVAL FCR_RETVAL / (FCV_VOLTAGE_PART);

	
return (
FCR_RETVAL);

}

/*=----------------------------------------------------------------------=*\
   Use :Parameters for macro ADC_to_Voltage:
       :  High_Byte : MX_UINT8
       :  Low_Byte : MX_UINT8
       :
       :Returns : MX_FLOAT
\*=----------------------------------------------------------------------=*/
MX_FLOAT FCM_ADC_to_Voltage(MX_UINT8 FCL_HIGH_BYTEMX_UINT8 FCL_LOW_BYTE)
{
	
//Local variable definitions
	
MX_FLOAT FCR_RETVAL;


	
//Comment:
	
//Transforms ADC reading into real voltages
	
//Register ADCON1 for PIC16F1847:
	
//bit7:   ADFM=1 with the 2 bits of ADRESH right justified

	
// Name: Scale V without shunt, Type: Calculation:
	
// Name: Scale V without shunt, Type:  ADC_reading = .High_Byte & 0x03 // only last 2 bits
	
// Name: Scale V without shunt, Type:  ADC_reading = (ADC_reading << 8)
	
// Name: Scale V without shunt, Type:  ADC_reading = ADC_reading + .Low_Byte
	
// Name: Scale V without shunt, Type:  Temp_Z = ADC_reading * 5 //  5 volt
	
// Name: Scale V without shunt, Type:  Temp_Z = Temp_Z * Voltage_Part // V= Voltage_part* Vadc
	
// Name: Scale V without shunt, Type:  .return = int2float (Temp_Z)
	
// Name: Scale V without shunt, Type:  .return = fdiv (.return,1024.0)
	
FCV_ADC_READING FCL_HIGH_BYTE 0x03;
	
FCV_ADC_READING = (FCV_ADC_READING << 8);
	
FCV_ADC_READING FCV_ADC_READING FCL_LOW_BYTE;
	
FCV_TEMP_Z FCV_ADC_READING 5;
	
FCV_TEMP_Z FCV_TEMP_Z FCV_VOLTAGE_PART;
	
FCR_RETVAL flt_fromi(FCV_TEMP_Z);
	
FCR_RETVAL flt_div(FCR_RETVAL1024.0);

	
return (
FCR_RETVAL);

}

/*=----------------------------------------------------------------------=*\
   Use :Parameters for macro TriState_Output_Ports_A:
       :  LED_num : MX_UINT8
\*=----------------------------------------------------------------------=*/
void FCM_TriState_Output_Ports_A(MX_UINT8 FCL_LED_NUM)
{
	
//Local variable definitions
	
MX_UINT8 FCL_TEMP_INPUT;


	
//Comment:
	
//LED's 1 until 4 with tristate output of ports A6 and A7.
	
//LED1 and 2 port A7 and 
	
//LED3 and 4 port A6.
	
//Low:  Output=0
	
//Open: INPUT
	
//High: Output=1

	
// Name: A6 open  LED3 and LED4 off, Type: Input: A6 -> .Temp_Input
	
FCL_TEMP_INPUT GET_PORT_PIN(A,6);

	
// Name: A7 open LED1 and LED2 off, Type: Input: A7 -> .Temp_Input
	
FCL_TEMP_INPUT GET_PORT_PIN(A,7);

	
// Name: Schakel, Type: Switch: .LED_num?
	
switch (
FCL_LED_NUM)
	
{
	
	
case 
1:
	
	
{
	
	
	
//Comment:
	
	
	
//LED1 on
	
	
	
//white/blue

	
	
	
// Name: A7 low, LED1 on and LED2 off, Type: Output: 0 -> A7
	
	
	
SET_PORT_PIN(A,7,(0));

	
	
	
break;
	
	
}
	
	
case 
2:
	
	
{
	
	
	
//Comment:
	
	
	
//LED2 on
	
	
	
//red

	
	
	
// Name: A7 high, LED1 off and LED2 on, Type: Output: 1 -> A7
	
	
	
SET_PORT_PIN(A,7,(1));

	
	
	
break;
	
	
}
	
	
case 
3:
	
	
{
	
	
	
//Comment:
	
	
	
//LED3 on
	
	
	
//orange

	
	
	
// Name: A6 low, LED3 on and LED4 off, Type: Output: 0 -> A6
	
	
	
SET_PORT_PIN(A,6,(0));

	
	
	
break;
	
	
}
	
	
case 
4:
	
	
{
	
	
	
//Comment:
	
	
	
//LED4 on
	
	
	
//green

	
	
	
// Name: A6 high LED3 off and LED4 on, Type: Output: 1 -> A6
	
	
	
SET_PORT_PIN(A,6,(1));

	
	
	
break;
	
	
}
	
	
default:
	
	
{
	
	
	
//Comment:
	
	
	
//All LED's off

	
	
}
	
}

}

/*=----------------------------------------------------------------------=*\
   Use :Returns : MX_UINT8
\*=----------------------------------------------------------------------=*/
MX_UINT8 FCM_Current_and_Internal_resistance()
{
	
//Local variable definitions
	
MX_UINT8 FCR_RETVAL;


	
//Comment:
	
//-Calculate Ri in case current <>0, else stop
	
//-Test on correct current (< maximum current)
	
//-Test on realistic Ri values

	
// Name: Calculate the shunt current, Type: Calculation:
	
// Name: Calculate the shunt current, Type:  Current = fsub (FVshunt_topside,FVshunt_bottomside)
	
// Name: Calculate the shunt current, Type:  Current = fdiv (Current,Rshunt) // Pay attention: Rshunt should be not equal 0
	
FCV_CURRENT flt_sub(FCV_FVSHUNT_TOPSIDEFCV_FVSHUNT_BOTTOMSIDE);
	
FCV_CURRENT flt_div(FCV_CURRENTFCV_RSHUNT);

	
// Name: Current value as string, Type: Call Macro: FloatTo4Char(Current)
	
FCM_FloatTo4Char(FCV_CURRENT);

	
// Name: No current (below 100 mA or negative)?, Type: Decision: Current < 0.1?
	
if (
flt_lt(FCV_CURRENT0.1))
	
{

	
	
//Comment:
	
	
//A negative current is possible if Vbat- is 
	
	
//not conencted. The capacitors in the shunt
	
	
//circuit can cause a reverse current.

	
	
//Comment:
	
	
//First step: Test connections and shunt resistance
	
	
//Second step: Test diode and MOSFET on correct working

	
	
// Name: Low or negative current error# (no dead end), Type: Calculation:
	
	
// Name: Low or negative current error# (no dead end), Type:  ErrorNumber = 3
	
	
FCV_ERRORNUMBER 3;

	
} else {

	
	
// Name: Current to large?, Type: Decision: Current > Current_max?
	
	
if (
flt_gt(FCV_CURRENTFCV_CURRENT_MAX))
	
	
{

	
	
	
// Name: High current error# (dead end fast flickering), Type: Calculation:
	
	
	
// Name: High current error# (dead end fast flickering), Type:  ErrorNumber = 1
	
	
	
FCV_ERRORNUMBER 1;

	
	
} else {

	
	
	
// Name: Calculate internal resistance Ri , Type: Calculation:
	
	
	
// Name: Calculate internal resistance Ri , Type:  FR_internal = fsub (FV0,FV_terminal)
	
	
	
// Name: Calculate internal resistance Ri , Type:  FR_internal = fdiv (FR_internal,Current) // Current=0 is not allowed
	
	
	
// Name: Calculate internal resistance Ri , Type:  FR_internal = fmul (FR_internal,1000.0) // Ri in mOhm
	
	
	
FCV_FR_INTERNAL flt_sub(FCV_FV0FCV_FV_TERMINAL);
	
	
	
FCV_FR_INTERNAL flt_div(FCV_FR_INTERNALFCV_CURRENT);
	
	
	
FCV_FR_INTERNAL flt_mul(FCV_FR_INTERNAL1000.0);

	
	
	
// Name: Ri value as string, Type: Call Macro: FloatTo4Char(FR_internal)
	
	
	
FCM_FloatTo4Char(FCV_FR_INTERNAL);

	
	
	
// Name: Internal resistance < 0.1 mOhm?, Type: Decision: FR_internal < 0.1?
	
	
	
if (
flt_lt(FCV_FR_INTERNAL0.1))
	
	
	
{

	
	
	
	
// Name: , Type: Decision: FR_internal >= 0?
	
	
	
	
if (
flt_ge(FCV_FR_INTERNAL0))
	
	
	
	
{

	
	
	
	
	
//Comment:
	
	
	
	
	
//For very low values of 0<=Ri<0.1 mOhm, it is expected that 
	
	
	
	
	
//the current I will become larger then Imax and stopt already 
	
	
	
	
	
//at an earlier place in the program.

	
	
	
	
	
// Name: Low resistance error# (no dead end), Type: Calculation:
	
	
	
	
	
// Name: Low resistance error# (no dead end), Type:  ErrorNumber = 3
	
	
	
	
	
FCV_ERRORNUMBER 3;

	
	
	
	
} else {

	
	
	
	
	
//Comment:
	
	
	
	
	
//Negative resistance can be due to a not correct
	
	
	
	
	
//connection. Choosen is here for warning only.

	
	
	
	
	
// Name: Negative resistance error# (no dead end), Type: Calculation:
	
	
	
	
	
// Name: Negative resistance error# (no dead end), Type:  ErrorNumber = 3
	
	
	
	
	
FCV_ERRORNUMBER 3;

	
	
	
	
}

	
	
	
} else {

	
	
	
	
// Name: Internal resistance > = 10 Ohm?, Type: Decision: FR_internal > 9999?
	
	
	
	
if (
flt_gt(FCV_FR_INTERNAL9999))
	
	
	
	
{

	
	
	
	
	
// Name: High resistance error# (no dead end), Type: Calculation:
	
	
	
	
	
// Name: High resistance error# (no dead end), Type:  ErrorNumber = 3
	
	
	
	
	
FCV_ERRORNUMBER 3;

	
	
	
	
// } else {

	
	
	
	
}

	
	
	
}

	
	
}

	
}

	
// Name: Go on if still default errornumber?, Type: Decision: ErrorNumber = 0?
	
if (
FCV_ERRORNUMBER == 0)
	
{

	
	
//Comment:
	
	
//Go on

	
	
// Name: Correct values found, Type: Calculation:
	
	
// Name: Correct values found, Type:  .Return = 1
	
	
FCR_RETVAL 1;

	
} else {

	
	
//Comment:
	
	
//Error# changed then goto DEAD END

	
	
// Name: High current in Shunt circuit, Type: Call Macro: Dead_end()
	
	
FCM_Dead_end();

	
	
// Name: No correct values found, Type: Calculation:
	
	
// Name: No correct values found, Type:  .Return = 0
	
	
FCR_RETVAL 0;

	
}

	
return (
FCR_RETVAL);

}

/*=----------------------------------------------------------------------=*\
   Use :
\*=----------------------------------------------------------------------=*/
void FCM_ADC_AN1()
{

	
//Comment:
	
//ADC reading for AN1 (port A1) of PIC16F1847

	
// Name: Set channel AN1 and enable ADC, Type: C Code:
	
adcon00x05;  // reset adcon0 and select channel AN1 (for ANx adcon0=x<<2)
	
               
// enable ADC (bit0 of adcon0)

	
// Name: Wait ADC acquisition time of 10 usec , Type: Delay: Taquisition_usec us
	
FCI_DELAYBYTE_US(FCV_TAQUISITION_USEC);

	
// Name: Start conversion AN1 and wait until ready, Type: C Code:
	
adcon0 adcon0 0x02;  // start adc conversion. (Set bit1 of adcon0)
	
while(
ts_bit(adcon0,1)); // wait for end conversion, until bit1 has been reset

	
FCV_LB0 adresl;
	
FCV_HB0 adresh;

	
// Name: Get ADC reading, Type: Calculation:
	
// Name: Get ADC reading, Type:  ADC_reading = (HB0 << 8) + LB0
	
FCV_ADC_READING = (FCV_HB0 << 8) + FCV_LB0;

}



/*========================================================================*\
   Use :Main
\*========================================================================*/
void main()
{
ANSELA 0x00;
ANSELB 0x00;

OPTION_REG 0xC0;


	
//Comment:
	
//Activates accumulators (6V, 12, 24V) and determines battery qualities 0-30V
	
//By means of a high current pulse during 100 usec (blue LED1 red) 
	
//which will be reapeated each 30 seconds.
	
//LED 2 (red),3 (orange) and 4 (green) shows the status of an accumulator.
	
//LCD line 1 shows the battery/accumilator voltage without and
	
//during the pulse.
	
//LCD  line 2 shows the shunt current, internal battery / accumulator
	
//resistance and count down seconds offtime.
	
//Elektor Version 2.0
	
//August 11, 2016
	
//Jan H. Lichtenbelt, Nl

	
//Comment:
	
//PAY ATTENTION    PAY ATTENTION
	
//Use B3 as output ONLY to activate the shunt!
	
//E.g. check carefully
	
//-  LCD ports, do NOT use the default port B3
	
//-  Trisate input B3 NOT allowed 
	
//   (Part of the tristate check will 
	
//    use B3 as output, which is NOT allowed)

	
//Comment:
	
//Definition:
	
//Accumalator or battery with a voltage on the terminals Vt and internal resistance Ri.
	
//Without external load V0=Vt. The voltage Vi=V0-Vt is the voltage over the internal resistance Ri.
	
//Vt will be measured with and without external shunt resistance.
	
//Thare are three ranges 0-10V, 7-20V and 7-30V with shunt resistances Rs
	
//of 50 resp 100 and 220 Ohm. 
	
//The voltage at the shunt will be Vh (high side) and Vl (low side), with Vh>Vl.
	
//Remark: Vl>0 due to thread resistance connected to the min-terminal.

	
//Comment:
	
//Setup:
	
//The accumulator voltage will be measured with (Vt) 
	
//and without (V0) load (shunt resistance Rshunt)
	
//The voltages over the shunt are measured with Vh at the high-side and
	
//Vl at the low-side of the shunt. 
	
//The voltages with shunt will be measured during the 100 usec pulse.
	
//The value for the current is: I= (Vh-Vl)/Rshunt. 
	
//Then battery internal resistance Ri can be calculated with Ri= (V0-Vt)/I.
	
//When measured the voltages directly at the accumulator/battery,
	
//the error in the internal resistance Ri will due to the error in the 
	
//real value of the shunt resistance and the contact potentials 
	
//at the accumulator/battery.

	
//Comment:
	
//LEDs:
	
//A7  low: LED1 Shunt activated
	
//A7 high: LED2 red voltage     < 5.95V    < 11.9 Volt   < 23.8 Volt 
	
//A6  low: LED3 orange voltage 5.95-6.25V 11.9-12.5 Volt 23.8-25.0 Volt
	
//A6 high: LED4 green voltage   > 6.25 V    > 12.5 Volt   > 25.0 Volt 
	
//Remark: A6 or A7 as input will deactivate the LEDs
	
//ADCs:
	
//A1: AN1=ADC1 Vt accumulator  (divide by 2, 4 or 6)
	
//A0: AN0=ADC2 Vh Shunt + side (divide by 2, 4 or 6)
	
//B7: AN6=ADC3 Vl Shunt - side (divide by 2, 4 or 6)
	
//Tristate Input (low/open/high):
	
//B4: Shunt 220(high) 100 (open) 50 mOhm (low)
	
//B5: Voltage ratio 1:6 (open), 1:4 (high) or 1:2 (low)
	
//Comparator Input- (with IN+= 2.048Volt):
	
//A2: NTC  
	
//Output:
	
//B3 - MOSFET Gate (Anode gate driver) 
	
//port LCD flatcable  LCD port flatcable
	
//A3   D4   1         D4  A3   1
	
//A4   En   2         D5  B6   3
	
//B6   D5   3         D6  B0   5
	
//B0   D6   5         D7  B1   7
	
//B1   D7   7         R   B2   9
	
//B2   R    9         En  A4   2
	
//                    0V       8
	
//                    5V       6
	
//                    NC       4 and 10
	
//Other inputs:
	
//A5 Off time 30 sec (open) or 10 sec. (closed)

	
//Comment:
	
//Interrupts:
	
//1. Timer0 interrupt with 61 Hz used to count down 30 seconds
	
//2. Comparator on port A2 with Vref= 2.048 Volt
	
//   If NTC > 100-135 oC interrupt to macro DEAD_END
	
//Remark: Flowcode does not has a comparator interrupt. 
	
//Therefor  the program uses C-codes for it.
	
//Macros:
	
//Reamark: Flowcode does have an ADC macro, but it seems that the shortes
	
//pulse will be about 160 usec, while the macro in C-code take only 100 usec.
	
//1. Init to initialise paramters
	
//2. Current_and_ Internal_resistance to calculate I and Ri and to check both on extreme values
	
//3. Test_Voltage_V0. Wait until V0 > V(min) and test V0> 10,20 or 30 Volt
	
//4. Tristate_Input_ports_B, reads the low, open or high state of a B-port, except B3
	
//5. Tristate_Output_Ports_A, activates LED1 until LED4 on A6 and A7
	
//6. ADC_to_Voltage transforms the 10 bit ADC into Voltages
	
//7. Voltage_to_ADC transforms a real into ADC units (0..1023)
	
//8. ADC_AN1 read AN1
	
//9. Dead_end is also an (comparator interrupt) macro.
	
//10. FloatTo4Char Real to string conversion with 4 characters

	
//Comment:
	
//Program steps:
	
//1. Initialise, with getting Rshunt, Part of Voltages (2, 4 or 6),
	
//   offtime (10 or 30 sec)
	
//2. Start 10/30 second loop
	
//3. Test V0 is within limits
	
//4. Setup ADC's
	
//5. Start without shunt and read V0
	
//6. START WITH SHUNT read Vt, Vh and Vl
	
//7. Stop shunt
	
//8. Transform ADC reading into real voltages
	
//9. Show status by means of red, orange and green LEDs
	
//10. Loop 10/30 seconds
	
//11. Start LCD each second. V0, Vt, I, Ri and count down counter (offtime)

	
//Comment:
	
//Flowcode 6:
	
//Most of the program is written in Flowcode 6.
	
//Written in C:
	
//- For the comparator there was no macro available
	
//- The shortest time for three ADC's has been found 
	
//  to take 150 usec, using Flowcode. 
	
//  Written in C is takes 100 usec, is required.

	
// Name: 16 MHZ internal oscillator, Type: C Code:
	
osccon0x78;

	
//Comment:
	
//1. Initialise, with getting Rshunt, Part of Voltages (2, 4 or 6),
	
//   offtime (10 or 30 sec)

	
// Name: Initialise, Type: Call Macro: Init()
	
FCM_Init();

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

	
	
//Comment:
	
	
//2. Start 10/30 second loop

	
	
//Comment:
	
	
//3. Test V0 is within limits

	
	
// Name: Wait until V0 > V0_min and stop on Vadc>=5V, Type: Call Macro: Test_Voltage_V0()
	
	
FCM_Test_Voltage_V0();

	
	
// Name: LED1 on (white/blue), Type: Call Macro: TriState_Output_Ports_A(1)
	
	
FCM_TriState_Output_Ports_A(1);

	
	
// Name: Stop temporary timer0, Type: Interrupt: Disable TMR0
	
	
cr_bit(INTCONTMR0IE);

	
	
//Comment:
	
	
//4. Setup ADC's

	
	
//Comment:
	
	
//ADC setup has been moved to INIT macro

	
	
//Comment:
	
	
//Tacq the aquisition time (to load the ADC condensor):
	
	
//Tacq= 2.0 µsec +Tc + 0.05?T  
	
	
//with ?T the temperature difference compared to 25 oC
	
	
//and Tc =7.62*10pF*(8k+Rs)
	
	
//with Rs the external load resistance. 
	
	
//The optimal Rs is 10k and Tc = 1.4 usec
	
	
//Other temperatures: increases Tacq with 1 usec/20 oC
	
	
//The total conversion time is 11.5*Tad
	
	
//The conversion time for 1 bit Tad 
	
	
//is for 16 MHz oscillator and ADC clock at Fosc/16: 1 usec
	
	
//This makes the total conversion time is 11.5 usec.
	
	
//Ttotal=  Tacq + Tc = 2 + 2 + 11.5 about 16 usec
	
	
//In the program Tacq is set to 10 usec, so Ttotal is about 22 usec

	
	
//Comment:
	
	
//5. Start without shunt and read V0

	
	
// Name: Read ACD AN1 (V0), Type: Call Macro: ADC_AN1()
	
	
FCM_ADC_AN1();

	
	
// Name: Caluculate  Battery Voltage without shunt, Type: Call Macro: FV0=ADC_to_Voltage(HB0, LB0)
	
	
FCV_FV0 FCM_ADC_to_Voltage(FCV_HB0FCV_LB0);

	
	
//Comment:
	
	
//6. START WITH SHUNT read Vt, Vh and Vl

	
	
// Name: Activate gate of MOSFET: set B3 high, Type: Output: 1 -> B3
	
	
SET_PORT_PIN(B,3,(1));

	
	
//Comment:
	
	
//It takes about 10 usec to get gate of 
	
	
//the MOSFET to become > 4 Volt 

	
	
// Name: 1. Wait until gate at >4V, Type: Delay: Tdelay_usec us
	
	
FCI_DELAYBYTE_US(FCV_TDELAY_USEC);

	
	
//Comment:
	
	
//MOSFET is now on.

	
	
//Comment:
	
	
//Wait again 10 usec to load the ADC capacitor (hold time)

	
	
// Name: 2. Wait ADC aquisition time of 10 usec, Type: Delay: Taquisition_usec us
	
	
FCI_DELAYBYTE_US(FCV_TAQUISITION_USEC);

	
	
// Name: Start conversion AN1 (Vt), wait until ready and save data, Type: C Code:
	
	
adcon0 adcon0 0x02;  // start adc conversion. (Set bit1 of adcon0)
	
	
while(
ts_bit(adcon0,1)); // wait for end conversion, until bit1 has been reset

	
	
FCV_LB1 adresl;
	
	
FCV_HB1 adresh;

	
	
// Name: Set channel AN0 (Vh) and enable ADC, Type: C Code:
	
	
adcon00x01// reset adcon0 and select channel AN0 (for ANx adcon0=x<<2)
	
	
               
// enable ADC (bit0 of adcon0)

	
	
// Name: Wait ADC acquisition time of 10 usec , Type: Delay: Taquisition_usec us
	
	
FCI_DELAYBYTE_US(FCV_TAQUISITION_USEC);

	
	
// Name: Start conversion AN0 (Vh), wait until ready and save data, Type: C Code:
	
	
adcon0 adcon0 0x02;  // start adc conversion. (Set bit1 of adcon0)
	
	
while(
ts_bit(adcon0,1)); // wait for end conversion, until bit1 has been reset

	
	
FCV_LB2 adresl;   // safe low byte
	
	
FCV_HB2 adresh;  // safe high byte

	
	
// Name: Set channel AN6 (Vl) and enable ADC, Type: C Code:
	
	
adcon00x19;   // reset adcon0 and select channel AN2 (for ANx adcon0=x<<2)
	
	
                
// enable ADC (bit0 of adcon0)

	
	
// Name: Wait ADC aquisition time of 10 usec, Type: Delay: Taquisition_usec us
	
	
FCI_DELAYBYTE_US(FCV_TAQUISITION_USEC);

	
	
// Name: Start conversion AN6 (Vl), wait until ready and save data, Type: C Code:
	
	
adcon0 adcon0 0x02;  // start adc conversion. (Set bit1 of adcon0)
	
	
while(
ts_bit(adcon0,1)); // wait for end conversion, until bit1 has been reset

	
	
FCV_LB3 adresl;
	
	
FCV_HB3 adresh;

	
	
//Comment:
	
	
//7. STOP SHUNT     STOP SHUNT     STOP SHUNT     STOP SHUNT     

	
	
// Name: Stop shunt: Reset B3 low, Type: Output: 0 -> B3
	
	
SET_PORT_PIN(B,3,(0));

	
	
//Comment:
	
	
//Safety reasons dubble stop

	
	
// Name: Stop shunt: Reset B3 low, Type: Output: 0 -> B3
	
	
SET_PORT_PIN(B,3,(0));

	
	
// Name: Disable ADC's, Type: C Code:
	
	
adcon0=0x00;  // disable ADC's

	
	
//Comment:
	
	
//8. Transform ADC reading into real voltages

	
	
// Name: (Re)set delay to off time, Type: Calculation:
	
	
// Name: (Re)set delay to off time, Type:  Seconds = Wait_seconds // off time
	
	
// Name: (Re)set delay to off time, Type:  Timer0_Counter = 61 // 61 Hz timer0
	
	
FCV_SECONDS FCV_WAIT_SECONDS;
	
	
FCV_TIMER0_COUNTER 61;

	
	
// Name: Interrupt timer0 with 61 Hz with 16 MHz internal osc, Type: Interrupt: Enable TMR0
	
	
cr_bit(OPTION_REG,T0CS);
	
	
st_bit(OPTION_REG,T0SE);
	
	
OPTION_REG = (OPTION_REG 0xF0) | 0x07;
	
	
st_bit(INTCON,GIE);
	
	
st_bit(INTCONTMR0IE);

	
	
// Name: Calculate the V terminal with shunt, Type: Call Macro: FV_terminal=ADC_to_Voltage(HB1, LB1)
	
	
FCV_FV_TERMINAL FCM_ADC_to_Voltage(FCV_HB1FCV_LB1);

	
	
// Name: Calculate the Voltage at the top of the shunt, Type: Call Macro: FVshunt_topside=ADC_to_Voltage(HB2, LB2)
	
	
FCV_FVSHUNT_TOPSIDE FCM_ADC_to_Voltage(FCV_HB2FCV_LB2);

	
	
// Name: Caluclate the voltage at the bottom of the shunt, Type: Call Macro: FVshunt_bottomside=ADC_to_Voltage(HB3, LB3)
	
	
FCV_FVSHUNT_BOTTOMSIDE FCM_ADC_to_Voltage(FCV_HB3FCV_LB3);

	
	
//Comment:
	
	
//7. Test V < Vmax and current <>0

	
	
// Name: ADC value for V0 ithout shunt, Type: Calculation:
	
	
// Name: ADC value for V0 ithout shunt, Type:  ADC_reading = ((HB0 << 8) + LB0)
	
	
FCV_ADC_READING = ((FCV_HB0 << 8) + FCV_LB0);

	
	
// Name: Calculate current and the internal resistance, Type: Call Macro: Calculations_without_error=Current_and_Internal_resistance()
	
	
FCV_CALCULATIONS_WITHOUT_ERROR FCM_Current_and_Internal_resistance();

	
	
// Name: Vertraging, Type: Delay: 300 ms
	
	
FCI_DELAYINT_MS(300);

	
	
//Comment:
	
	
//9. Show status by means of red, orange and green LEDs

	
	
// Name: Correct calculations?, Type: Decision: Calculations_without_error = 1?
	
	
if (
FCV_CALCULATIONS_WITHOUT_ERROR == 1)
	
	
{

	
	
	
// Name: Time between pulses=10 sec?, Type: Decision: Wait_seconds = 10?
	
	
	
if (
FCV_WAIT_SECONDS == 10)
	
	
	
{

	
	
	
	
//Comment:
	
	
	
	
//In case of batteries mostly 10 seconds
	
	
	
	
//will be choosen. In this case the
	
	
	
	
//LED showing the accumulator status is set off.

	
	
	
	
// Name: Reset actual led number, Type: Calculation:
	
	
	
	
// Name: Reset actual led number, Type:  Actual_Led_Number = 0
	
	
	
	
FCV_ACTUAL_LED_NUMBER 0;

	
	
	
} else {

	
	
	
	
//Comment:
	
	
	
	
//For accumulators pulses are repeated each 30 seconds
	
	
	
	
//In this case the red-orange-green LED show the stauts 
	
	
	
	
//of the accumulator, based on the voltage

	
	
	
	
// Name: Set acutal low-high values for lead accumulators, Type: Calculation:
	
	
	
	
// Name: Set acutal low-high values for lead accumulators, Type:  Vlead_low = Vacc_low
	
	
	
	
// Name: Set acutal low-high values for lead accumulators, Type:  Vlead_high = Vacc_high
	
	
	
	
FCV_VLEAD_LOW FCV_VACC_LOW;
	
	
	
	
FCV_VLEAD_HIGH FCV_VACC_HIGH;

	
	
	
	
// Name: Voltages 0-10 Volt?, Type: Decision: Voltage_Part = 2?
	
	
	
	
if (
FCV_VOLTAGE_PART == 2)
	
	
	
	
{

	
	
	
	
	
// Name: V < 5 Volt  (lead accumultors with less then 3 cells)?, Type: Decision: ADC_reading < 512?
	
	
	
	
	
if (
FCV_ADC_READING 512)
	
	
	
	
	
{

	
	
	
	
	
	
// Name: Set acutal low-high values for 1 lead accumulators, Type: Calculation:
	
	
	
	
	
	
// Name: Set acutal low-high values for 1 lead accumulators, Type:  Vlead_low = Vlead_low / 3
	
	
	
	
	
	
// Name: Set acutal low-high values for 1 lead accumulators, Type:  Vlead_high = Vlead_high / 3
	
	
	
	
	
	
FCV_VLEAD_LOW FCV_VLEAD_LOW 3;
	
	
	
	
	
	
FCV_VLEAD_HIGH FCV_VLEAD_HIGH 3;

	
	
	
	
	
	
// Name: V < 2.5 Volt  (lead accumultors with 1 cells)?, Type: Decision: ADC_reading < 256?
	
	
	
	
	
	
if (
FCV_ADC_READING 256)
	
	
	
	
	
	
{

	
	
	
	
	
	
} else {

	
	
	
	
	
	
	
// Name: Set acutal low-high values for 2  lead accumulators, Type: Calculation:
	
	
	
	
	
	
	
// Name: Set acutal low-high values for 2  lead accumulators, Type:  Vlead_low = Vlead_low << 1 // multiply with 2
	
	
	
	
	
	
	
// Name: Set acutal low-high values for 2  lead accumulators, Type:  Vlead_high = Vlead_high << 1
	
	
	
	
	
	
	
FCV_VLEAD_LOW FCV_VLEAD_LOW << 1;
	
	
	
	
	
	
	
FCV_VLEAD_HIGH FCV_VLEAD_HIGH << 1;

	
	
	
	
	
	
}

	
	
	
	
	
// } else {

	
	
	
	
	
}

	
	
	
	
// } else {

	
	
	
	
}

	
	
	
	
// Name: High voltage?, Type: Decision: ADC_reading > Vlead_high?
	
	
	
	
if (
FCV_ADC_READING FCV_VLEAD_HIGH)
	
	
	
	
{

	
	
	
	
	
// Name: Set green LED, Type: Calculation:
	
	
	
	
	
// Name: Set green LED, Type:  LED_Number = 4
	
	
	
	
	
FCV_LED_NUMBER 4;

	
	
	
	
} else {

	
	
	
	
	
// Name: Low voltage?, Type: Decision: ADC_reading < Vlead_low?
	
	
	
	
	
if (
FCV_ADC_READING FCV_VLEAD_LOW)
	
	
	
	
	
{

	
	
	
	
	
	
// Name: Set red LED, Type: Calculation:
	
	
	
	
	
	
// Name: Set red LED, Type:  LED_Number = 2
	
	
	
	
	
	
FCV_LED_NUMBER 2;

	
	
	
	
	
} else {

	
	
	
	
	
	
// Name: Set yellow/orange LED, Type: Calculation:
	
	
	
	
	
	
// Name: Set yellow/orange LED, Type:  LED_Number = 3
	
	
	
	
	
	
FCV_LED_NUMBER 3;

	
	
	
	
	
}

	
	
	
	
}

	
	
	
}

	
	
	
// Name: Set LED, Type: Call Macro: TriState_Output_Ports_A(LED_Number)
	
	
	
FCM_TriState_Output_Ports_A(FCV_LED_NUMBER);

	
	
	
// Name: Set flag, Type: Calculation:
	
	
	
// Name: Set flag, Type:  PulseSent = 1
	
	
	
FCV_PULSESENT 1;

	
	
	
// Name: Start LCD (Make self starting possible of LCD connected later), Type: Call Component Macro: lcd_eb005::Start()
	
	
	
FCD_0ad31_lcd_eb005__Start();

	
	
} else {

	
	
	
// Name: Reset actual led number, Type: Calculation:
	
	
	
// Name: Reset actual led number, Type:  Actual_Led_Number = 0
	
	
	
FCV_ACTUAL_LED_NUMBER 0;

	
	
	
// Name: Reset flag, Type: Calculation:
	
	
	
// Name: Reset flag, Type:  PulseSent = 0
	
	
	
FCV_PULSESENT 0;

	
	
}

	
	
//Comment:
	
	
//10. Loop 10/30 seconds

	
	
// Name: Start directly to show the results, Type: Calculation:
	
	
// Name: Start directly to show the results, Type:  Timer0_Counter = 1 // pay attention NOT Timer0_Counter = 0
	
	
FCV_TIMER0_COUNTER 1;

	
	
// Name: Count down the off timer, Type: Loop: While Seconds > 0
	
	
while (
FCV_SECONDS 0)
	
	
{

	
	
	
//Comment:
	
	
	
//10/30 second loop

	
	
	
// Name: Seconds have been decreased?, Type: Decision: (Change_seconds = 1)?
	
	
	
if ((
FCV_CHANGE_SECONDS == 1))
	
	
	
{

	
	
	
	
//Comment:
	
	
	
	
//11. Start LCD each second. V0, Vt, I, Ri and count down counter (offtime)

	
	
	
	
// Name: First time after pulse?, Type: Decision: PulseSent = 1?
	
	
	
	
if (
FCV_PULSESENT == 1)
	
	
	
	
{

	
	
	
	
	
// Name: Clear LCD, Type: Call Component Macro: lcd_eb005::Clear()
	
	
	
	
	
FCD_0ad31_lcd_eb005__Clear();

	
	
	
	
	
// Name: Convert FV0  to string, Type: Call Macro: FloatTo4Char(FV0)
	
	
	
	
	
FCM_FloatTo4Char(FCV_FV0);

	
	
	
	
	
// Name: Print text, Type: Call Component Macro: lcd_eb005::PrintString("V0:")
	
	
	
	
	
FCD_0ad31_lcd_eb005__PrintString("V0:"4);

	
	
	
	
	
// Name: Print V0, Type: Call Component Macro: lcd_eb005::PrintString(StrTemp)
	
	
	
	
	
FCD_0ad31_lcd_eb005__PrintString(FCV_STRTEMPFCVsz_STRTEMP);

	
	
	
	
	
// Name: Convert FV-terminal  to string, Type: Call Macro: FloatTo4Char(FV_terminal)
	
	
	
	
	
FCM_FloatTo4Char(FCV_FV_TERMINAL);

	
	
	
	
	
// Name: Space, Type: Call Component Macro: lcd_eb005::PrintString(" ")
	
	
	
	
	
FCD_0ad31_lcd_eb005__PrintString(" "2);

	
	
	
	
	
// Name: Print text, Type: Call Component Macro: lcd_eb005::PrintString("Vt:")
	
	
	
	
	
FCD_0ad31_lcd_eb005__PrintString("Vt:"4);

	
	
	
	
	
// Name: Print V0, Type: Call Component Macro: lcd_eb005::PrintString(StrTemp)
	
	
	
	
	
FCD_0ad31_lcd_eb005__PrintString(FCV_STRTEMPFCVsz_STRTEMP);

	
	
	
	
	
// Name: 2nd line, Type: Call Component Macro: lcd_eb005::Cursor(0, 1)
	
	
	
	
	
FCD_0ad31_lcd_eb005__Cursor(01);

	
	
	
	
	
// Name: print text, Type: Call Component Macro: lcd_eb005::PrintString("I:")
	
	
	
	
	
FCD_0ad31_lcd_eb005__PrintString("I:"3);

	
	
	
	
	
// Name: Covert to string, Type: Call Macro: FloatTo4Char(Current)
	
	
	
	
	
FCM_FloatTo4Char(FCV_CURRENT);

	
	
	
	
	
// Name: Print text, Type: Call Component Macro: lcd_eb005::PrintString(StrTemp)
	
	
	
	
	
FCD_0ad31_lcd_eb005__PrintString(FCV_STRTEMPFCVsz_STRTEMP);

	
	
	
	
	
// Name: Print text, Type: Call Component Macro: lcd_eb005::PrintString("R:")
	
	
	
	
	
FCD_0ad31_lcd_eb005__PrintString("R:"3);

	
	
	
	
	
// Name: Covert to string, Type: Call Macro: FloatTo4Char(FR_internal)
	
	
	
	
	
FCM_FloatTo4Char(FCV_FR_INTERNAL);

	
	
	
	
	
// Name: Print text, Type: Call Component Macro: lcd_eb005::PrintString(StrTemp)
	
	
	
	
	
FCD_0ad31_lcd_eb005__PrintString(FCV_STRTEMPFCVsz_STRTEMP);

	
	
	
	
	
// Name: Print text, Type: Call Component Macro: lcd_eb005::PrintString("m")
	
	
	
	
	
FCD_0ad31_lcd_eb005__PrintString("m"2);

	
	
	
	
	
// Name: Print greef symbol omega for Ohm, Type: Call Component Macro: lcd_eb005::PrintAscii(0xF4)
	
	
	
	
	
FCD_0ad31_lcd_eb005__PrintAscii(0xF4);

	
	
	
	
	
// Name: Reset pulse flag, Type: Calculation:
	
	
	
	
	
// Name: Reset pulse flag, Type:  PulseSent = 0
	
	
	
	
	
FCV_PULSESENT 0;

	
	
	
	
// } else {

	
	
	
	
}

	
	
	
	
// Name: TAB second line place 14, Type: Call Component Macro: lcd_eb005::Cursor(14, 1)
	
	
	
	
FCD_0ad31_lcd_eb005__Cursor(141);

	
	
	
	
// Name: less than 10 seconds?, Type: Decision: Seconds < 10?
	
	
	
	
if (
FCV_SECONDS 10)
	
	
	
	
{

	
	
	
	
	
// Name: Print space, Type: Call Component Macro: lcd_eb005::PrintString(" ")
	
	
	
	
	
FCD_0ad31_lcd_eb005__PrintString(" "2);

	
	
	
	
// } else {

	
	
	
	
}

	
	
	
	
// Name: Print seconds (count down), Type: Call Component Macro: lcd_eb005::PrintNumber(Seconds)
	
	
	
	
FCD_0ad31_lcd_eb005__PrintNumber(FCV_SECONDS);

	
	
	
	
// Name: reset flag, Type: Calculation:
	
	
	
	
// Name: reset flag, Type:  Change_seconds = 0
	
	
	
	
FCV_CHANGE_SECONDS 0;

	
	
	
	
// Name: Correct calulcations I and Ri?, Type: Decision: Calculations_without_error = 1?
	
	
	
	
if (
FCV_CALCULATIONS_WITHOUT_ERROR == 1)
	
	
	
	
{

	
	
	
	
} else {

	
	
	
	
	
//Comment:
	
	
	
	
	
//Flickering of LED each second

	
	
	
	
	
// Name: LED on/off, Type: Calculation:
	
	
	
	
	
// Name: LED on/off, Type:  Actual_Led_Number = LED_Number - Actual_Led_Number
	
	
	
	
	
FCV_ACTUAL_LED_NUMBER FCV_LED_NUMBER FCV_ACTUAL_LED_NUMBER;

	
	
	
	
	
// Name: Set LED, Type: Call Macro: TriState_Output_Ports_A(Actual_Led_Number)
	
	
	
	
	
FCM_TriState_Output_Ports_A(FCV_ACTUAL_LED_NUMBER);

	
	
	
	
}

	
	
	
// } else {

	
	
	
}


	
	
}


	
}

	
mainendloop: goto mainendloop;
}



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

	
//Handler code for [TMR0]
	
#ifndef MX_INTHANDLER_INTCON_TMR0IF
	
#define MX_INTHANDLER_INTCON_TMR0IF
	
if (
ts_bit(INTCONTMR0IF) && ts_bit(INTCONTMR0IE))
	
{
	
	
FCM_Timer0_Interrupt();
	
	
cr_bit(INTCONTMR0IF);
	
}
	
#else
	
#warning "This interrupt has previously been enabled, so the macro <Timer0_Interrupt> may never get called."
	
#endif


	
//Handler code for [TMR0]
	
#ifndef MX_INTHANDLER_INTCON_TMR0IF
	
#define MX_INTHANDLER_INTCON_TMR0IF
	
if (
ts_bit(INTCONTMR0IF) && ts_bit(INTCONTMR0IE))
	
{
	
	
FCM_Timer0_Interrupt();
	
	
cr_bit(INTCONTMR0IF);
	
}
	
#else
	
#warning "This interrupt has previously been enabled, so the macro <Timer0_Interrupt> may never get called."
	
#endif


	
//Handler code for [TMR0]
	
#ifndef MX_INTHANDLER_INTCON_TMR0IF
	
#define MX_INTHANDLER_INTCON_TMR0IF
	
if (
ts_bit(INTCONTMR0IF) && ts_bit(INTCONTMR0IE))
	
{
	
	
FCM_Timer0_Interrupt();
	
	
cr_bit(INTCONTMR0IF);
	
}
	
#else
	
#warning "This interrupt has previously been enabled, so the macro <Timer0_Interrupt> may never get called."
	
#endif


	
//Handler code for [TMR0]
	
#ifndef MX_INTHANDLER_INTCON_TMR0IF
	
#define MX_INTHANDLER_INTCON_TMR0IF
	
if (
ts_bit(INTCONTMR0IF) && ts_bit(INTCONTMR0IE))
	
{
	
	
FCM_Timer0_Interrupt();
	
	
cr_bit(INTCONTMR0IF);
	
}
	
#else
	
#warning "This interrupt has previously been enabled, so the macro <Timer0_Interrupt> may never get called."
	
#endif


}




Ama işine yararmı bilmem
Başlık: Ynt: FLOWCODE da FCFX uzantı nedir?
Gönderen: Epsilon - 03 Kasım 2019, 12:17:47
@Mehmet Salim GÜLLÜCE elinize sağlık.

Ancak çok ilginç,bu son mesajınızda kodların olduğu kısma fare ile tıkladığımda (kodu seçip kopyalamak için falan)sayfa kilitleniyor,sayfada hiçbirşey çalışmıyor, "Alıntı Yap" butonu da çalışmıyor.Sanırım @gevv in kontrol etmesi gereken bir durum oluşuyor.
Başlık: Ynt: FLOWCODE da FCFX uzantı nedir?
Gönderen: Mehmet Salim GÜLLÜCE - 03 Kasım 2019, 15:40:49
Alıntı yapılan: Epsilon - 03 Kasım 2019, 12:17:47@Mehmet Salim GÜLLÜCE elinize sağlık.

Ancak çok ilginç,bu son mesajınızda kodların olduğu kısma fare ile tıkladığımda (kodu seçip kopyalamak için falan)sayfa kilitleniyor,sayfada hiçbirşey çalışmıyor, "Alıntı Yap" butonu da çalışmıyor.Sanırım @gevv in kontrol etmesi gereken bir durum oluşuyor.
Mail verirseniz gönderebilirimde.

Özel Mesaj ile gönderdim
Başlık: Ynt: FLOWCODE da FCFX uzantı nedir?
Gönderen: Mehmet Salim GÜLLÜCE - 03 Kasım 2019, 15:52:02
Ayrıca flowcode bölümünde kürekli versiyon 8 war oradan indirip kendinde bakabilirsin.
Kaynak üzerinde en iyi çalışmayı o ortamda yaparsın.
Başlık: Ynt: FLOWCODE da FCFX uzantı nedir?
Gönderen: Epsilon - 03 Kasım 2019, 15:59:32
Alıntı yapılan: Mehmet Salim GÜLLÜCE - 03 Kasım 2019, 15:52:02Ayrıca flowcode bölümünde kürekli versiyon 8 war oradan indirip kendinde bakabilirsin.
Kaynak üzerinde en iyi çalışmayı o ortamda yaparsın.
Haklısınız da ben hiç flowcode bilmiyorum.Youtube dada hemen hiçbir bilgi yok
Eklediğiniz versiyonunun 2 linkini de indirdim.Ama hiçbirşey bilmediğim için kurmadım.
Başlık: Ynt: FLOWCODE da FCFX uzantı nedir?
Gönderen: Mehmet Salim GÜLLÜCE - 03 Kasım 2019, 22:12:10
Alıntı yapılan: Epsilon - 03 Kasım 2019, 15:59:32Haklısınız da ben hiç flowcode bilmiyorum.Youtube dada hemen hiçbir bilgi yok
Eklediğiniz versiyonunun 2 linkini de indirdim.Ama hiçbirşey bilmediğim için kurmadım.

Benim eklediğim birkaç uygulama örneği war aslında.
Size fikir verir.

Bunlarıda seyrederseniz illaki size faydası olur.
https://www.youtube.com/results?search_query=flowcode+dersleri (https://www.youtube.com/results?search_query=flowcode+dersleri)