#ifndef __TYPEDEF_H
#define __TYPEDEF_H

typedef signed char _SBYTE;
typedef unsigned char _UBYTE;
typedef signed short _SWORD;
typedef unsigned short _UWORD;
typedef signed int _SINT;
typedef unsigned int _UINT;
typedef signed long _SDWORD;
typedef unsigned long _UDWORD;

/*  typedefs */
typedef unsigned char tUChar;
typedef signed char tSChar;
typedef unsigned int tUInt;
typedef signed int tSInt;
typedef unsigned long tULong;
typedef signed long tSLong;

#ifndef TRUE
#define TRUE          1
#endif 

#ifndef FALSE
#define FALSE         0
#endif 


#define NO_ERROR	  0



#ifndef NULL
 #define NULL	0
#endif 



typedef void (*pFunc)(void);

#define	MergeValue(a,b)		a<<8 | b



#include "sensors.h"		// pro definici MAX_SENSORS


//*****************************************************************************************
// The structure contain information about system requirement and its parameter
// Purpose of this structure used it in array of requirement (requirement(task) buffer)
//*****************************************************************************************
typedef struct  
{
	tUChar type;
	tUChar byte_count;
	tUChar address_hi;
	tUChar address_low;
	tUChar data[64];
	tUChar crc;
} tsSrec; 



//*****************************************************************************************
// struktura pro pretypovani konektovacich tabulek pro pristup pres int
//*****************************************************************************************
typedef union  {
	unsigned int  X;
	struct {
            unsigned char HI;
            unsigned char LO;
           }      VALUE;     	
 } GUINTRECORD;


typedef union  {
	unsigned int  X[2];
	struct {
            unsigned char X0_HI;
            unsigned char X0_LO;
            unsigned char X1_HI;
            unsigned char X1_LO;
           }      VALUE_X;     	
 } GUINTADDR;
 
//*****************************************************************************************
// The structure contain ADC_status + ADC_Buffer
//*****************************************************************************************
typedef struct
{
	tUInt  buffer[3];	// 3x 10bit ADC value = TEMP+NAPETI+PROUD
	tUChar status;
} tsADC;


//*****************************************************************************************
// The structure contain EEPROM Buffer and memory MAP management
//*****************************************************************************************
typedef struct
{
	tUInt address;		// start adress in EEPROM
	tUChar data[16];	
} tsEEPROM;


//*****************************************************************************************
// The structure contain EEPROM Buffer and memory MAP management
//*****************************************************************************************
typedef struct
{
  tUChar block;		// blok 
  tUInt address;	// adresa na kterou ramec prijde ulozit
  tUInt length;		// delka dat
  tUChar status;	// status operace
  tUChar *buffer;	// pointer na zdrojovy buffer
} tsBOOTLOADER;

extern tsBOOTLOADER BOOT;


//**********************************************************************
// The structure contain low level master information stored in EEPROM 
// obsah teto struktury se nahrava v bootloaderu a nelze aplikaci zmenit
//**********************************************************************
typedef struct CONSTANT         
{ 
  tUChar tsn[12];		// read only - serial number		 
  tUChar master;		// read only - verze masteru		 
  tUChar bootver;		// read only - verze bootloaderu		  
  
  tUChar manufact;		// read only - verze manufactuer - nepouziva se
  tUChar rez1;			
  
  tUInt  MACadr[3];     // [0] - read only - MAC address from master
						// [1] - r/w - working MAC address 
						// [2] - r/w - copy working MAC address 
  tUChar rez[10];		// volne misto do 16 bajtu

} tsConstant;


//*****************************************************************************************
// struktura title - popisek 
//*****************************************************************************************
typedef struct TITLE    /* 16 byte */
{ 
  tUChar string[16];	// textovy popisek jednotky, oznaceni HW+SW pro lepsi identifikaci 
} tsTitle;




