/*
 * spz_3f_2.c
 *
 *  Created on: 05-01-2024
 *      Author: PS
 */

#include <math.h>

//#include "pawel_usun_to.h"
#include "spz_3f_2.h"

#include "helper.h"
#include "config.h"

int spz_3f_2_initlog(void *arguments, void *logic)
{
	struct spz_3f_2_args *args = (struct spz_3f_2_args *)arguments;
	struct spz_3f_2_logic *log = (struct spz_3f_2_logic *)logic;

	if(set_bit_ptr_mask(args->io.Pob_in,&log->Pob,&log->Pob_bit_mask))
		return -1;
	if(set_bit_ptr_mask(args->io.Blokada_in,&log->Blokada,&log->Blokada_bit_mask))
		return -1;
	if(set_bit_ptr_mask(args->io.W1_ON_in,&log->W1_ON,&log->W1_ON_bit_mask))
		return -1;
	if(set_bit_ptr_mask(args->io.W2_ON_in,&log->W2_ON,&log->W2_ON_bit_mask))
		return -1;
	if(set_bit_ptr_mask(args->io.W3_ON_in,&log->W3_ON,&log->W3_ON_bit_mask))
		return -1;
	if(set_bit_ptr_mask(args->io.WYL_1_in,&log->WYL_1,&log->WYL_1_bit_mask))
		return -1;
	if(set_bit_ptr_mask(args->io.WYL_2_in,&log->WYL_2,&log->WYL_2_bit_mask))
		return -1;
	if(set_bit_ptr_mask(args->io.WYL_3_in,&log->WYL_3,&log->WYL_3_bit_mask))
		return -1;
	if(set_bit_ptr_mask(args->io.FAZ_1_in,&log->FAZ_1,&log->FAZ_1_bit_mask))
		return -1;
	if(set_bit_ptr_mask(args->io.FAZ_3_in,&log->FAZ_3,&log->FAZ_3_bit_mask))
		return -1;
	if(set_bit_ptr_mask(args->io.kasowanie_in,&log->kasowanie,&log->kasowanie_bit_mask))
		return -1;
	if(set_bit_ptr_mask(args->io.gotowosc_in,&log->gotowosc,&log->gotowosc_bit_mask))
		return -1;
	if(set_bit_ptr_mask(args->io.wydluzenie_in,&log->wydluzenie_we,&log->wydluzenie_we_bit_mask))
		return -1;	
	if(set_bit_ptr_mask(args->io.sck_in,&log->sck_we,&log->sck_we_bit_mask))
		return -1;			
	if(set_bit_ptr_mask(args->io.master_slave_in,&log->master_slave,&log->master_slave_bit_mask))
		return -1;		
	if(set_bit_ptr_mask(args->io.wyl_2_in,&log->wyl_2,&log->wyl_2_bit_mask))
		return -1;	
	if(set_bit_ptr_mask(args->io.we_zal_slave_in,&log->we_zal_slave,&log->we_zal_slave_bit_mask))
		return -1;		
	if(set_bit_ptr_mask(args->io.zal_in,&log->we_zal,&log->we_zal_bit_mask))
		return -1;		
	if(set_bit_ptr_mask(args->io.przysp_in,&log->we_przysp,&log->we_przysp_bit_mask))
		return -1;		
		
	if(set_bit_ptr_mask(args->io.wy_pob_out,&log->wy_pob,&log->wy_pob_bit_mask))
		return -1;
	if(set_bit_ptr_mask(args->io.Z_out,&log->Z,&log->Z_bit_mask))
		return -1;
	if(set_bit_ptr_mask(args->io.ZGODA_1F_out,&log->ZGODA_1F,&log->ZGODA_1F_bit_mask))
		return -1;
	if(set_bit_ptr_mask(args->io.t_akcji_out,&log->t_akcji,&log->t_akcji_bit_mask))
		return -1;
	if(set_bit_ptr_mask(args->io.t_o_out,&log->t_o,&log->t_o_bit_mask))
		return -1;
	if(set_bit_ptr_mask(args->io.t_prz_bez_out,&log->t_prz_bez,&log->t_prz_bez_bit_mask))
		return -1;
	if(set_bit_ptr_mask(args->io.t_blokady_out,&log->t_blokady,&log->t_blokady_bit_mask))
		return -1;
	if(set_bit_ptr_mask(args->io.proba1_out,&log->proba1,&log->proba1_bit_mask))
		return -1;
	if(set_bit_ptr_mask(args->io.proba2_out,&log->proba2,&log->proba2_bit_mask))
		return -1;
	if(set_bit_ptr_mask(args->io.proba3_out,&log->proba3,&log->proba3_bit_mask))
		return -1;
	if(set_bit_ptr_mask(args->io.proba4_out,&log->proba4,&log->proba4_bit_mask))
		return -1;
	if(set_bit_ptr_mask(args->io.proba5_out,&log->proba5,&log->proba5_bit_mask))
		return -1;
	if(set_bit_ptr_mask(args->io.proba6_out,&log->proba6,&log->proba6_bit_mask))
		return -1;
	if(set_bit_ptr_mask(args->io.proba7_out,&log->proba7,&log->proba7_bit_mask))
		return -1;
	if(set_bit_ptr_mask(args->io.proba8_out,&log->proba8,&log->proba8_bit_mask))
		return -1;
	if(set_bit_ptr_mask(args->io.udany_out,&log->udany,&log->udany_bit_mask))
		return -1;
	if(set_bit_ptr_mask(args->io.nieudany_out,&log->nieudany,&log->nieudany_bit_mask))
		return -1;
	if(set_bit_ptr_mask(args->io.rozwojowe_out,&log->rozwojowe,&log->rozwojowe_bit_mask))
		return -1;
	if(set_bit_ptr_mask(args->io.wy_blokady_out,&log->wy_blokady,&log->wy_blokady_bit_mask))
		return -1;
	if(set_bit_ptr_mask(args->io.error_out,&log->error,&log->error_bit_mask))
		return -1;
	if(set_bit_ptr_mask(args->io.brak_SCK_out,&log->brakSCK,&log->brak_SCK_bit_mask))
		return -1;
	if(set_bit_ptr_mask(args->io.niegotowy_out,&log->niegotowy,&log->niegotowy_bit_mask))
		return -1;
	if(set_bit_ptr_mask(args->io.zal_zw_out,&log->zal_zw,&log->zal_zw_bit_mask))
		return -1;
	if(set_bit_ptr_mask(args->io.wy_zal_slave_out,&log->wy_zal_slave,&log->wy_zal_slave_bit_mask))
		return -1;
	if(set_bit_ptr_mask(args->io.wy_jest_slave_out,&log->wy_jest_slave,&log->wy_jest_slave_bit_mask))
		return -1;	
	if(set_bit_ptr_mask(args->io.wy_jest_master_out,&log->wy_jest_master,&log->wy_jest_master_bit_mask))
		return -1;		
	if(set_bit_ptr_mask(args->io.wy_czek_na_master,&log->wy_czek_na_master,&log->wy_czek_na_master_bit_mask))
		return -1;			
	if(set_bit_ptr_mask(args->io.wy_czek_na_sck,&log->wy_czek_na_SCK,&log->wy_czek_na_SCK_bit_mask))
		return -1;
	if(set_bit_ptr_mask(args->io.t_prz_bez_1f_out,&log->t_prz_bez_1f,&log->t_prz_bez_1f_bit_mask))
		return -1;


	log->nast_.SPZ_on = (args->params.bity & 0x0001) ? 1: 0;
	log->nast_.ZW_rozw = ((args->params.bity & 0x0002) != 0) ? 1 : 0;
	log->nast_.Blok_nieudany = ((args->params.bity & 0x0004) != 0) ? 1 : 0;
	log->nast_.kontr_pocz = ((args->params.bity & 0x0008) != 0) ? 1 : 0;
	log->nast_.kontr_kon = ((args->params.bity & 0x0010) != 0) ? 1 : 0;
	log->nast_.zal_zw_bit = ((args->params.bity & 0x0020) != 0) ? 1 : 0;
	log->nast_.master_slave_on = ((args->params.bity & 0x0040) != 0) ? 1 : 0;
	log->nast_.zal_zw_kryt_W = ((args->params.bity & 0x0080) != 0) ? 1 : 0;

	log->nast_.licz_p = (u8)args->params.licz_p;
	log->nast_.t[0] = (u16)((args->params.t1) * 1000);  // wyliczenie ilosci petli dla odliczenia czasu prerwy beznapieciowej 1
	log->nast_.t[1] = (u16)((args->params.t2) * 1000);  // wyliczenie ilosci petli dla odliczenia czasu prerwy beznapieciowej 2
	log->nast_.t[2] = (u16)((args->params.t3) * 1000);  // wyliczenie ilosci petli dla odliczenia czasu prerwy beznapieciowej 3
	log->nast_.t[3] = (u16)((args->params.t4) * 1000);  // wyliczenie ilosci petli dla odliczenia czasu prerwy beznapieciowej 4
	log->nast_.t[4] = (u16)((args->params.t5) * 1000);  // wyliczenie ilosci petli dla odliczenia czasu prerwy beznapieciowej 5
	log->nast_.t[5] = (u16)((args->params.t6) * 1000);  // wyliczenie ilosci petli dla odliczenia czasu prerwy beznapieciowej 5
	log->nast_.t[6] = (u16)((args->params.t7) * 1000);  // wyliczenie ilosci petli dla odliczenia czasu prerwy beznapieciowej 5
	log->nast_.t[7] = (u16)((args->params.t8) * 1000);  // wyliczenie ilosci petli dla odliczenia czasu prerwy beznapieciowej 5
	log->nast_.to = (u16)((args->params.to) * 1000);  // wyliczenie ilosci petli dla odliczenia czasu oczekiwania na odpowiedz wylacznika
	log->nast_.tb = (u16)((args->params.tb) * 1000);  // wyliczenie ilosci petli dla odliczenia czasu odwzbudzania SPZ
	log->nast_.tz = (u16)((args->params.tz) * 1000);  // wyliczenie ilosci petli dla odliczenia czasu impulsu zalaczajacego
	log->nast_.tp1 = (u16)((args->params.tp1) * 1000); // czas przerwy jednofazowej
	log->nast_.twy = (u16)((args->params.twy) * 1000); // czas przerwy jednofazowej
	log->nast_.trozw = (u16)((args->params.troz) * 1000); // czas przerwy w zawrciu rzowojowym
	log->nast_.tsck = (u16)((args->params.tsck) * 1000); // czas oczewkiwania na SCK
	log->nast_.t_akcji = (u16)((args->params.takcji) * 1000); // czas akcji
	log->nast_.t_zal_zw = (u16)((args->params.t_zal_zw) *1000);
	log->nast_.t_slave = (u16)((args->params.t_slave) *1000);
	log->nast_.t_czek_na_master = (u16)((args->params.t_czek_na_master) * 1000);
	log->nast_.t_zbierania = (u16)((args->params.t_zbierania) * 1000);

	log->licznik_SPZ = 1;
	log->stan_wew = CZEKANIE;
	log->jednofazowy = 1;
	log->wydluzenie = 0;
	log->licznik_SCK = 0;
	log->licznik_zal_zw = 0;
	log->licznik_czek_na_master = 0;
	log->licznik_master_slave = 0;
	log->licznik_zbierania = 0;

	log->W_ON1_old = 0;
	log->W_ON2_old = 0;
	log->W_ON3_old = 0;
	log->we_zal_old = 0;
	log->byl_zalacz = 0;
	log->tryb_master_slave = NORMAL;
	log->jest_blok_trw = 0;

	log->start_log = 0;

	return 0;
}
void ustaw_numer_SPZ_2(struct spz_3f_2_logic *log)
{
	*log->proba1&=~log->proba1_bit_mask;
	*log->proba2&=~log->proba2_bit_mask;
	*log->proba3&=~log->proba3_bit_mask;
	*log->proba4&=~log->proba4_bit_mask;
	*log->proba5&=~log->proba5_bit_mask;
	*log->proba6&=~log->proba6_bit_mask;
	*log->proba7&=~log->proba7_bit_mask;
	*log->proba8&=~log->proba8_bit_mask;

	switch (log->licznik_SPZ)
	{
		case 1:
			//*log->proba1|=log->proba1_bit_mask;
			break;
		case 2:
			*log->proba2|=log->proba2_bit_mask;
			break;
		case 3:
			*log->proba3|=log->proba3_bit_mask;
			break;
		case 4:
			*log->proba4|=log->proba4_bit_mask;
			break;
		case 5:
			*log->proba5|=log->proba5_bit_mask;
			break;
		case 6:
			*log->proba6|=log->proba6_bit_mask;
			break;
		case 7:
			*log->proba7|=log->proba7_bit_mask;
			break;
		case 8:
			*log->proba8|=log->proba8_bit_mask;
			break;

		default:
			break;
	}
}

