/*
 * ZDistL.c
 *
 *  Created on: 07-03-2017
 *      Author: Krzysztof Jakubczyk
 */

#include <math.h>

#include "../tdefs.h"
#include "../misc.h"

#include "helper.h"
#include "ZDistL.h"
#include "ZDistA.h"

struct ZDistL_nast
{
	double ts1LE;///< Czas wyłączenia strefy 1 zwarcia jednofazowe z ziemią
	double ts1LL;///< Czas wyłączenia strefy 1 zwarcia miedzyfazowe
	double ts2LE;///< Czas wyłączenia strefy 2 zwarcia jednofazowe z ziemią
	double ts2LL;///< Czas wyłączenia strefy 2 zwarcia miedzyfazowe
	double ts3LE;///< Czas wyłączenia strefy 3 zwarcia jednofazowe z ziemią
	double ts3LL;///< Czas wyłączenia strefy 3 zwarcia miedzyfazowe
	double ts4LE;///< Czas wyłączenia strefy 4 zwarcia jednofazowe z ziemią
	double ts4LL;///< Czas wyłączenia strefy 4 zwarcia miedzyfazowe
	double ts5LE;///< Czas wyłączenia strefy 5 zwarcia jednofazowe z ziemią
	double ts5LL;///< Czas wyłączenia strefy 5 zwarcia miedzyfazowe

	long Stf1; ///< Sposób działania strefy 1
	long Stf2; ///< Sposób działania strefy 2
	long Stf3; ///< Sposób działania strefy 3
	long Stf4; ///< Sposób działania strefy 4
	long Stf5; ///< Sposób działania strefy 5
};