//*****************************************************************************************
// The structure contain system operative data stored in EEPROM
//*****************************************************************************************
typedef struct
{
	tUInt idAdr;	// adresa jednotky na sbernici = working MAC
	tUInt appcfg;	// konfigurace
	tUInt appcfg1;	// konfigurace
	tUInt appcfg2;	
	tUInt appcfg3;
	tUInt appcfg4;
	tUInt appcfg5;
	tUChar BFL;		// kontrolni bajt pro bootloader
	tUChar cfgDone;	// kontrolni bajt, ze inicializace vseho byla provedena
} tsOPER;  




	
//************************************************************************
// adresace v EEPROM, mapovano od adresy 0x3000 - BLOCK_A (pouzito 80 bajtu)
// kvuli operacim READ/MODIFY/WRITE se musi obsah bufferovat do RAM
// tak kvuli tomu je omezen maximalni prostor konfigurace na 128 Bajtu 
//************************************************************************
#define SNCONST_ADDRESS				DF_BLOCK_A_START								// zde je ulozeno SN

#define CDATAADDRESS_CONSTANT		DF_BLOCK_A_START								// ulozena struktura CONSTANT - pouze cteni - nedrzi se v pameti, nutno vzdy nacist v pripade potreby
#define STUCT_CONSTANT_SIZE			sizeof(tsConstant)								// 32 bajtu, velikost struktury CONSTANT v bajtech

#define CDATAADDRESS_OPERATIVE		CDATAADDRESS_CONSTANT + STUCT_CONSTANT_SIZE		// struktura tsOPER
#define STRUCT_OPERATIVE_SIZE		sizeof(tsOPER)									// 16 bajtu, velikost struktury OPERATIVE v bajtech

#define CDATAADDRESS_TITLE			CDATAADDRESS_OPERATIVE + STRUCT_OPERATIVE_SIZE 	// textovy popis jednotky 16 byte
#define STRUCT_TITLE_SIZE			sizeof(tsTitle)									// 16 bajtu, velikost struktury TITLE v bajtech

#define CDATAADDRESS_CONFIG			CDATAADDRESS_TITLE + STRUCT_TITLE_SIZE 			// globalni konfigurace zarizeni
#define STRUCT_CONFIG_SIZE			sizeof(tsConfig)									// 16 bajtu, velikost struktury CONFIG v bajtech

// pro nacitani z dataFlash, celkova alokace dat, aby jsme zbytecne nenacitali vice
#define BLOCK_A_ALLOC_SIZE			STUCT_CONSTANT_SIZE + STRUCT_OPERATIVE_SIZE + STRUCT_TITLE_SIZE + STRUCT_CONFIG_SIZE

// offset pro RamBuffer pro R/M/W 
#define OFFSET_ADDRESS_CONSTANT		CDATAADDRESS_CONSTANT-DF_BLOCK_A_START			
#define OFFSET_ADDRESS_OPERATIVE	CDATAADDRESS_OPERATIVE-DF_BLOCK_A_START
#define OFFSET_ADDRESS_TITLE		CDATAADDRESS_TITLE-DF_BLOCK_A_START
#define OFFSET_ADDRESS_CONFIG		CDATAADDRESS_CONFIG-DF_BLOCK_A_START


//************************************************************************
//adresace v EEPROM, mapovano od adresy 0x3400 - BLOCK_B
// HW konfigurace a prioritni offline karty
//************************************************************************
#define CDATAADDRESS_DEFCARD		DF_BLOCK_B_START								// zde se ukladaji karty pro offline rezim
#define STRUCT_DEFCARD_SIZE			MAX_NUMBER_EMERGENCY_CARDS * sizeof(tsOffCard)  // velikost je pro max.pocet karet

#define CDATAADDRESS_INPUTTABLE		CDATAADDRESS_DEFCARD+STRUCT_DEFCARD_SIZE	    // ulozena struktura inputTable - limitz sensoru
#define STRUCT_INPUTTABLE_SIZE		sizeof(inputTable)							    // velikost struktury 

// pro nacitani z dataFlash, celkova alokace dat, aby jsme zbytecne nenacitali vice
#define BLOCK_B_ALLOC_SIZE			STRUCT_INPUTTABLE_SIZE + STRUCT_DEFCARD_SIZE