void przejdz_do_error_2(struct spz_3f_2_logic *log)
{
	*log->wy_pob&= ~log->wy_pob_bit_mask;
	*log->Z &= ~log->Z_bit_mask;
	*log->t_prz_bez &= ~log->t_prz_bez_bit_mask;
	*log->rozwojowe &= ~log->rozwojowe_bit_mask;
	*log->nieudany &= ~log->nieudany_bit_mask;
	*log->udany &= ~log->udany_bit_mask;
	*log->t_o &= ~log->t_o_bit_mask;
	*log->error |= log->error_bit_mask;
	*log->t_akcji &= ~log->t_akcji_bit_mask;
	*log->brakSCK &= ~log->brak_SCK_bit_mask;
	*log->wy_zal_slave &= ~log->wy_zal_slave_bit_mask;	
	*log->wy_czek_na_master &= ~log->wy_czek_na_master_bit_mask;
	*log->wy_czek_na_SCK &= ~log->wy_czek_na_SCK_bit_mask;
	*log->t_prz_bez_1f &= ~log->t_prz_bez_1f_bit_mask;
	log->stan_wew = ERROR;
	log->tryb_master_slave = NORMAL;
}

void przejdz_do_nieudany_2(struct spz_3f_2_logic *log)
{
	*log->wy_pob&= ~log->wy_pob_bit_mask;
	*log->Z &= ~log->Z_bit_mask;
	*log->t_prz_bez &= ~log->t_prz_bez_bit_mask;
	*log->rozwojowe &= ~log->rozwojowe_bit_mask;
	*log->udany &= ~log->udany_bit_mask;
	*log->nieudany |= log->nieudany_bit_mask;
	*log->t_o &= ~log->t_o_bit_mask;
	*log->error &= ~log->error_bit_mask;
	*log->t_akcji &= ~log->t_akcji_bit_mask;
	*log->wy_zal_slave &= ~log->wy_zal_slave_bit_mask;	
	*log->wy_czek_na_master &= ~log->wy_czek_na_master_bit_mask;
	*log->wy_czek_na_SCK &= ~log->wy_czek_na_SCK_bit_mask;
	log->licznik_odwzb = 0;
	log->stan_wew = NIEUDANY;
	log->tryb_master_slave = NORMAL;
}