int ZDistL_initlog(void *arguments, void *logic)
{
	struct ZDistL_args *args = (struct ZDistL_args *)arguments;
	struct ZDistL_logic *log = (struct ZDistL_logic *)logic;
	struct ZDistL_nast znast;

	if(set_bit_ptr_struct(args->io.stan_bl_in,&log->stan_bl))
		return -1;

	if(set_pointer_in_ptr(args->io.we_zdist_ptr_in,(u32 *)&log->WE_Zdist))
		return -1;
	if(set_pointer_in_ptr(args->io.we_l1_ptr_in,(u32 *)&log->WE_L1))
		return -1;
	if(set_pointer_in_ptr(args->io.we_l2_ptr_in,(u32 *)&log->WE_L2))
		return -1;

	if(set_bit_ptr_struct(args->io.bl_ps_in,&log->Bl_PS))
		return -1;
	if(set_bit_ptr_struct(args->io.bl_ufail_in,&log->Bl_Ufail))
		return -1;
	if(set_bit_ptr_struct(args->io.bl_sck_in,&log->Bl_SCH))
		return -1;
	if(set_bit_ptr_struct(args->io.wm_ok_in,&log->WM_OK))
		return -1;
	if(set_bit_ptr_struct(args->io.w_on_l1_in,&log->W_ON_L1))
		return -1;
	if(set_bit_ptr_struct(args->io.w_off_l1_in,&log->W_OFF_L1))
		return -1;
	if(set_bit_ptr_struct(args->io.w_on_l2_in,&log->W_ON_L2))
		return -1;
	if(set_bit_ptr_struct(args->io.w_off_l2_in,&log->W_OFF_L2))
		return -1;
	if(set_bit_ptr_struct(args->io.w_on_l3_in,&log->W_ON_L3))
		return -1;
	if(set_bit_ptr_struct(args->io.w_off_l3_in,&log->W_OFF_L3))
		return -1;
	if(set_bit_ptr_struct(args->io.start_spz_in,&log->Start_SPZ))
		return -1;
	if(set_bit_ptr_struct(args->io.bl_spz_in,&log->BL_SPZ))
		return -1;
	if(set_bit_ptr_struct(args->io.z_in,&log->Z))
		return -1;
	if(set_bit_ptr_struct(args->io.kas_syg_in,&log->Kas_Syg))
		return -1;
	if(set_bit_ptr_struct(args->io.test_in,&log->test))
		return -1;

	if(set_bit_ptr_struct(args->io.p_out,&log->P))
		return -1;
	if(set_bit_ptr_struct(args->io.p1w_out,&log->P1W))
		return -1;
	if(set_bit_ptr_struct(args->io.p1_out,&log->P1))
		return -1;
	if(set_bit_ptr_struct(args->io.p2_out,&log->P2))
		return -1;
	if(set_bit_ptr_struct(args->io.p3_out,&log->P3))
		return -1;
	if(set_bit_ptr_struct(args->io.p4_out,&log->P4))
		return -1;
	if(set_bit_ptr_struct(args->io.p5_out,&log->P5))
		return -1;
	if(set_bit_ptr_struct(args->io.r_out,&log->R))
		return -1;
	if(set_bit_ptr_struct(args->io.s_out,&log->S))
		return -1;
	if(set_bit_ptr_struct(args->io.t_out,&log->T))
		return -1;
	if(set_bit_ptr_struct(args->io.e_out,&log->E))
		return -1;
	if(set_bit_ptr_struct(args->io.z1w_out,&log->Z1W))
		return -1;
	if(set_bit_ptr_struct(args->io.z1_out,&log->Z1))
		return -1;
	if(set_bit_ptr_struct(args->io.z2_out,&log->Z2))
		return -1;
	if(set_bit_ptr_struct(args->io.z3_out,&log->Z3))
		return -1;
	if(set_bit_ptr_struct(args->io.z4_out,&log->Z4))
		return -1;
	if(set_bit_ptr_struct(args->io.z5_out,&log->Z5))
		return -1;
	if(set_bit_ptr_struct(args->io.w_out,&log->W))
		return -1;
	if(set_bit_ptr_struct(args->io.w1_out,&log->W1))
		return -1;
	if(set_bit_ptr_struct(args->io.w2_out,&log->W2))
		return -1;
	if(set_bit_ptr_struct(args->io.w3_out,&log->W3))
		return -1;
	if(set_bit_ptr_struct(args->io.zal_out,&log->zal))
		return -1;
	if(set_bit_ptr_struct(args->io.p_spz_out,&log->P_SPZ))
		return -1;
	if(set_bit_ptr_struct(args->io.spz_p1_out,&log->SPZ_P1))
		return -1;
	if(set_bit_ptr_struct(args->io.spz_p2_out,&log->SPZ_P2))
		return -1;
	if(set_bit_ptr_struct(args->io.spz_p3_out,&log->SPZ_P3))
		return -1;
	if(set_bit_ptr_struct(args->io.spz_p4_out,&log->SPZ_P4))
		return -1;
	if(set_bit_ptr_struct(args->io.spz_p5_out,&log->SPZ_P5))
		return -1;
	if(set_bit_ptr_struct(args->io.spz_wz_out,&log->WZ))
		return -1;
	if(set_bit_ptr_struct(args->io.spz_wzw_out,&log->WZW))
		return -1;
	if(set_bit_ptr_struct(args->io.wd_out,&log->WD))
		return -1;
	if(set_bit_ptr_struct(args->io.err_spz_out,&log->err_SPZ))
		return -1;
	if(set_bit_ptr_struct(args->io.spz1f_bli0_out,&log->SPZ_BlIo))
		return -1;
	if(set_bit_ptr_struct(args->io.tps_SPZ_out,&log->tps_SPZ))
		return -1;
	if(set_bit_ptr_struct(args->io.t_bzn_out,&log->t_bzn))
		return -1;

	if(set_pointer_out_ptr(args->io.wyj_ptr_out,(u32 *)&log->dw))
		return -1;


	log->nast_.SPZ_ON = (args->params.bity & 0x0001)?1:0;
	log->nast_.SPZ_s[0] = (args->params.bity & 0x0002)?1:0;
	log->nast_.SPZ_s[1] = (args->params.bity & 0x0004)?1:0;
	log->nast_.SPZ_s[2] = (args->params.bity & 0x0008)?1:0;
	log->nast_.SPZ_s[3] = (args->params.bity & 0x0010)?1:0;
	log->nast_.SPZ_s[4] = (args->params.bity & 0x0020)?1:0;
	log->nast_.SPZ_zew = (args->params.bity & 0x0040)?1:0;
	log->nast_.Bl_SCH = (args->params.bity & 0x0080)?1:0;
	log->nast_.Bl_PS[1] = log->nast_.Bl_PS[0] = (args->params.bity & 0x0100)?1:0;
	log->nast_.Bl_PS[2] = (args->params.bity & 0x0200)?1:0;
	log->nast_.Bl_PS[3] = (args->params.bity & 0x0400)?1:0;
	log->nast_.Bl_PS[4] = (args->params.bity & 0x0800)?1:0;
	log->nast_.Bl_PS[5] = (args->params.bity & 0x1000)?1:0;
	log->nast_.ZZw_ON = (args->params.bity & 0x2000)?1:0;
	log->nast_.bl_ = (args->params.bity & 0x4000)?1:0;

	log->nast_.ZdistA = log->WE_Zdist;//(R_ZdistA::Wyjscia *)wskazniki[log->nast_.adr.WE_Zdist];

	unsigned short i;
	short temp_ti;

	znast.ts1LE=args->params.ts1LE;///< Czas wyłączenia strefy 1 zwarcia jednofazowe z ziemią
	znast.ts1LL=args->params.ts1LL;///< Czas wyłączenia strefy 1 zwarcia miedzyfazowe
	znast.ts2LE=args->params.ts2LE;///< Czas wyłączenia strefy 2 zwarcia jednofazowe z ziemią
	znast.ts2LL=args->params.ts2LL;///< Czas wyłączenia strefy 2 zwarcia miedzyfazowe
	znast.ts3LE=args->params.ts3LE;///< Czas wyłączenia strefy 3 zwarcia jednofazowe z ziemią
	znast.ts3LL=args->params.ts3LL;///< Czas wyłączenia strefy 3 zwarcia miedzyfazowe
	znast.ts4LE=args->params.ts4LE;///< Czas wyłączenia strefy 4 zwarcia jednofazowe z ziemią
	znast.ts4LL=args->params.ts4LL;///< Czas wyłączenia strefy 4 zwarcia miedzyfazowe
	znast.ts5LE=args->params.ts5LE;///< Czas wyłączenia strefy 5 zwarcia jednofazowe z ziemią
	znast.ts5LL=args->params.ts5LL;///< Czas wyłączenia strefy 5 zwarcia miedzyfazowe
	znast.Stf1=args->params.Stf1;
	znast.Stf2=args->params.Stf2;
	znast.Stf3=args->params.Stf3;
	znast.Stf4=args->params.Stf4;
	znast.Stf5=args->params.Stf5;

	double *temp_tf = &znast.ts1LE;

	for (i=2;i<12;i++)
	{

		//przeliczenie czasow stref
		temp_ti = (100 * (*temp_tf - 0.005f));
		temp_tf++;
		if (temp_ti)
		{
			log->nast_.Zbz[i/2][i%2] = 0;
			log->nast_.t_stf[i/2][i%2] = temp_ti;
		} else {
			log->nast_.Zbz[i/2][i%2] = 1;
		}
		//--------------------------
	}
	log->nast_.Zbz[0][0] = 0;
	log->nast_.Zbz[0][1] = 0;
	log->nast_.t_stf[0][0] = log->nast_.t_stf[1][0];
	log->nast_.t_stf[0][1] = log->nast_.t_stf[1][1];
	//-------------------------

	log->nast_.ZZw_st = args->params.ZZw_st;

	switch(log->nast_.ZZw_st)
	{
		case 0:
			log->PZZw=log->P1W;
			log->ZZZw=log->Z1W;
			break;
		case 1:
			log->PZZw=log->P1;
			log->ZZZw=log->Z1;
			break;
		case 2:
			log->PZZw=log->P2;
			log->ZZZw=log->Z2;
			break;
		case 3:
			log->PZZw=log->P3;
			log->ZZZw=log->Z3;
			break;
		case 4:
			log->PZZw=log->P4;
			log->ZZZw=log->Z4;
			break;
		case 5:
			log->PZZw=log->P5;
			log->ZZZw=log->Z5;
			break;
		default:
			log->PZZw=log->P1W;
			log->ZZZw=log->Z1W;
			break;
	}

	long *temp_e = &znast.Stf1;

	for (i=1;i<6;i++)
	{

		//ustawienie bitow sposobu dzialania stref
		switch (*(temp_e))
		{
			case 0:
				log->nast_.Stf_ON[i] = 0;
				log->nast_.Stf_W[i] = 0;
				break;
			case 1:
				log->nast_.Stf_ON[i] = 1;
				log->nast_.Stf_W[i] = 0;
				break;
			case 2:
				log->nast_.Stf_ON[i] = 1;
				log->nast_.Stf_W[i] = 1;
				break;
		}
		temp_e++;
		log->nast_.Stf_W_SPZ[i] = log->nast_.Stf_W[i] && log->nast_.SPZ_s[i-1];
		log->nast_.Stf_WD[i] = log->nast_.Stf_W[i] && !(log->nast_.SPZ_s[i-1] && log->nast_.SPZ_ON);
		//--------------------------
	}
			log->nast_.Stf_ON[0] = log->nast_.Stf_ON[1];
			log->nast_.Stf_W[0] = log->nast_.Stf_W[1];
			log->nast_.Stf_WD[0] = 0;
			log->nast_.Stf_W_SPZ[0] = log->nast_.Stf_W_SPZ[1];
	//-------------------------

	log->nast_.SPZst1 = (enum Wylaczenie)args->params.SPZst1; //ustawienie sposobu startu SPZ

	log->nast_.tWSPZ = 1000 * args->params.tWSPZ; //nastawa dodatkowego opóźnienia wyłączenia w SPZ

	log->nast_.tSPZ_1f = (short)(100 * (args->params.tSPZ_1f + 0.005f));
	log->nast_.tSPZ_3f = (short)(100 * (args->params.tSPZ_3f + 0.005f));
	log->nast_.tSPZ_zr = (short)(100 * (args->params.tSPZ_zr + 0.005f));
	log->nast_.tSPZ_st2 = (short)(100 * (args->params.tSPZ_st2 + 0.005f));
	log->nast_.tSPZ_st3 = (short)(100 * (args->params.tSPZ_st3 + 0.005f));
	log->nast_.tSPZ_st4 = (short)(100 * (args->params.tSPZ_st4 + 0.005f));
	log->nast_.tSPZ_st5 = (short)(100 * (args->params.tSPZ_st5 + 0.005f));
	log->nast_.tSPZow = (short)(100 * (args->params.tSPZow + 0.005f));
	log->nast_.tSPZSCH = (short)(100 * (args->params.tSPZSCH + 0.005f));
	log->nast_.tSPZ_zal = (short)(100 * (args->params.tSPZ_zal + 0.005f));
	log->nast_.tSPZ_bl = (short)(100 * (args->params.tSPZCON + 0.005f));
	log->nast_.ZZw_ta = (short)(100 * (args->params.ZZw_ta + 0.005f));
	log->nast_.ZZw_to = (short)(100 * (args->params.ZZw_to + 0.005f));
	log->nast_.SPZilst = (short)(args->params.SPZilst + 0.5f);

	log->nast_.ZZw_Ir = args->params.ZZw_Ir * args->params.ZZw_Ir;
	log->nast_.ZZw_Ur = args->params.ZZw_Ur * args->params.ZZw_Ur;


	for(i=0;i<7;i++)
		log->nast_.wy.dbl_Com[i] = 1;

	log->nast_.wy.PSPZ = 0;

	if(log->WE_L1) log->nast_.COM1 = log->WE_L1; else log->nast_.COM1 = &log->nast_.wy;
	if(log->WE_L2) log->nast_.COM2 = log->WE_L2; else log->nast_.COM2 = &log->nast_.wy;

	return 0;
}