// offset pro RamBuffer pro R/M/W 
#define  OFFSET_ADDRESS_INPUTCONFIG	CDATAADDRESS_INPUTTABLE-DF_BLOCK_B_START



//************************************************************************
// EEPROM blok D nelze pouzit, nahravaji se zde rutiny pro E8a debugger
//************************************************************************


// maskovani pro appCB.mode
#define REQFLAG_MASK			0x0100		// flag pro kontrolu REQ bufferu udalosti
#define LEDFLAG_MASK			0x0200		// flag pro provoz zelenych LED na modulech pokud je nastaven zelene se ridi nastavenim v module.output[0]
#define READADC_MASK			0x0400		// flag nastavovany v TimerZ pro spousteni vzorkovani tlacitek
#define DISABLE_MASK			0x0800		// interni flag pro vzorkovani tlacitek
#define free_MASK				0x1000		// volno
#define SYSBUSY_MASK			0x8000		// po dobu nastaveni flagu nejsou zpracovany zadne udalosti
#define SUBMENU_INFO_MASK		0x2000		// flag pro polozky SUBMENU - informativni vypis talcitkem INFO (RIGHT)-blokovani funkci ktere nechci
#define INP_INIT_MASK			0x4000		// flag pro inicializaci InputCheck(), prepisuje se tabulka inputTable a negeneruji se udalosti


//------------------------------------------------------------------------
// struktura virtualniho casovace
//------------------------------------------------------------------------
typedef struct 
{
  tUInt divider;				// delicka pro Timer
  tUInt overflow;				// flag preteceni citace = docasovano
} tsTimer;



//------------------------------------------------------------------------
// timer B pro funkci delay na pozadi
//------------------------------------------------------------------------
typedef struct 
{
  tUInt divider;				// delicka pro Timer
  tUInt counter;				// citac
  tUInt timeout;				// flag preteceni citace = docasovano
} tsTimerB;


//------------------------------------------------------------------------
// timer C pro funkci delay na pozadi
//------------------------------------------------------------------------
typedef struct 
{
  tUInt counter;				// citac
  tUInt timeout;				// flag preteceni citace = docasovano
} tsTimerC;



typedef struct
{
	tUChar presence_counter;	// citac pro detekci odpojeni
	tUChar presence_state;		// pritomnost sensoru teploty
	tUChar old_presence_state;	// pritomnost sensoru teploty
	tUChar presence_error;		// ma byt cidlo pritomno ale neni, pro generovani paketu po startu
	tUChar first_sample;		// prvni mereni na sensoru DALLAS
    tUChar undervoltage;		// podpeti na mereni Vcc
} tsGlobalSensorDef;

									
//*****************************************************************************************
// hlavni systemova struktura appCB
//*****************************************************************************************
typedef struct  
{
	tUChar task;					// number of item in array which cover pointer to functions
	tUChar error;					// system errores
	tUChar last_error;				// system errores
	tUInt  mode;					// stavove slovo jednotky - bitova maska
									// bit 0-3: 0=normalni rezim provozu, >0 = pozice v hlavnim menu
									// bit 4-7: flagy pro funkce subMenu
									// bit 8-15: systemove flagy
	tUInt  SciTmp;					// pomocna promenna pro SCI funkce
	tUInt  cycles200ms;				// pomocna promena
	tUChar cycles1sec;				// number of 1 s timer cycles, reset by API if demand

	GUINTRECORD 	SubMenu_tmp;

	tsTimer	 timer5ms;
	tsTimer  timer10ms;
	tsTimer	 timer20ms;
	tsTimer  timer100ms;
	tsTimer  timer200ms;
	tsTimer  timer250ms;	
	tsTimer  timer1sec;
	tsTimerB timerB;			// timeout timer_B
	tsTimer	 timerC;			// timeout timer_C
	tsADC 	 adc;
	
	tsGlobalSensorDef sensor;	// pomocna struktura k mereni teploty

	tUInt  StatValue[4];		// uloziste pro statistiky pocitadla
								//	0 - ztracenych paketu
								//  1 - opakovanych paketu
								//  2 - rezerva
								//  3 - rezerva
	tUChar sensorCount;			// pocet mericich poeriferii-sensoru, v ramci zarizeni, obdobne jako pocetModulu u GRU01 
	tUChar iChk;
		
} tsAppCB; 