void wy_blokada_2(struct spz_3f_2_logic *log)
{
	*log->wy_pob&= ~log->wy_pob_bit_mask;
	*log->Z &= ~log->Z_bit_mask;
	*log->t_prz_bez &= ~log->t_prz_bez_bit_mask;
	*log->t_blokady &= ~log->t_blokady_bit_mask;
	*log->rozwojowe &= ~log->rozwojowe_bit_mask;
	*log->udany &= ~log->udany_bit_mask;
	*log->nieudany &= ~log->nieudany_bit_mask;
	*log->t_o &= ~log->t_o_bit_mask;
	*log->error &= ~log->error_bit_mask;
	*log->t_akcji &= ~log->t_akcji_bit_mask;
	*log->brakSCK &= ~log->brak_SCK_bit_mask;
	*log->zal_zw &= ~log->zal_zw_bit_mask;
	*log->wy_zal_slave &= ~log->wy_zal_slave_bit_mask;	
	*log->wy_czek_na_master &= ~log->wy_czek_na_master_bit_mask;
	*log->wy_czek_na_SCK &= ~log->wy_czek_na_SCK_bit_mask;

}

void domyslne_wy_2(struct spz_3f_2_logic *log)
{
	wy_blokada_2(log);
	*log->t_prz_bez_1f &= ~log->t_prz_bez_1f_bit_mask;
}