/**
Funkcja okraślania petli zwarciwej przy wyłaczeniu
\param nr_strefy - numer strefy wyłaczającej
*/
void wybiornik_f(struct ZDistL_logic *log,unsigned short nr_strefy)
{
	log->dw.R = log->nast_.ZdistA->Zdist_dw->P[nr_strefy][0]
		|| log->nast_.ZdistA->Zdist_dw->P[nr_strefy][3]
		|| log->nast_.ZdistA->Zdist_dw->P[nr_strefy][5];

	log->dw.S = log->nast_.ZdistA->Zdist_dw->P[nr_strefy][1]
		|| log->nast_.ZdistA->Zdist_dw->P[nr_strefy][3]
		|| log->nast_.ZdistA->Zdist_dw->P[nr_strefy][4];

	log->dw.T = log->nast_.ZdistA->Zdist_dw->P[nr_strefy][2]
		|| log->nast_.ZdistA->Zdist_dw->P[nr_strefy][4]
		|| log->nast_.ZdistA->Zdist_dw->P[nr_strefy][5];

	log->dw.E = log->nast_.ZdistA->Zdist_dw->Iogr;

	log->dw.jedfaz = (log->dw.R && !(log->dw.S||log->dw.T))
				|| (log->dw.S && !(log->dw.T||log->dw.R))
				|| (log->dw.T && !(log->dw.R||log->dw.S));
}

/**
Funkcja okraślania petli zwarciwej przy wyłaczeniu - działanie bezkierunkowe
\param nr_strefy - numer strefy wyłaczającej
*/
void wybiornik_fbk(struct ZDistL_logic *log, unsigned short nr_strefy)
{
	log->dw.Rbk = log->nast_.ZdistA->Zdist_dw->Pbk[nr_strefy][0]
		|| log->nast_.ZdistA->Zdist_dw->Pbk[nr_strefy][3]
		|| log->nast_.ZdistA->Zdist_dw->Pbk[nr_strefy][5];

	log->dw.Sbk = log->nast_.ZdistA->Zdist_dw->Pbk[nr_strefy][1]
		|| log->nast_.ZdistA->Zdist_dw->Pbk[nr_strefy][3]
		|| log->nast_.ZdistA->Zdist_dw->Pbk[nr_strefy][4];

	log->dw.Tbk = log->nast_.ZdistA->Zdist_dw->Pbk[nr_strefy][2]
		|| log->nast_.ZdistA->Zdist_dw->Pbk[nr_strefy][4]
		|| log->nast_.ZdistA->Zdist_dw->Pbk[nr_strefy][5];

	log->dw.E = log->nast_.ZdistA->Zdist_dw->Iogr;
}


void czy_zw_rozwojowe(struct ZDistL_logic *log)
{
	log->dw.R1 |= log->dw.R;
	log->dw.S1 |= log->dw.S;
	log->dw.T1 |= log->dw.T;

	if (
		log->dw.R1 && log->dw.S1 ||
		log->dw.S1 && log->dw.T1 ||
		log->dw.R1 && log->dw.T1
		)
	{
		log->dw.W = log->dw.W1 = log->dw.W2 = log->dw.W3 = 1;
	}
}