extern tsAppCB  appCB;




//*****************************************************************************************
// struktura tsModule
// uchovava realne informace o virtualnich mericich modulech
//*****************************************************************************************
typedef struct  
{
	tUInt type;				// spodnich 5 bitu je HWID = typ modulu
							// horni bity jsou volne pro pouziti v API vrstve, prepisuji se pouze ve funkci ProcessModules
	tUInt input[1];
	tUInt output[1];
} tsModule;



//------------------------------------------------------------------------
// struktura citacu EDK
//------------------------------------------------------------------------
typedef struct 
{
	tUChar led_time;					// doba svitu LED [x100ms]
	tUChar led_cycles;					// pocet bliknuti [x1]
	tUChar blocked_buzzer_timer;		// blokujici flag buzzer timeru
	tUInt  buzzer_time;					// delka pipnuti [x100ms]
	tUChar buzzer_cycles;				// pocet pipnuti [x1]
	tUInt  relay;						// doba sepnuti rele [x100ms]
    tUInt  optocoupler;					// citac doby aktivace opozavory
    tUChar input1;						// citac doby aktivace vstupu 1
	tUChar input2;						// citac doby aktivace vstupu 2 
    tUChar input3;						// citac doby aktivace vstupu 1
	tUChar input4;						// citac doby aktivace vstupu 2 
    tUChar input5;						// citac doby aktivace vstupu 1
	tUChar input6;						// citac doby aktivace vstupu 2 
    tUChar input7;						// citac doby aktivace vstupu 1
	tUChar input8;						// citac doby aktivace vstupu 2 
    
	tUInt  sync_out;					// delicka pro generovani sync signalu	
	tUChar flip_div;					// delicka pro blikani LED
    tUChar flip_div2;					// delicka pro pipani
	tUChar d1pulse_time;				// delka pulsu do pinu DATA1
	tUChar comm_timeout;				// timeout pro detekci vypadku komunikace s terminalem
	tUChar ehs_check_interval;			// pro osahavani karty u odkladacky
	tUChar temperature_check_interval;	// pro osahavani teplomeru
	tUChar temperature_send_interval;	// automaticke odesilani teploty paketem STV
} tsCounter;


//------------------------------------------------------------------------
// struktura tsGUI pro ovladani piskace a buzzeru prikazem GUI
//------------------------------------------------------------------------
typedef struct 
 {
   tUChar value; 
   tUChar mask;
   tUChar idle_value; 
   tUChar idle_mask;
 } tsGUI;


//------------------------------------------------------------------------
// struktura pro obsluhu vstupu a DIPU
//------------------------------------------------------------------------
typedef struct 
{
  unsigned int state; 
  unsigned int lastState;   
  unsigned int change;   
} tsIN;


//------------------------------------------------------------------------
// struktura drzi nactene data ze sensoru 
//------------------------------------------------------------------------
typedef struct 
{
  signed int raw; 		// raw data primo z cidla
  signed int data; 		// zpracovane data 
} tsSensor;