void spz_3f_2(void *arguments, void *logic)
{
	struct spz_3f_2_logic *log = (struct spz_3f_2_logic *)logic;

	u8 we_pob = ((*log->Pob & log->Pob_bit_mask) != 0) ? 1 : 0;
	u8 we_bl = ((*log->Blokada & log->Blokada_bit_mask) != 0) ? 1 : 0;
	u8 we_W1 = ((*log->W1_ON & log->W1_ON_bit_mask) != 0) ? 1 : 0;
	u8 we_W2 = ((*log->W2_ON & log->W2_ON_bit_mask) != 0) ? 1 : 0;
	u8 we_W3 = ((*log->W3_ON & log->W3_ON_bit_mask) != 0) ? 1 : 0;
	u8 we_wyl1 = ((*log->WYL_1 & log->WYL_1_bit_mask) != 0) ? 1 : 0;
	u8 we_wyl2 = ((*log->WYL_2 & log->WYL_2_bit_mask) != 0) ? 1 : 0;
	u8 we_wyl3 = ((*log->WYL_3 & log->WYL_3_bit_mask) != 0) ? 1 : 0;
	u8 we_1faz = ((*log->FAZ_1 & log->FAZ_1_bit_mask) != 0) ? 1 : 0;
	u8 we_3faz = ((*log->FAZ_3 & log->FAZ_3_bit_mask) != 0) ? 1 : 0;
	u8 we_kasuj = ((*log->kasowanie & log->kasowanie_bit_mask) != 0) ? 1 : 0;
	u8 we_gotowosc = ((*log->gotowosc & log->gotowosc_bit_mask) != 0) ? 1 : 0;
	u8 we_wydluz = ((*log->wydluzenie_we & log->wydluzenie_we_bit_mask) != 0) ? 1 : 0;
	u8 we_sck = ((*log->sck_we & log->sck_we_bit_mask) != 0) ? 1 : 0;

	u8 we_master_slave = ((*log->master_slave & log->master_slave_bit_mask) != 0) ? 1 : 0;
	u8 we_wyl2u = ((*log->wyl_2 & log->wyl_2_bit_mask) != 0) ? 1 : 0;
	u8 we_zal_slave =  ((*log->we_zal_slave & log->we_zal_slave_bit_mask) != 0) ? 1 : 0;
	u8 we_zal =  ((*log->we_zal & log->we_zal_bit_mask) != 0) ? 1 : 0;
	u8 we_przysp =  ((*log->we_przysp & log->we_przysp_bit_mask) != 0) ? 1 : 0;
	
	if (log->start_log < 20)
	{
		log->start_log++;
		domyslne_wy_2(log);
		return;	
	}


if (log->nast_.SPZ_on)
	{

	//gdy jest pobudzone wejscie wydluzenie do zmiennej wydluzenie
	//wpisywana jest nastawa
	if (we_wydluz)
	{
		log->wydluzenie = log->nast_.twy;
	}
	else
	{
		log->wydluzenie = 0;
	}

	//ustawiwenie zgody na wylacz jednofazowy
	if (log->jednofazowy && !we_1faz && log->stan_wew != ERROR && log->stan_wew != NIEUDANY
	&& log->stan_wew != BLOKADA &&  we_bl==0)
	{
		*log->ZGODA_1F |= log->ZGODA_1F_bit_mask;
		log->wyj_zgoda_jednofazowy = 1;
	}
	else
	{
		*log->ZGODA_1F &= ~log->ZGODA_1F_bit_mask;
		log->wyj_zgoda_jednofazowy = 0;
	}

	//ustawienie zgody na wylacz trojfazowy
	if (!we_3faz)
		log->wyj_zgoda_trojfazowy = 1;
	else
		log->wyj_zgoda_trojfazowy = 0;

	//pobudzenie blokady powoduje przejscie do stanu blokady
	//gdy bylo to w trakcie przerwy beznapieciowej przy pob 1 faz.
	//ustawia flage

	if (we_bl)
	{
		if (log->stan_wew == PRZERWA_BEZNAP_1FAZ)
		{
			//log->blokada_w_1faz = 1;
		}
		log->stan_wew = BLOKADA;
	}

	if ((log->stan_wew == BLOKADA) || (we_1faz && we_3faz) || (log->jest_blok_trw))
		*log->wy_blokady |= log->wy_blokady_bit_mask;
	else
		*log->wy_blokady &= ~log->wy_blokady_bit_mask;

	if ((log->stan_wew == BLOKADA) || (we_1faz && we_3faz) ||
	(log->stan_wew ==ERROR) || (log->stan_wew ==NIEUDANY) ||
	((log->stan_wew == ZALACZ_BLOKADA) && (log->licznik_SPZ == log->nast_.licz_p)) ||
	((log->stan_wew == ZALACZ_BLOKADA) && (we_3faz)))
	{
		*log->niegotowy |= log->niegotowy_bit_mask;
	}
	else
	{
		*log->niegotowy &= ~log->niegotowy_bit_mask;
	}

	//kasowanie - powrot do stanu normalnego
	if (we_kasuj)
	{
		log->stan_wew = CZEKANIE;
		log->licznik_SPZ = 1;
		ustaw_numer_SPZ_2(log);
		log->jednofazowy = 1;
		domyslne_wy_2(log);
		log->jest_blok_trw = 0;
	}

	//autoamtyka zal na zwarocie

	*log->zal_zw &= ~log->zal_zw_bit_mask; //zawsze zdejmuje sygnal


	if (log->nast_.zal_zw_bit == 1)
	{
		if (log->nast_.zal_zw_kryt_W == 1) //kryterium od stanu wycznika
		{		
			if (log->W_ON1_old == 0 && we_W1 == 1)
			{
				log->byl_zalacz = 1;
				log->licznik_zal_zw = 0;
			}
			if (log->W_ON2_old == 0 && we_W2 == 1)
			{
				log->byl_zalacz = 1;
				log->licznik_zal_zw = 0;
			}
			if (log->W_ON3_old == 0 && we_W3 == 1)
			{
				log->byl_zalacz = 1;
				log->licznik_zal_zw = 0;
			}
		}
		
		if (log->we_zal_old == 0 && we_zal == 1) //kryterium od sygnalu zal
		{
			log->byl_zalacz = 1;
			log->licznik_zal_zw = 0;
		}
			
		log->W_ON1_old = we_W1;
		log->W_ON2_old = we_W2;
		log->W_ON3_old = we_W3;
		log->we_zal_old = we_zal;

		if (log->byl_zalacz == 1)
		{
			log->licznik_zal_zw += LOOP_CYCLE_MS;
			if (log->licznik_zal_zw >= log->nast_.t_zal_zw)
			{
				log->byl_zalacz = 0;
			}
		}
	
		if (log->byl_zalacz && (we_wyl1 || we_wyl2 || we_wyl3))
		{
			//wykryto zal na zwarcie
			przejdz_do_nieudany_2(log);
	
			*log->zal_zw |= log->zal_zw_bit_mask;
	
		}
	

	}
	//wyjcia jest master jest slave
	if (log->tryb_master_slave == MASTER)
	{
		*log->wy_jest_master |= log->wy_jest_master_bit_mask;	
		*log->wy_jest_slave &= ~log->wy_jest_slave_bit_mask;		
	}
	else if  (log->tryb_master_slave == SLAVE)
	{
		*log->wy_jest_master &= ~log->wy_jest_master_bit_mask;	
		*log->wy_jest_slave |= log->wy_jest_slave_bit_mask;		
	}
	else
		{
		*log->wy_jest_master &= ~log->wy_jest_master_bit_mask;	
		*log->wy_jest_slave &= ~log->wy_jest_slave_bit_mask;		
	}
	

	switch(log->stan_wew)
	{
	//*********************************************************************
	// czekanie na pobudzenie SPZ
	case CZEKANIE:

	if (log->licznik_udany > 0)
		log->licznik_udany--;

	if (log->licznik_udany == 1)
	{
		*log->udany &= ~log->udany_bit_mask;
		*log->nieudany &= ~log->nieudany_bit_mask;
	}

	if (we_pob)
	{
		if (log->nast_.kontr_pocz)
		{
			if (!we_W1 || !we_W2 || !we_W3)
			{
				log->licznik_odwzb = 0;
				przejdz_do_error_2(log);
				break;
			}
		}
		
				
		if (we_wyl2u && log->nast_.master_slave_on)
		{
			if (we_master_slave)
			{
				log->tryb_master_slave = MASTER;	
			}
			else
			{
				log->tryb_master_slave = SLAVE; 	
			}
		}
		else
		{
			log->tryb_master_slave = NORMAL;
		}
		
				
		log->stan_wew = AKCJA;

		log->byl_wyl_f1 = 0;
	   	log->byl_wyl_f2 = 0;
	  	log->byl_wyl_f3 = 0;

		log->byl_odpad_f1 = 0;
		log->byl_odpad_f2 = 0;
		log->byl_odpad_f3 = 0;

		log->licznik_akcji = 0;

		*log->proba1|=log->proba1_bit_mask; //proba 1 dopiero po pobudzeniu
		*log->wy_pob |= log->wy_pob_bit_mask;
		*log->udany &= ~log->udany_bit_mask;
		*log->nieudany &= ~log->nieudany_bit_mask;
		*log->t_akcji |= log->t_akcji_bit_mask;

	}
	break;

	//*********************************************************************

	case AKCJA:
		log->licznik_akcji += LOOP_CYCLE_MS;
		if (log->licznik_akcji >= log->nast_.t_akcji)
		{
			przejdz_do_nieudany_2(log);
			break;
		}

		if (we_wyl1)
			log->byl_wyl_f1 = 1;

		if (we_wyl2)
			log->byl_wyl_f2 = 1;

		if (we_wyl3)
			log->byl_wyl_f3 = 1;


		if (we_wyl1 || we_wyl2 || we_wyl3)
		{
			log->stan_wew = POBUDZENIE;
			log->licznik_pob = 0;
			
			log->licznik_zbierania = 0;
			log->spr_wylaczenia = 0;
			log->jednofazowy_L1 = 0;
			log->jednofazowy_L2 = 0;
			log->jednofazowy_L3 = 0;

			*log->t_o |= log->t_o_bit_mask;
			*log->t_akcji &= ~log->t_akcji_bit_mask;

		}

	break;



	//*********************************************************************
	//SPZ pobudzony - sprawdzenie czy wylacz jedno czy trojfazowy

	case POBUDZENIE:


		log->licznik_pob += LOOP_CYCLE_MS;
		if (log->licznik_pob >= log->nast_.to)
		{
			log->licznik_odwzb = 0;
			przejdz_do_error_2(log);
			break;
		}

// kontrola wylaczen nowa \/\/\/

		if (log->spr_wylaczenia == 0)
		{
			log->licznik_zbierania += LOOP_CYCLE_MS;
			if (log->licznik_zbierania >= log->nast_.t_zbierania)
			{
				log->spr_wylaczenia = 1;
				if ((log->byl_wyl_f1 == 1) && (log->byl_wyl_f2 == 0) && (log->byl_wyl_f3 == 0))
					log->jednofazowy_L1 = 1;
				if ((log->byl_wyl_f1 == 0) && (log->byl_wyl_f2 == 1) && (log->byl_wyl_f3 == 0))
					log->jednofazowy_L2 = 1;
			 	if ((log->byl_wyl_f1 == 0) && (log->byl_wyl_f2 == 0) && (log->byl_wyl_f3 == 1))
					log->jednofazowy_L3 = 1;
							 
				// w momencie sprawdzenia by wycz 2 fazowy
				if (((log->byl_wyl_f1 == 1) && (log->byl_wyl_f2 == 1) && (log->byl_wyl_f3 == 0)) ||
					((log->byl_wyl_f1 == 0) && (log->byl_wyl_f2 == 1) && (log->byl_wyl_f3 == 1)) ||
					((log->byl_wyl_f1 == 1) && (log->byl_wyl_f2 == 0) && (log->byl_wyl_f3 == 1)))
				{
					log->licznik_odwzb = 0;
					przejdz_do_error_2(log);
					break;	
				}	
			}
		} else
		{
			if ((log->jednofazowy_L1 == 1) && ((log->byl_wyl_f2 == 1) || (log->byl_wyl_f3 == 1)) ||
				(log->jednofazowy_L2 == 1) && ((log->byl_wyl_f1 == 1) || (log->byl_wyl_f3 == 1)) ||
				(log->jednofazowy_L3 == 1) && ((log->byl_wyl_f1 == 1) || (log->byl_wyl_f2 == 1)))
			{
					log->licznik_odwzb = 0;
					przejdz_do_error_2(log);
					break;		
			}		
		}

// kontrola wylaczen nowa /\/\/\

		if (we_wyl1)
			log->byl_wyl_f1 = 1;

		if (we_wyl2)
			log->byl_wyl_f2 = 1;

		if (we_wyl3)
			log->byl_wyl_f3 = 1;

		if ((we_wyl1 == 0) && (log->byl_wyl_f1 == 1))
			log->byl_odpad_f1 = 1;

		if ((we_wyl2 == 0) && (log->byl_wyl_f2 == 1))
			log->byl_odpad_f2 = 1;

		if ((we_wyl3 == 0) && (log->byl_wyl_f3 == 1))
			log->byl_odpad_f3 = 1;


		// dla wylaczenia jednofazowego sprawdz jedno wylaczenie
		if (log->wyj_zgoda_jednofazowy)
		{

			if ((log->byl_odpad_f1&& !log->byl_wyl_f2 && !log->byl_wyl_f3) ||
			(log->byl_odpad_f2 && !log->byl_wyl_f1 && !log->byl_wyl_f3) ||
			(log->byl_odpad_f3 && !log->byl_wyl_f1 && !log->byl_wyl_f2))
			{
				log->stan_wew = PRZERWA_BEZNAP_1FAZ;
				log->licznik_beznap = 0;
				log->limit_beznap_1faz = log->nast_.tp1;

				// zapisz ktora faza wylaczyla
				log->wylaczyla_f1 = 0;
				log->wylaczyla_f2 = 0;
				log->wylaczyla_f3 = 0;

				if (log->byl_wyl_f1) log->wylaczyla_f1 = 1;
				if (log->byl_wyl_f2) log->wylaczyla_f2 = 1;
				if (log->byl_wyl_f3) log->wylaczyla_f3 = 1;

				//byl wylacz 1 fazowy nie pozwalaj na nastepny
				log->jednofazowy = 0;

				*log->t_prz_bez |= log->t_prz_bez_bit_mask;
				*log->t_prz_bez_1f |= log->t_prz_bez_1f_bit_mask;
				*log->t_o &= ~log->t_o_bit_mask;
				break;
			}
		}
		else //nie ma zgody na jednofazowy a jest
		{
			if ((log->byl_odpad_f1&& !log->byl_wyl_f2 && !log->byl_wyl_f3) ||
			(log->byl_odpad_f2 && !log->byl_wyl_f1 && !log->byl_wyl_f3) ||
			(log->byl_odpad_f3 && !log->byl_wyl_f1 && !log->byl_wyl_f2))
			{
				przejdz_do_nieudany_2(log);
				break;		
			}
		}

		// dla wylacza trojfazowego musza odpasc wylacza
		if (log->wyj_zgoda_trojfazowy)
		{

			if (log->byl_odpad_f1 && log->byl_odpad_f2 && log->byl_odpad_f3)
			{
				log->stan_wew = PRZERWA_BEZNAP;

				log->licznik_beznap = 0;
				log->limit_beznap = log->nast_.t[log->licznik_SPZ - 1];
				//byl wylacz 3 fazowy nie pozwalaj na 1 fazowy
				log->jednofazowy = 0;

				*log->t_prz_bez |= log->t_prz_bez_bit_mask;
				*log->t_o &= ~log->t_o_bit_mask;
			}
		}
		else
		{
			//nie ma zgody na trojfazowy a jest
			if (log->byl_odpad_f1 && log->byl_odpad_f2 && log->byl_odpad_f3)
			{
				przejdz_do_nieudany_2(log);
				break;
			}
		}

		if (!log->wyj_zgoda_trojfazowy && !log->wyj_zgoda_jednofazowy)
		{
			//przyszlo pobudzenie i jest blokada jedno i 3 fazowego
			przejdz_do_nieudany_2(log);
		}


		break;
	//*********************************************************************
	// przerwa beznapieciowa - po uplywie idzie do czekanie na sck
	// lub, jesli jest tryb m/s idzie do czekanie na imp od master

	case PRZERWA_BEZNAP:

		log->ile_fazowy = 3;
		
		if (we_wyl1 || we_wyl2 || we_wyl3)
		{
			log->licznik_odwzb = 0;
			przejdz_do_error_2(log);
			break;
		}

	if(we_3faz) //w czasie przerwy beznap przyszla blokada 3 fazowego
	{
		przejdz_do_nieudany_2(log);
	}

		log->licznik_beznap += LOOP_CYCLE_MS;
		if ((log->licznik_beznap >= (log->limit_beznap + log->wydluzenie)) || we_przysp)
		{
			if ((log->nast_.master_slave_on) && (log->tryb_master_slave == SLAVE)) 
			{
				log->stan_wew = CZEKANIE_NA_MASTER;
				*log->wy_czek_na_master |= log->wy_czek_na_master_bit_mask;
				log->licznik_czek_na_master = 0;
			}
			else
			{		
				log->stan_wew = CZEKANIE_NA_SCK;
				*log->wy_czek_na_SCK |= log->wy_czek_na_SCK_bit_mask;
				log->licznik_SCK = 0;		
			}		
		
		*log->t_prz_bez &= ~log->t_prz_bez_bit_mask;		
		}
		break;

	//*********************************************************************
	// czekanie na master - w trybie m/s gdy jest slave
	// czeka na impuls od master, gdy go dostanie i jest to SPZ 1-fazowy
	// nastepuje zalacz a gdy trojfazowy idzie do czekania na SCK
	case CZEKANIE_NA_MASTER:
	{
		if (we_wyl1 || we_wyl2 || we_wyl3)
		{
			log->licznik_odwzb = 0;
			przejdz_do_error_2(log);
			break;
		}
		
		if (we_zal_slave)
		{
			if (log->ile_fazowy == 1)
			{
				if (we_gotowosc && !we_wyl1 && !we_wyl2 && !we_wyl3)
				{				
					log->stan_wew = ZALACZ_BLOKADA;
					log->licznik_zalacz = 0;
					log->licznik_odwzb = 0;
					log->licznik_pob = 0;
					log->licznik_master_slave = 0;
					log->blokuj_slave = 0;
	
					*log->Z |= log->Z_bit_mask;
					*log->t_blokady |= log->t_blokady_bit_mask;	
					*log->t_prz_bez_1f &= ~log->t_prz_bez_1f_bit_mask;
					*log->wy_czek_na_master &= ~log->wy_czek_na_master_bit_mask;	
					*log->t_prz_bez_1f &= ~log->t_prz_bez_1f_bit_mask; //sygnal przeznaczony do wylaczenia
					break;
				}
				else
				{
					//nie bylo gotowosci do zalaczenia
					*log->brakSCK |= log->brak_SCK_bit_mask;
					przejdz_do_nieudany_2(log);
					break;
				}	
			}		
			else
			{
				*log->wy_czek_na_master &= ~log->wy_czek_na_master_bit_mask;
				*log->wy_czek_na_SCK |= log->wy_czek_na_SCK_bit_mask;
				log->licznik_SCK = 0;
				log->stan_wew = CZEKANIE_NA_SCK;
				break;				
			}					
		}
		
		log->licznik_czek_na_master += LOOP_CYCLE_MS;		
		if(log->licznik_czek_na_master >= log->nast_.t_czek_na_master)
		{
			przejdz_do_nieudany_2(log);
		}		
		break;
	}
	
	//*********************************************************************
	// czeaknie na sck - w SPZ 3 fazowym czeka na sck
	case CZEKANIE_NA_SCK:
	{
		if (we_wyl1 || we_wyl2 || we_wyl3)
		{
			log->licznik_odwzb = 0;
			przejdz_do_error_2(log);
			break;
		}
		
		//przed zalaczeniem sprawdz gotowosc do zaleczenia i nie ma wylacza
			if (we_sck && we_gotowosc && !we_wyl1 && !we_wyl2 && !we_wyl3)
			{
				log->stan_wew = ZALACZ_BLOKADA;
				log->licznik_zalacz = 0;
				log->licznik_odwzb = 0;
				log->licznik_pob = 0;
				log->licznik_master_slave = 0;
				log->blokuj_slave = 0;

				*log->Z |= log->Z_bit_mask;
				*log->wy_czek_na_SCK &= ~log->wy_czek_na_SCK_bit_mask;
				*log->t_blokady |= log->t_blokady_bit_mask;
				break;
			}

			log->licznik_SCK += LOOP_CYCLE_MS;
			if (log->licznik_SCK >= log->nast_.tsck)
			{
				//nie bylo gotowosci do zalaczenia
				*log->brakSCK |= log->brak_SCK_bit_mask;
				przejdz_do_nieudany_2(log);
				break;
			}
		break;
	}
	//*********************************************************************
	//przerwa beznapieciowa jednofazowa
	// jesli w czsie oczekiwania przyjdzie wylacz na innej fazie
	// przejdz do trybu ZWARCIE_ROZWOJOWE
	// po czasie blokady sprawdza gotowosc do zalaczenia

	case PRZERWA_BEZNAP_1FAZ:

		log->ile_fazowy = 1;
		
		if (we_wyl1)
			log->byl_wyl_f1 = 1;

		if (we_wyl2)
			log->byl_wyl_f2 = 1;

		if (we_wyl3)
			log->byl_wyl_f3 = 1;

	if(we_1faz) //w czasie przerwy beznap przyszla blokada 1 fazowego
	{
		przejdz_do_nieudany_2(log);
	}

		if ((log->wylaczyla_f1 && (log->byl_wyl_f2 || log->byl_wyl_f3))
		|| (log->wylaczyla_f2 && (log->byl_wyl_f1 || log->byl_wyl_f3))
		|| (log->wylaczyla_f3 && (log->byl_wyl_f1 || log->byl_wyl_f2)))
		{
			if (log->nast_.ZW_rozw)
			{
				//blokuj przy zwarciu nieudanym
				przejdz_do_nieudany_2(log);
				break;
			}
			else
			{
				if (log->wyj_zgoda_trojfazowy)
				{
					log->licznik_pob = 0; // zwarcie rozwijajace sie, licznik oczewkiania od nowa
					log->licznik_beznap = 0; //restart licznika przerwy baznap.
					log->stan_wew = ZWARCIE_ROZWOJOWE;

					*log->t_prz_bez_1f &= ~log->t_prz_bez_1f_bit_mask;
					*log->rozwojowe |= log->rozwojowe_bit_mask;
					*log->t_o |= log->t_o_bit_mask;
				}
				else
				{
					przejdz_do_nieudany_2(log);
				}
			}
			break;
		}

		log->licznik_beznap += LOOP_CYCLE_MS;
		if ((log->licznik_beznap >= (log->limit_beznap_1faz + log->wydluzenie)) || (we_przysp))
		{
			if ((log->nast_.master_slave_on) && (log->tryb_master_slave == SLAVE)) 
			{
				log->stan_wew = CZEKANIE_NA_MASTER;
				*log->wy_czek_na_master |= log->wy_czek_na_master_bit_mask;
				*log->t_prz_bez &= ~log->t_prz_bez_bit_mask;
				log->licznik_czek_na_master = 0;
			}
			else
			{		
				if (we_gotowosc && !we_wyl1 && !we_wyl2 && !we_wyl3)
				{
					log->stan_wew = ZALACZ_BLOKADA;
					log->licznik_zalacz = 0;
					log->licznik_odwzb = 0;
					log->licznik_pob = 0;
					log->licznik_master_slave = 0;
					log->blokuj_slave = 0;
	
					*log->Z |= log->Z_bit_mask;
					*log->t_prz_bez &= ~log->t_prz_bez_bit_mask;
					*log->t_prz_bez_1f &= ~log->t_prz_bez_1f_bit_mask;
					*log->t_blokady |= log->t_blokady_bit_mask;
				}
				else
				{
					//nie bylo gotowosci do zalaczenia
					*log->brakSCK |= log->brak_SCK_bit_mask;
					przejdz_do_nieudany_2(log);
				}
			}
		}



		break;
	//*********************************************************************
	//w czasie oczekiwania nastapilo juz zwarie na innej fazie
	//czekaj az przyjdzie zawrcie na 3 fazach
	//jesli przyszlo przejdz to trybu przerwy beznapieciowej trojfazowej
	//jesli nie to zwracie dwufazowe - error

	case ZWARCIE_ROZWOJOWE:

		//sprawdz czy w pozostalym czasie oczewkiania wylaczyly 3 fazy

		if (we_wyl1)
			log->byl_wyl_f1 = 1;

		if (we_wyl2)
			log->byl_wyl_f2 = 1;

		if (we_wyl3)
			log->byl_wyl_f3 = 1;

		if ((we_wyl1 == 0) && (log->byl_wyl_f1 == 1))
			log->byl_odpad_f1 = 1;

		if ((we_wyl2 == 0) && (log->byl_wyl_f2 == 1))
			log->byl_odpad_f2 = 1;

		if ((we_wyl3 == 0) && (log->byl_wyl_f3 == 1))
			log->byl_odpad_f3 = 1;

		log->licznik_pob += LOOP_CYCLE_MS;
		if (log->licznik_pob >= log->nast_.to)
		{
			//w czasie oczekiwania nie wylaczyly wszystkie fazy
			log->licznik_odwzb = 0;
			przejdz_do_error_2(log);
			break;
		}


		if (((log->byl_odpad_f1) && (log->byl_odpad_f2) && (log->byl_odpad_f3))/* || W_OFF*/)
		{
			//w czasie oczekiwanie po wylaczeniu jednofazowym wylaczyly pozostale fazy

			log->stan_wew = PRZERWA_BEZNAP;
			log->licznik_beznap = 0;
			log->limit_beznap = log->nast_.trozw;

			*log->t_o &= ~log->t_o_bit_mask;
			*log->t_prz_bez |= log->t_prz_bez_bit_mask;

			log->licznik_SCK = 0;
		}
		break;

	//*********************************************************************
	//stan generuje sygnal zalacz i czas blokady
	//jesli przyjdzie wylacz - przerywa zlacz i idzie do  KOLEJNE_POB
	//jesli przydzie pobudzenie - idzie do KOLEJNE_POB
	//po czasie oczekiwania sprawdza czy jest wszystko zalaczone
	//po czasie blokady sprawdza czy udany czy nie udany

	case ZALACZ_BLOKADA:

		//gdy minal czas impulsu wylaczajacego wylacz impuls
		log->licznik_zalacz += LOOP_CYCLE_MS;
		if (log->licznik_zalacz >= log->nast_.tz)
		{
			*log->Z &= ~log->Z_bit_mask;
			
		}

		if (log->tryb_master_slave == MASTER)
		{
			if (!log->blokuj_slave)
			{			
				log->licznik_master_slave += LOOP_CYCLE_MS;
		
				if (log->licznik_master_slave >= (log->nast_.t_slave + 1000))
				{
					*log->wy_zal_slave &= ~log->wy_zal_slave_bit_mask;	
				}
				else if (log->licznik_master_slave >= log->nast_.t_slave)
				{
					*log->wy_zal_slave |= log->wy_zal_slave_bit_mask;	
				}
				

			}
		}
		
		if (we_wyl1 || we_wyl2 || we_wyl3)
		{
			*log->Z &= ~log->Z_bit_mask;
			*log->wy_zal_slave &= ~log->wy_zal_slave_bit_mask;	
			log->blokuj_slave = 1;
		}

		if (we_pob)
		{
			if ( log->licznik_SPZ == log->nast_.licz_p)
			{
				przejdz_do_nieudany_2(log);
				break;
			}

			log->byl_wyl_f1 = 0;
		   	log->byl_wyl_f2 = 0;
		  	log->byl_wyl_f3 = 0;

			log->byl_odpad_f1 = 0;
			log->byl_odpad_f2 = 0;
			log->byl_odpad_f3 = 0;

			log->licznik_pob = 0;
			log->licznik_akcji = 0;
			log->stan_wew = KOLEJNA_AKCJA;
			*log->t_akcji |= log->t_akcji_bit_mask;
			break;
		}

		// minal czas blokady rozpoznaj czy udany czy nieudany
		log->licznik_odwzb += LOOP_CYCLE_MS;
		if (log->licznik_odwzb >= log->nast_.tb)
		{
			*log->Z &= ~log->Z_bit_mask;
			*log->t_blokady &= ~log->t_blokady_bit_mask;
			*log->wy_pob &= ~log->wy_pob_bit_mask;
			*log->rozwojowe &= ~log->rozwojowe_bit_mask;
			*log->wy_zal_slave &= ~log->wy_zal_slave_bit_mask;	
			log->tryb_master_slave = NORMAL;
			//zdarzenie udany
			if (log->nast_.kontr_kon)
			{
				if (we_W1 && we_W2 && we_W3)
				{
					*log->udany |= log->udany_bit_mask;
					log->licznik_udany = 3000; // 3 sekundy podtrzumanie stanu (dla zdarzen)
					log->stan_wew = CZEKANIE;
					log->licznik_SPZ = 1;
					ustaw_numer_SPZ_2(log);
					log->jednofazowy = 1;
				}
				else
				{
					*log->nieudany |= log->nieudany_bit_mask;
					log->licznik_udany = 3000; // 3 sekundy podtrzumanie stanu (dla zdarzen)
					log->stan_wew = CZEKANIE;
					log->licznik_SPZ = 1;
					ustaw_numer_SPZ_2(log);
					log->jednofazowy = 1;
				}
			}
			else
			{
				*log->udany |= log->udany_bit_mask;
				log->licznik_udany = 3000; // 3 sekundy podtrzumanie stanu (dla zdarzen)
				log->stan_wew = CZEKANIE;
				log->licznik_SPZ = 1;
				ustaw_numer_SPZ_2(log);
				log->jednofazowy = 1;
			}
		}
		break;

//*********************************************************************
	// pobudzenie lub wylaczenie w czasie blokady
	//sprawdza warunki po kolejnej prby zalaczenia

	case KOLEJNE_POB:

		if (we_wyl1)
			log->byl_wyl_f1 = 1;

		if (we_wyl2)
			log->byl_wyl_f2 = 1;

		if (we_wyl3)
			log->byl_wyl_f3 = 1;

		if ((we_wyl1 == 0) && (log->byl_wyl_f1 == 1))
			log->byl_odpad_f1 = 1;

		if ((we_wyl2 == 0) && (log->byl_wyl_f2 == 1))
			log->byl_odpad_f2 = 1;

		if ((we_wyl3 == 0) && (log->byl_wyl_f3 == 1))
			log->byl_odpad_f3 = 1;

		log->licznik_pob += LOOP_CYCLE_MS;
		if (log->licznik_pob >= log->nast_.to)
		{
			//w czasie oczekiwania nie wylaczyly wszystkie fazy lub nie przyszlo pobudzenie
			log->licznik_odwzb = 0;
			przejdz_do_error_2(log);
			break;
		}


		if (log->byl_odpad_f1 && log->byl_odpad_f2 && log->byl_odpad_f3)
		{
			//w czasie oczekiwanie po wylaczeniu jednofazowym wylaczyly pozostale fazy
			*log->t_akcji &= ~log->t_akcji_bit_mask;

			if (we_3faz)
			{
				//byl wylacz 3 fazowy i blokada 3 faz
				przejdz_do_nieudany_2(log);
				break;
			}

			log->licznik_SPZ++;

			ustaw_numer_SPZ_2(log);
			log->stan_wew = PRZERWA_BEZNAP;

			log->licznik_beznap = 0;
			log->limit_beznap = log->nast_.t[log->licznik_SPZ - 1];
			//byl wylacz 3 fazowy nie pozwalaj na 1 fazowy
			log->jednofazowy = 0;

			*log->t_o &= ~log->t_o_bit_mask;
			*log->t_prz_bez |= log->t_prz_bez_bit_mask;
			log->licznik_SCK = 0;

			break;

			//}
		}
		break;
//*********************************************************************
	// stan zablokowanie SPZ

	case BLOKADA:
		// w blokadzie pusc zalacz
		*log->Z &= ~log->Z_bit_mask;
		wy_blokada_2(log);

		if (we_bl == 0)
		{			
			*log->t_prz_bez_1f &= ~log->t_prz_bez_1f_bit_mask;
								
			 //gdy byl pobudzony i przyszla blokada
			// zdarzenie nieudany
			if ((*log->wy_pob & log->wy_pob_bit_mask) != 0)
			{
				*log->nieudany |= log->nieudany_bit_mask;
			}

			log->stan_wew = CZEKANIE;
			log->tryb_master_slave = NORMAL;
			domyslne_wy_2(log);
			log->licznik_SPZ = 1;
			ustaw_numer_SPZ_2(log);
		}
		break;

//*********************************************************************
	case KOLEJNA_AKCJA:

	log->licznik_akcji += LOOP_CYCLE_MS;
	if (log->licznik_akcji >= log->nast_.t_akcji)
	{
		log->licznik_odwzb = 0;
		przejdz_do_error_2(log);
		break;
	}

	if (we_wyl1)
		log->byl_wyl_f1 = 1;

	if (we_wyl2)
		log->byl_wyl_f2 = 1;

	if (we_wyl3)
		log->byl_wyl_f3 = 1;

	if (++log->licznik_zalacz > log->nast_.tz)
	{
		*log->Z &= ~log->Z_bit_mask;
	}

	if (log->tryb_master_slave == MASTER)
	{
		if (!log->blokuj_slave)
		{			
			log->licznik_master_slave += LOOP_CYCLE_MS;
	
			if (log->licznik_master_slave >= (log->nast_.t_slave + 1000))
			{
				*log->wy_zal_slave &= ~log->wy_zal_slave_bit_mask;	
			}
			else if (log->licznik_master_slave >= log->nast_.t_slave)
			{
				*log->wy_zal_slave |= log->wy_zal_slave_bit_mask;	
			}
				

		}
	}

	if (we_wyl1 || we_wyl2 || we_wyl3)
	{
		log->stan_wew = KOLEJNE_POB;
		*log->Z &= ~log->Z_bit_mask;
		*log->t_o |= log->t_o_bit_mask;
		*log->t_blokady &= ~log->t_blokady_bit_mask;
		*log->t_akcji &= ~log->t_akcji_bit_mask;
		*log->wy_zal_slave &= ~log->wy_zal_slave_bit_mask;	
		log->blokuj_slave = 1;
		log->licznik_pob = 0;
	}
	break;

//*********************************************************************

	// stan error
	case ERROR:

	// stan nieudany
	case NIEUDANY:

		//tutaj sciaga przerwe bez nap 1 f zeby byl jeden obieg na sume z blokadami
		*log->t_prz_bez_1f &= ~log->t_prz_bez_1f_bit_mask;
		
		*log->brakSCK &= ~log->brak_SCK_bit_mask;
		*log->Z &= ~log->Z_bit_mask;
		*log->t_blokady |= log->t_blokady_bit_mask;

		if (log->nast_.Blok_nieudany)
		{
			log->jest_blok_trw = 1;
		}
		else
		{
			log->licznik_odwzb += LOOP_CYCLE_MS;
			if (log->licznik_odwzb >= log->nast_.tb)
			{
				log->stan_wew = CZEKANIE;
				domyslne_wy_2(log);
				log->licznik_SPZ = 1;
				ustaw_numer_SPZ_2(log);
				log->jednofazowy = 1;
			}
		}
	break;

//*********************************************************************

	default:
		break;

	}
	}
	else
	{
		domyslne_wy_2(log);
		*log->wy_blokady |= log->wy_blokady_bit_mask;
		*log->ZGODA_1F &= ~log->ZGODA_1F_bit_mask;
	}
}