/**
Funkcja wykonuje wyłaczenie w zalezności od nastawy
\param wyl - tryb wylaczenia
*/
void wylacz(struct ZDistL_logic *log, enum Wylaczenie wyl)
{
	short i;

	if(!log->dw.W)
	{
			switch(wyl)
			{

				case start_jednofazowy:

					for(i=0;i<6;i++)
					{
						if (log->dw.Ws[i])
						{

							wybiornik_f(log,i);

							if(log->dw.jedfaz)
							{
								log->dw.W1 = log->dw.R;
								log->dw.W2 = log->dw.S;
								log->dw.W3 = log->dw.T;
								log->dw.blIo = 1;
								log->dw.P_SPZD = 1;
							}
							czy_zw_rozwojowe(log);
							if (log->dw.W)
								set_struct(&log->WD);
							break;

						}
					}
					break;

				case start_trojfazowy:

					for(i=0;i<6;i++)
					{
						if (log->dw.Ws[i])
						{
							log->dw.W = 1;
							wybiornik_f(log,i);
							log->dw.P_SPZD = 1;
							break;
						}
					}
					log->dw.W1 = log->dw.W2 = log->dw.W3 = log->dw.W;
					break;

				case start_kombinowany:

					for(i=0;i<6;i++)
					{
						if (log->dw.Ws[i])
						{
							log->dw.P_SPZD = 1;
							wybiornik_f(log,i);
							if(log->dw.jedfaz)
							{
								log->dw.W1 = log->dw.R;
								log->dw.W2 = log->dw.S;
								log->dw.W3 = log->dw.T;
								log->dw.blIo = 1;
							} else {
								log->dw.W1 = log->dw.W2 = log->dw.W3 = log->dw.W = 1;
							}
							czy_zw_rozwojowe(log);
							break;

						}

					}


					break;

				case wyl_definitywny:
					for(i=1;i<6;i++)
					{
						if (log->dw.Ws[i])
						{
							log->dw.W = 1;
							wybiornik_f(log,i);
							set_struct(&log->WD);
							break;
						}
					}
					log->dw.W1 = log->dw.W2 = log->dw.W3 = log->dw.W;

					break;
				default:
					break;
		}
	}
}

void ZDistL(void *arguments, void *logic)
{
	struct ZDistL_logic *log = (struct ZDistL_logic *)logic;
	unsigned short i;

		log->dw.P = 0;
		log->dw.Zz = 0;

		u8 temp_Bl,temp_Zezwolenie;
		u8 temp_b;


		if (*log->nast_.ZdistA->on)
		{
			temp_Bl = check_struct(&log->Bl_Ufail) || (check_struct(&log->stan_bl) && log->nast_.bl_);// | czy_start();

			for (i=0;i<6;i++)
			{
				if (log->nast_.Stf_ON[i]) //jesli strefa wlaczona
				{
					temp_Zezwolenie = !(temp_Bl  || (log->nast_.Bl_PS[i] && check_struct(&log->Bl_PS)));


						//obsluga wejscia testu przekaznika
					if (czy_test_R())
					{
						log->dw.Pf[i][0] = log->dw.Pf[i][1] = temp_Zezwolenie && check_struct(&log->test);
					}
					else
					{

						//ustawienie pobudzen
						log->dw.Pf[i][0] = (log->nast_.ZdistA->Zdist_dw->P[i][0] ||
													log->nast_.ZdistA->Zdist_dw->P[i][1] ||
																	log->nast_.ZdistA->Zdist_dw->P[i][2])
																		&& temp_Zezwolenie;
						log->dw.Pf[i][1] = (log->nast_.ZdistA->Zdist_dw->P[i][3] ||
													log->nast_.ZdistA->Zdist_dw->P[i][4] ||
																	log->nast_.ZdistA->Zdist_dw->P[i][5])
																		&& temp_Zezwolenie;
					}
					log->dw.Pzf[i] = log->dw.Pf[i][0] || log->dw.Pf[i][1];

					//ustawienie zadzialan jesli bezzwloczny
					if (log->nast_.Zbz[i][0])
					{
						log->dw.Zf[i][0] = log->dw.Pf[i][0];
					}
					if (log->nast_.Zbz[i][1])
					{
						log->dw.Zf[i][1] = log->dw.Pf[i][1];
					}
					//ustawienie zadzialania strefy
					log->dw.Z[i] = log->dw.Zf[i][0] || log->dw.Zf[i][1];
					log->dw.Ws[i] = log->dw.Z[i] && log->nast_.Stf_WD[i];


				} else {
					log->dw.Pzf[i] = 0;
					log->dw.Z[i] = 0;
				}

				log->dw.P |= log->dw.Pzf[i];
				log->dw.Zz |= log->dw.Z[i]; //zadzialanie zabezpieczenia
			}


			wylacz(log,wyl_definitywny);



			//-------------------------------------------------------------------------------------------------------
			//automatyka załaczenia na zwarcie

			if (check_struct(&log->Z))
			{
				log->dw.ZZw |= 1;
			}

			if (log->dw.ZZw && log->nast_.ZZw_ON) //jeseli jest właczony i jest spełnione kryterium załączenia na zwarcie
			{
				wybiornik_fbk(log,log->nast_.ZZw_st);

				log->dw.bl_WSPZ = 1;

				if (log->dw.Rbk || log->dw.Sbk || log->dw.Tbk)
				{
					log->dw.W |= 1;
					set_struct(&log->WD);
					log->dw.ZZwP = 1;
				} else log->dw.ZZwP = 0;
				log->dw.W1 = log->dw.W2 = log->dw.W3 = log->dw.W;

			} else {
				log->dw.Rbk = log->dw.Sbk = log->dw.Tbk = 0;
				log->dw.ZZwP = 0;
			}

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


			if(log->nast_.SPZ_ON && !log->dw.bl_WSPZ && log->dw.dBl_SPZ) // obsluga wylaczenia z automatyka SPZ
			{
				///sprawdzenie wyłączenia w cyklu SPZ
				temp_b = 0;
				i=0;
				while(!temp_b && i < 6)
				{
					temp_b = log->dw.Pzf[i] && log->nast_.Stf_W_SPZ[i]
									&& log->nast_.COM1->dbl_Com[i] && log->nast_.COM2->dbl_Com[i]; // czy jest pobudzenie w cyklu SPZ
					i++;
				}

				i--;


				if (temp_b) //odliczenie czasu dodatkowego opóźnienia wyłączenia w przypadku SPZ
				{
					log->dw.licz_WSPZ--;
				} else {
					log->dw.licz_WSPZ = log->nast_.tWSPZ;
				}



				if (log->dw.licz_WSPZ<0) //po doliczeniu czasu jest wyłączenie w cyklu SPZ
				{
					log->dw.licz_WSPZ++;


						log->dw.Z[i] = 1;
						log->dw.Ws[i] = 1;

						if (log->dw.bl_SPZ1)
						{
							wylacz(log,start_trojfazowy);
						} else {
							wylacz(log,log->nast_.SPZst1);
						}


				}
			}  else {
				for(i=1;i<6;i++)
				{
					log->dw.Ws[i] = log->dw.Z[i] && log->nast_.Stf_W[i];
				}
				wylacz(log,wyl_definitywny);
			}

			//jeśli nie ma SPZ to wyłączenie trójfazowe definitywne




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

			//wyprowadzenie wyjść
			check_and_set_struct(log->dw.P,&log->P);
			check_and_set_struct(log->dw.Pzf[0],&log->P1W);
			check_and_set_struct(log->dw.Pzf[1],&log->P1);
			check_and_set_struct(log->dw.Pzf[2],&log->P2);
			check_and_set_struct(log->dw.Pzf[3],&log->P3);
			check_and_set_struct(log->dw.Pzf[4],&log->P4);
			check_and_set_struct(log->dw.Pzf[5],&log->P5);

			check_and_set_struct(log->dw.Z[0],&log->Z1W);
			check_and_set_struct(log->dw.Z[1],&log->Z1);
			check_and_set_struct(log->dw.Z[2],&log->Z2);
			check_and_set_struct(log->dw.Z[3],&log->Z3);
			check_and_set_struct(log->dw.Z[4],&log->Z4);
			check_and_set_struct(log->dw.Z[5],&log->Z5);

			check_and_set_struct(log->dw.R || log->dw.Rbk,&log->R);
			check_and_set_struct(log->dw.S || log->dw.Sbk,&log->S);
			check_and_set_struct(log->dw.T || log->dw.Tbk,&log->T);
			check_and_set_struct(log->dw.E,&log->E);

			check_and_set_struct(log->dw.W,&log->W);
			check_and_set_struct(log->dw.W1,&log->W1);
			check_and_set_struct(log->dw.W2,&log->W2);
			check_and_set_struct(log->dw.W3,&log->W3);

			check_and_set_struct(log->dw.blIo,&log->SPZ_BlIo);

			if(log->dw.ZZwP)
			{
				set_struct(&log->ZZZw);
				set_struct(&log->PZZw);
			}
		} else {
			clear_struct(&log->P);
			clear_struct(&log->P1W);
			clear_struct(&log->P1);
			clear_struct(&log->P2);
			clear_struct(&log->P3);
			clear_struct(&log->P4);
			clear_struct(&log->P5);
			clear_struct(&log->Z1W);
			clear_struct(&log->Z1);
			clear_struct(&log->Z2);
			clear_struct(&log->Z3);
			clear_struct(&log->Z4);
			clear_struct(&log->Z5);
			clear_struct(&log->R);
			clear_struct(&log->S);
			clear_struct(&log->T);
			clear_struct(&log->E);
			clear_struct(&log->W);
			clear_struct(&log->W1);
			clear_struct(&log->W2);
			clear_struct(&log->W3);
			clear_struct(&log->SPZ_BlIo);
		}
}