//------------------------------------------------------------------------
// globalni konfiguracni parametry - 16 bajtu, lze rozsirovat
//------------------------------------------------------------------------
typedef struct
{
  tUChar check_byte;		// kontrolni bajt - pokud neni nastaven, jedna se o prvni spusteni a je nutno 
  							// inicializovat default hodnotami, po dalsim spusteni se uz nacita z DATAFLASH vzdy
  tUChar card_timeout;		// timeout pro přiložení karty (čas v sekundách)
  tUChar emm_code_length;	// 4/5 bytů z karty (pouze EMmarin)
  tUChar card_code_reverse;	// kód z karty je načten v opačném pořadí bytů v horní a dolní polovině bytů
  tUChar card_code_flip;	// otocene poradi bajtu
  tUChar card_code_dal;		// kod karty jako cislo DALLAS
  tUChar card_code_mf7;		// kod karty jako cislo PARADOX MF7
  tUChar card_code_dec;		// kód z karty je převeden na dekadické vyjádření
  tUChar card_code_hex;		// kód z karty je převeden na hexa vyjádření
  tUChar wg_bit_length;		// Wiegand 26 / 32 /42bit
  tUChar card_code_length;	// 8/10/16 znaků  
  tUChar card_send_loop;	// čtečka posílá opakovaně kód poslední načtené karty dokud je karta v dosahu
  tUChar buzzer_active;		// piskac piska/nepiska
  tUChar buzzer_wait_card;	// aktivace zvuku pískače při požadavku na přiložení karty 
  tUChar loopinp;  			// perioda generovani paketu MEASURE 
  tUChar check_offline;		// pokud je nastaveno, je hlidana komunikace s terminalem a v pripade vypadku jsou akceptovany master karty.
  tUChar free[16];			// rezervace
} tsConfig;



//*****************************************************************************************
//	The structure tsEDK
//*****************************************************************************************
typedef struct  
{
	tUInt  sys_flag;			// stavove systemove flagy EDK
	tUInt  io_flag;				// IO flagy EDK
	tUInt  ext_io_flag;				// IO flagy EDK
	
	tUChar sync_level;			// synchronizacni propojeni ctecek
	tUChar old_sync_level;
	tUChar sync_count;			// delicka SYNC pro EDK 
	tUChar output;				// vystupy 
	
	tsSensor	sensor[MAX_SENSORS];	// data ze sensoru, interni i externi, rozmer pole podle prekladu
	tsCounter	counter;		// doba sepnuti rele	
	tsIN	  	input;			// globalni promena vsech vstupu
	tsIN 	  	dip;			// DIP prepinac
	tsIN  	  	optocoupler;	// optozavora
	tsIN  		input1;			// pro filtraci vstupu IN1 - odchodove tlacitko nebo pro GR_EXT8 vstup IN1
	tsIN  		input2;			// pro filtraci vstupu IN2 - dverni kontakt nebo pro GR_EXT8 vstup IN2

// GR_EXT8
	tsIN  		input3;			// pro filtraci vstupu IN3 GR_EXT8 IN3
	tsIN  		input4;			// pro filtraci vstupu IN4 GR_EXT8 IN4
	tsIN  		input5;			// pro filtraci vstupu IN5 GR_EXT8 IN5
	tsIN  		input6;			// pro filtraci vstupu IN6 GR_EXT8 IN6
	tsIN  		input7;			// pro filtraci vstupu IN7 GR_EXT8 IN7	
	tsIN  		input8;			// pro filtraci vstupu IN8 GR_EXT8 IN8
	// postupně budou přidavany vstupy 8-12 dle požadavků	
				

	tsGUI 		led;			// LED diody
	tsGUI 		buzzer;			// piskac
	tUChar 		jumpers;		// pomocna promena, pro stav jumperu, binarni hodnota odpovida pozicim
	tUChar	 	hwspec_low;		// pro predani HWSPEC (stav osazenych jumperu) na dotaz STV + typ zarizeni (nahrazuje HW_SPEC_LOW) 	
	tsConfig	config;
} tsEDK;

extern tsEDK EDK;


//*****************************************************************************************
//	struktura citacu pro POW
//*****************************************************************************************
typedef struct 
{
	tUInt relay;			// doba odepnuti rele [x100ms]
    tUInt optocoupler;		// citac doby aktivace opozavory
    tUInt EPS;				// citac doby aktivace vstupu EPS
	tUInt TMP;				// citac doby aktivace vstupu TMP
    tUInt LOCK;				// citac doby aktivace vstupu LOCK
	tUInt RESET;			// citac doby aktivace vstupu RESET
} tsPOWCounter;


//*****************************************************************************************
//	The structure tsPOW
//*****************************************************************************************

typedef struct  
{
	tUInt flag;				// stavove flagy POW
	
	tsIN   input;			// globalni promena vsech vstupu
	tsIN   dip;				// DIP prepinac
	
	tsIN   inputEPS;		// pro filtraci vstupu EPS
	tsIN   inputTMP;		// pro filtraci vstupu TMP
	tsIN   inputLOCK;		// pro filtraci vstupu LOCK
	tsIN   inputRESET;		// pro filtraci vstupu RESET

	tsPOWCounter counter;	// citace POW
					
	tUChar output;			// vystupy 
	tUInt  adc[3];			// adc kanaly
	
} tsPOW;

extern tsPOW POW;

//*****************************************************************************************
// systemova struktura pro ulozeni seznamu offline karet do dataflash
// pro zapis jedne karty pouzito 8 bajtu
//*****************************************************************************************
typedef struct
{
	tUChar index;	// index zaznamu
	tUChar Id[4];	// 4 bajty ID karty
	tUChar Pin[2];	// 2 bajty ID karty
	tUChar crc;		// kontrolni soucet polozky - pouze 8-bitovy aby byl vysledny blok 8 bajtu
} tsOffCard;

extern	tsOffCard	 gOffCard;



// pro praci MIFARE bloky - pakety z PC
typedef struct
{
    tUChar cmd[4];		// command
    tUChar id[4];		// UID karty
    tUChar block;		// cislo bloku
    tUChar ktype;		// typ klice KEY-A nebo KEY-B
	tUChar kid;			// id klice- pozice v EEPROM 11-24, 0xFF pro inicializaci, pokud je 0x00 tak poskytnuty klic
    tUChar key[6];		// klice
    // !! je nutne zachovat tuto strukturu, aby crc[] bylo posledni za data[]
    tUChar data[16];	// data pro zapis
	tUChar crc[2];		// crc16
} tsRD3_packet;

extern	tsRD3_packet	 RD3_packet;



//========================================================================
//>> CARD_CONTROL_STRUCT
// struktura promennych vse okolo cteni karty EMMARIN
//------------------------------------------------------------------------
#define EHS_BUFF_SIZE	2	  // velikost bufferu		
typedef struct 
{
 unsigned char cardId[10];   		 	// cislo karty
 unsigned char old_cardId[10];   		// posledni nactene cislo karty, kvuli podvrhu u EHS4
 
 unsigned char mif_cc;       			// mifare CARD CODE - 1. byte SAK
 unsigned char mif_flag;				// status MIFARE READ/WRITE
 unsigned char mif_status;				// navratovy kod operace s kartou MIFARE
 unsigned char mif_rwmode;				// mod pristupu ke karte
 unsigned char old_state;    		 	// stav karty - prolizena/oddalena
 unsigned char state;         		 	// stav karty - prolizena/oddalena
 unsigned char isbusy;        			// flag ze probiha cteni karty
 unsigned int  wg_cc;         		 	// wiegand CARD CODE
 unsigned int  wg_fc;         		 	// wiegand FC
 unsigned char sector_data[16];			// obsah sektoru MIFARE
 unsigned char card_type[3];			// typ MIFARE karty
 unsigned char ehs_buff[EHS_BUFF_SIZE]; // card buffer pro nacteni karty EHS
 unsigned char ehs_buff_index; 			// index do pole ehs_buff	
 unsigned char ehs_first; 
 unsigned char ehs_inserted; 
} tsCARD;

extern  tsCARD	gCard;

struct TranSciveBuffer
{
  unsigned char MfCommand;
  unsigned int  MfLength;
  unsigned char MfData[64];
};


//*****************************************************************************************
// The structure contain information about system requirement and its parameter
// Purpose of this structure used it in array of requirement (requirement(task) buffer)
//*****************************************************************************************
typedef struct  
{
	tUInt requirement;
	tUInt parameter;
	tUInt addr[2];
} tsReq; 





#endif