void ZDistL_100hz(void *arguments, void *logic)
{
	struct ZDistL_logic *log = (struct ZDistL_logic *)logic;
	unsigned short i;
	u8 tempbool = 0;
	u8 Pob_zew;
	unsigned short temp = 0;

		if (*log->nast_.ZdistA->on)
		{

			//wczytanie danych o stanie wyłącznika
			log->dw.W1_ON = check_struct(&log->W_ON_L1) && !check_struct(&log->W_OFF_L1);
			log->dw.W2_ON = check_struct(&log->W_ON_L2) && !check_struct(&log->W_OFF_L2);
			log->dw.W3_ON = check_struct(&log->W_ON_L3) && !check_struct(&log->W_OFF_L3);
			log->dw.W_ON = log->dw.W1_ON && log->dw.W2_ON && log->dw.W3_ON;
			log->dw.W1_OFF = !check_struct(&log->W_ON_L1) && check_struct(&log->W_OFF_L1);
			log->dw.W2_OFF = !check_struct(&log->W_ON_L2) && check_struct(&log->W_OFF_L2);
			log->dw.W3_OFF = !check_struct(&log->W_ON_L3) && check_struct(&log->W_OFF_L3);
			log->dw.W_OFF = log->dw.W1_OFF && log->dw.W2_OFF && log->dw.W3_OFF;
			log->dw.dBl_SPZ = !check_struct(&log->BL_SPZ);
			log->dw.bl_SPZ_SCH = (log->nast_.Bl_SCH && check_struct(&log->Bl_SCH)) || !check_struct(&log->WM_OK);



			for (i=1;i<6;i++)
			{

				//realizacja przekaznikow czasowych
				if (log->nast_.Stf_ON[i]) //jesli strefa wlaczona
				{

					if (log->dw.Pf[i][0])
					{
						if(!log->nast_.Zbz[i][0]) // jesli nie bezzwloczny
						{
							if (!log->dw.liczts[i][0])
							{
								log->dw.Zf[i][0] = 1;
								log->dw.liczts[i][0]++;
							}
							log->dw.liczts[i][0]--;

						}

					}
					else//wylaczenie zadzialania (odpad)
					{
						log->dw.liczts[i][0] = log->nast_.t_stf[i][0];
						log->dw.Zf[i][0] = 0;
					}
					if (log->dw.Pf[i][1])
					{
						if(!log->nast_.Zbz[i][1]) // jesli nie bezzwloczny
						{
							if (!log->dw.liczts[i][1])
							{
								log->dw.Zf[i][1] = 1;
								log->dw.liczts[i][1]++;
							}
							log->dw.liczts[i][1]--;
						}
					}
					else//wylaczenie zadzialania (odpad)
					{
						log->dw.liczts[i][1] = log->nast_.t_stf[i][1];
						log->dw.Zf[i][1] = 0;
					}

				}
				//-----------------------------------------------------------
			}

			Pob_zew = log->nast_.COM1->PSPZ || log->nast_.COM2->PSPZ || (log->nast_.SPZ_zew && check_struct(&log->Start_SPZ));
			log->dw.P_SPZ = log->dw.dBl_SPZ && (log->dw.P_SPZD || Pob_zew); //pobudzenie SPZ
			log->dw.W_1faz = !log->dw.W && log->dw.P_SPZD;
			log->dw.P_SPZD = 0;

			//obsługa sygnalizacji wyłączenia definitywnego
			if (log->nast_.SPZ_ON)
			{
				if (log->dw.stan_SPZ==0)
				{
					if(log->dw.WD && log->dw.W_OFF)
						set_struct(&log->WD);
					log->dw.WD = 0;
				}
			} else {
				if(log->dw.W)
					set_struct(&log->WD);
			}
			//

			switch(log->dw.stan_SPZ) //w zaleznosci od polozenia w cyklu SPZ
				{
					case 0: //oczekiwanie
						log->dw.bl_WSPZ = 0;
						if (log->dw.P_SPZ & log->dw.W_ON & log->nast_.SPZ_ON) //jezeli pobudzenie spz to start cyklu
						{

							if(log->dw.W_1faz) log->dw.stan_SPZ = 100; // jesli wyłączenie jednofazowe
							else log->dw.stan_SPZ = 1;//jesli wyłaczenie trójfazowe
							set_struct(&log->P_SPZ);  // pobudzenie spz
							// skasowanie sygnalizacji z poprzedniego dzialania
								log->dw.WZ =  0;
								log->dw.WZW =  0;
								log->dw.WD = 1;
								clear_struct(&log->SPZ_P1);
								clear_struct(&log->SPZ_P2);
								clear_struct(&log->SPZ_P3);
								clear_struct(&log->SPZ_P4);
								clear_struct(&log->SPZ_P5);
								clear_struct(&log->err_SPZ);
								clear_struct(&log->WD);
								//
								log->dw.licznik_SPZ = log->nast_.tSPZow;

						} else {
							if (check_struct(&log->Kas_Syg))    // skasowanie sygnalizacji z ostatniego cyklu
							{
								log->dw.WZ =  0;
								log->dw.WZW =  0;
								clear_struct(&log->SPZ_P1);
								clear_struct(&log->SPZ_P2);
								clear_struct(&log->SPZ_P3);
								clear_struct(&log->SPZ_P4);
								clear_struct(&log->SPZ_P5);
								clear_struct(&log->err_SPZ);
								clear_struct(&log->WD);
							}
							clear_struct(&log->P_SPZ);
							log->dw.R1 = log->dw.S1 = log->dw.T1 = 0;
						}

						log->dw.bl_SPZ1 = 0;

						break;

					case 17:    //wylacz_5:
						temp++;
					case 13:    //wylacz_4:
						temp++;
					case 9: //wylacz_3:
						temp++;
					case 5: //wylacz_2:
						temp++;
					case 1: //wyłącz trójfazowy stopień 1

						if (log->dw.W_OFF &&
							!check_struct(&log->P))
						{
							log->dw.licznik_SPZ = *((short *)&log->nast_.tSPZ_3f + temp); //ustawienie czasu przerwy beznapieciowej
							log->dw.stan_SPZ += 1;

							log->dw.licznik_bl_SCH = log->nast_.tSPZSCH;//ustawienie czasu oczekiwania na synchronizm
							set_struct(&log->tps_SPZ);
						} else {
							log->dw.licznik_SPZ--;
							if (!log->dw.licznik_SPZ)   // jesli brak otwarcia wylacznika
							{
								log->dw.stan_SPZ = 22;  //SPZ_error
								log->dw.licznik_SPZ = log->nast_.tSPZ_bl;
								set_struct(&log->err_SPZ);
							}
						}
						break;

					case 100://wyłącz jednofazowy stopień 1

						if (log->dw.W) // jesli jednak wyłaczenie trojfazowe
						{
							if(log->nast_.SPZst1==start_jednofazowy)
							{
								log->dw.stan_SPZ = 22;
								log->dw.licznik_SPZ = log->nast_.tSPZ_bl;
								set_struct(&log->tps_SPZ);
								set_struct(&log->WD);
							}
							else log->dw.stan_SPZ = 1;

						} else { // jesli wyłączenie jednofazowe

							if ((log->dw.jedfaz && ((log->dw.R && log->dw.W1_OFF) || (log->dw.S && log->dw.W2_OFF) || (log->dw.T && log->dw.W3_OFF))))
							{
								log->dw.licznik_SPZ = log->nast_.tSPZ_1f; //ustawienie czasu przerwy beznapieciowej
								log->dw.licznik_bl_SCH = log->nast_.tSPZSCH;//ustawienie czasu oczekiwania na synchronizm
								log->dw.stan_SPZ = 102;
								set_struct(&log->tps_SPZ);
							} else {
								log->dw.licznik_SPZ--;
								if (!log->dw.licznik_SPZ)   // jesli brak otwarcia wylacznika
								{
									log->dw.stan_SPZ = 22;  //SPZ_error
									log->dw.licznik_SPZ = log->nast_.tSPZ_bl;
									set_struct(&log->err_SPZ);
								}
							}
						}

						break;

					case 18:    //czas_przerwy_5:
						temp++;
					case 14:    //czas_przerwy_4:
						temp++;
					case 10:    //czas_przerwy_3:
						temp++;
					case 6: //czas_przerwy_2:
						temp++;
					case 2: //czas_przerwy_1: // odliczanie czasu przerwy beznapieciowej

						log->dw.licznik_SPZ--;

						if (!log->dw.licznik_SPZ) // jesli odliczono czas przerwy beznapieciowej
						{
							log->dw.licznik_SPZ++;
							log->dw.licznik1 = log->nast_.tSPZow;
							set_struct(&log->tps_SPZ);
							clear_struct(&log->t_bzn);
							if (check_struct(&log->BL_SPZ))
							{
								log->dw.stan_SPZ = 22;    // jesli jest wlaczona blokada SPZ to koniec cyklu
								set_struct(&log->err_SPZ);
								log->dw.licznik_SPZ = log->nast_.tSPZ_bl;
							} else {
								if(log->dw.bl_SPZ_SCH) //jesli jest blokada od kontroli synchronizmu lub brak gotowosci napędu
								{
									log->dw.licznik_bl_SCH--;
									if(!log->dw.licznik_bl_SCH) // jeśli nie doczekano sie zezwolenia na załącz od synchronizmu
									{
										log->dw.stan_SPZ = 22;    // error i koniec cyklu
										set_struct(&log->err_SPZ);
										log->dw.licznik_SPZ = log->nast_.tSPZ_bl;
									}
								}else{
									log->dw.stan_SPZ += 1;
									    // wystawienie zalaczenia
									set_struct(&log->zal);
									log->dw.licznik2 = log->nast_.tSPZ_zal;
									switch(temp)
									{
									case 0:
										set_struct(&log->SPZ_P1);
										break;
									case 1:
										set_struct(&log->SPZ_P2);
										break;
									case 2:
										set_struct(&log->SPZ_P3);
										break;
									case 3:
										set_struct(&log->SPZ_P4);
										break;
									case 4:
										set_struct(&log->SPZ_P5);
										break;
									default:
										set_struct(&log->SPZ_P1);
										break;
									}

									log->dw.licznik_SPZ = log->nast_.tSPZ_bl;
								}
							}
						}
						break;

					case 102:

						log->dw.licznik_SPZ--;
						if(log->dw.W) // przerwanie cyklu jednofazowego SPZ
						{
							log->dw.licznik_SPZ = log->nast_.tSPZow;
							log->dw.stan_SPZ = 103;
						}else{
							if (!log->dw.licznik_SPZ) // jesli odliczono czas przerwy beznapieciowej
							{
								log->dw.licznik_SPZ++;
								log->dw.licznik1 = log->nast_.tSPZow;

								set_struct(&log->tps_SPZ);
								clear_struct(&log->t_bzn);

								if (check_struct(&log->BL_SPZ))
								{
									log->dw.stan_SPZ = 22;    // jesli jest wlaczona blokada SPZ to koniec cyklu
									set_struct(&log->err_SPZ);
									log->dw.licznik_SPZ = log->nast_.tSPZ_bl;
								} else {
									if(log->dw.bl_SPZ_SCH) //jesli jest blokada od kontroli synchronizmu lub brak gotowosci napedu
									{
										log->dw.licznik_bl_SCH--;
										if(!log->dw.licznik_bl_SCH) // jeśli nie doczekano sie zezwolenia na załącz od synchronizmu
										{
											log->dw.stan_SPZ = 22;    // error i koniec cyklu
											set_struct(&log->err_SPZ);
											log->dw.licznik_SPZ = log->nast_.tSPZ_bl;
										}
									}else{
										log->dw.stan_SPZ = 3;
										set_struct(&log->zal);
										    // wystawienie zalaczenia
										log->dw.licznik2 = log->nast_.tSPZ_zal;
										set_struct(&log->SPZ_P1);
										log->dw.licznik_SPZ = log->nast_.tSPZ_bl;
									}
								}
							}
						}
						break;

					case 103: //przerwanie cyklu SPZ - zwarcie rozwojowe
						if (log->dw.W_OFF &&
							!check_struct(&log->P))
						{
							log->dw.licznik_SPZ = log->nast_.tSPZ_zr; //ustawienie czasu przerwy beznapieciowej dla zwarcia rozwojowego
							if(log->nast_.SPZst1==start_jednofazowy) //jesli start jednofazowy to blokada SPZ
							{
								log->dw.stan_SPZ = 22;
								log->dw.licznik_SPZ = log->nast_.tSPZ_bl;
								set_struct(&log->tps_SPZ);
								set_struct(&log->WD);
							} else {
								log->dw.stan_SPZ = 2;
							}
							log->dw.licznik_bl_SCH = log->nast_.tSPZSCH;//ustawienie czasu oczekiwania na synchronizm
						} else {
							log->dw.licznik_SPZ--;
							if (!log->dw.licznik_SPZ)   // jesli brak otwarcia wylacznika
							{
								log->dw.stan_SPZ = 22;  //SPZ_error
								log->dw.licznik_SPZ = log->nast_.tSPZ_bl;
								set_struct(&log->err_SPZ);
							}
						}

						break;

					case 19:    //zalacz_5:
					case 15:    //zalacz_4:
					case 11:    //zalacz_3:
					case 7: //zalacz_2:
					case 3: //zalacz_1:  // oczekiwanie na odpowiedz wylacznika
						log->dw.bl_SPZ1 = 1;
						log->dw.licznik_SPZ--;
						log->dw.licznik1--;
						log->dw.licznik2--;
						if (!log->dw.licznik2) clear_struct(&log->zal); //wyłączenie impulsu załączającego po odliczeniu nastawionego czasu
						if (log->dw.W_ON)   // jesli wylacznik zamknąl sie
						{
							log->dw.stan_SPZ += 1;
							clear_struct(&log->zal);
							log->dw.licznik_SPZ = log->nast_.tSPZ_bl;
						}
						if ((!log->dw.licznik_SPZ) || check_struct(&log->P) && (!log->dw.licznik1))    // jezeli przed informacja o zamknieciu wylacznika przyszedl sygnal wylacz, lub wylacznik sie nie zamknal
						{
							log->dw.licznik_SPZ = log->nast_.tSPZ_bl;
							log->dw.stan_SPZ = 22;    // jesli jest wlaczona blokada SPZ to koniec cyklu
							set_struct(&log->err_SPZ);
							clear_struct(&log->zal);
						}
						break;

					case 20:    //odwzbudzenie_5:
					case 16:    //odwzbudzenie_4:
					case 12:    //odwzbudzenie_3:
					case 8: //odwzbudzenie_2:
					case 4: //odwzbudzenie_1: // odliczanie czasu odwzbudzenia po wyslaniu sygnalu zalacz
						log->dw.bl_WSPZ = log->nast_.SPZilst < (log->dw.stan_SPZ / 4);
						log->dw.licznik_SPZ--;
						if (log->dw.P_SPZ)          // jesli ponownie pobudzenie przed wybiegnieciem czasu blokady spz
						{
							log->dw.WZ =  0;
							log->dw.WZW = 1;

							if ((log->nast_.SPZilst > (log->dw.stan_SPZ / 4)) & (log->nast_.SPZst1!=start_jednofazowy))    // przejscie do nastepnej proby w cyklu
							{
								log->dw.stan_SPZ += 1;
								log->dw.licznik_SPZ = log->nast_.tSPZow;
							} else {    // wylaczenie definitywne
								log->dw.stan_SPZ = 21;  //koniec_cyklu
							}
						} else {    // jeżeeli nie to koniec cyklu
							if(!log->dw.licznik_SPZ)
							{
								if(log->dw.W_ON)
								{
									log->dw.WZ = 1;
									log->dw.WZW =  0;
								} else {
									log->dw.WZ = 0;
									log->dw.WZW =  1;
								}
								log->dw.stan_SPZ = 0;   //oczekiwanie;
								clear_struct(&log->tps_SPZ);
							}
						}
						break;

					case 21:    //koniec_cyklu:
						log->dw.licznik_SPZ--;
						if (!log->dw.licznik_SPZ)
						{
							log->dw.stan_SPZ = 0;   //oczekiwanie;
							clear_struct(&log->tps_SPZ);
						}
						break;

					case 22:    //SPZ_error:
						log->dw.licznik_SPZ--;
						if(log->dw.licznik_SPZ)
						{
							set_struct(&log->tps_SPZ);
						} else {
							log->dw.stan_SPZ = 0;   //oczekiwanie;
							clear_struct(&log->tps_SPZ);

						}

						break;
					default:
						log->dw.stan_SPZ = 0;
						break;
				}


			if (!check_struct(&log->tps_SPZ))
			{
				check_and_set_struct(log->dw.WZ,&log->WZ);
				check_and_set_struct(log->dw.WZW,&log->WZW);
			}


			//odpad wyłaczeń



			for(i=0;i<6;i++)
			{
				tempbool |= log->dw.Ws[i];
			}
			if (!tempbool) log->dw.W = log->dw.W1 = log->dw.W2 = log->dw.W3 = log->dw.R = log->dw.S = log->dw.T = log->dw.E = 0;


			//zdjęcie blokady zabezpieczenia zeimnozwarciowego od jednofazowego SPZ

			if (log->dw.W1_ON && log->dw.W2_ON && log->dw.W3_ON) log->dw.blIo = 0;


			//automatyka załaczenia na zwarcie - identyfikacja stanu załączenia na zwarcie

			//właczenie od otwarcia wyłącznika

			tempbool = 	(log->nast_.ZdistA->Zdist_dw->I1<log->nast_.ZZw_Ir) &&
						(log->nast_.ZdistA->Zdist_dw->I2<log->nast_.ZZw_Ir) &&
						(log->nast_.ZdistA->Zdist_dw->I3<log->nast_.ZZw_Ir) &&
						(log->nast_.ZdistA->Zdist_dw->U1<log->nast_.ZZw_Ur) &&
						(log->nast_.ZdistA->Zdist_dw->U2<log->nast_.ZZw_Ur) &&
						(log->nast_.ZdistA->Zdist_dw->U3<log->nast_.ZZw_Ur);

			sprawdz_P(&log->dw.ZZw_PIU,tempbool,!tempbool,&log->dw.licznik_PIU,log->nast_.ZZw_to,2);

			log->dw.ZZw_start = log->dw.ZZw_PIU || //włączenie ZZw jeśli brak napięcia i prądu
							check_struct(&log->Z) || //włączenie ZZw jeśli aktywny sygnał zamknięcia wyłącznika
							(log->dw.W_OFF & !check_struct(&log->P_SPZ)); //włączenie ZZw jeśli otwarte styki i nie ma cyklu SPZ

			log->dw.ZZw |= log->dw.ZZw_start;
			if(log->dw.ZZw_start)
			{
				log->dw.licznik_ZZwa = 0;
			} else {
				log->dw.licznik_ZZwa++;
				if(log->dw.licznik_ZZwa>log->nast_.ZZw_ta)
				{
					if (!log->dw.ZZwP) log->dw.ZZw = 0;
					log->dw.licznik_ZZwa--;
				}
			}


			///

				// realizacja rejestratora parametrow ostatniego zaklocenia
					switch(status_rej)
					{
						case oczekiwanie:
							if (log->dw.P)
							{
								log->dw.dl_ = 0; // start odliczania czasu dlugosci trwania zaklocenia
								status_rej = sledzenie;
							}
							break;
						case sledzenie:
							if (log->dw.W1 || log->dw.W2 || log->dw.W3)
							{
								status_rej = sledzenie_zad;
								if (log->dw.Ws[0] || log->dw.Ws[1])
								{
									log->dw.RL1Em = log->nast_.ZdistA->Zdist_dw->Z.R[0];
									log->dw.RL2Em = log->nast_.ZdistA->Zdist_dw->Z.R[1];
									log->dw.RL3Em = log->nast_.ZdistA->Zdist_dw->Z.R[2];
									log->dw.XL1Em = log->nast_.ZdistA->Zdist_dw->Z.X[0];
									log->dw.XL2Em = log->nast_.ZdistA->Zdist_dw->Z.X[1];
									log->dw.XL3Em = log->nast_.ZdistA->Zdist_dw->Z.X[2];
								} else {
									log->dw.RL1Em = log->nast_.ZdistA->Zdist_dw->Z.R[3];
									log->dw.RL2Em = log->nast_.ZdistA->Zdist_dw->Z.R[4];
									log->dw.RL3Em = log->nast_.ZdistA->Zdist_dw->Z.R[5];
									log->dw.XL1Em = log->nast_.ZdistA->Zdist_dw->Z.X[3];
									log->dw.XL2Em = log->nast_.ZdistA->Zdist_dw->Z.X[4];
									log->dw.XL3Em = log->nast_.ZdistA->Zdist_dw->Z.X[5];
								}
								log->dw.RL1L2m = log->nast_.ZdistA->Zdist_dw->Z.R[6];
								log->dw.RL2L3m = log->nast_.ZdistA->Zdist_dw->Z.R[7];
								log->dw.RL3L1m = log->nast_.ZdistA->Zdist_dw->Z.R[8];
								log->dw.XL1L2m = log->nast_.ZdistA->Zdist_dw->Z.X[6];
								log->dw.XL2L3m = log->nast_.ZdistA->Zdist_dw->Z.X[7];
								log->dw.XL3L1m = log->nast_.ZdistA->Zdist_dw->Z.X[8];

			//					log->dw.czas_ = time; // zapisanie do bufora tymczasowego czasu wyslania impulsu wylacz dla rejestracji
							}
							if (log->dw.P)
							{
								log->dw.dl_++;
							} else {
								status_rej = oczekiwanie;
							}
							break;
						case sledzenie_zad:
							if (!log->dw.P)
							{
								log->dw.wsk_rej = 1; // zapamietanie faktu powstania zaklocenia z wylaczeniem
								status_rej = zapis;
							} else {
								log->dw.dl_++;
							}
							break;
						case zapis:
							if (!log->dw.wsk_rej)
							{
								status_rej = oczekiwanie;
							}
							break;
					}

		} else {
			clear_struct(&log->SPZ_P1);
			clear_struct(&log->SPZ_P2);
			clear_struct(&log->SPZ_P3);
			clear_struct(&log->SPZ_P4);
			clear_struct(&log->SPZ_P5);
			clear_struct(&log->err_SPZ);
			clear_struct(&log->WZ);
			clear_struct(&log->WZW);
			clear_struct(&log->WD);
			clear_struct(&log->zal);
			clear_struct(&log->P_SPZ);
			clear_struct(&log->tps_SPZ);
			clear_struct(&log->t_bzn);
		}
}
