dodany kod c od Krzyska po wielu modyfikacjach przez Gemini zeby usunac zalezność od TI-RTOS

src/21g.c

@@ -0,0 +1,278 @@
+/*
+ * 21g.c
+ *
+ *  Created on: 07-05-2018
+ *      Author: Krzysztof Jakubczyk
+ */
+
+#include "tdefs.h"
+#include "misc.h"
+
+#include "21g.h"
+#include "helper.h"
+#include "analog_in.h"
+#include "config.h"
+#include <math.h>
+
+int r21g_initlog(void *arguments, void *logic)
+{
+	struct r21g_args *args = (struct r21g_args *)arguments;
+	struct r21g_logic *log = (struct r21g_logic *)logic;
+
+	if(set_bit_ptr_struct(args->io.stan_bl_in,&log->stan_bl))
+		return -1;
+	if(set_bit_ptr_struct(args->io.test_in,&log->test))
+		return -1;
+
+	if(set_float_ptr(args->io.U_esk_float_in,&log->U_esk))
+		return -1;
+	if(set_float_ptr(args->io.U_orta_float_in,&log->U_orta))
+		return -1;
+	if(set_float_ptr(args->io.U_ortb_float_in,&log->U_ortb))
+		return -1;
+
+	if(set_float_ptr(args->io.I_esk_float_in,&log->I_esk))
+		return -1;
+	if(set_float_ptr(args->io.I_orta_float_in,&log->I_orta))
+		return -1;
+	if(set_float_ptr(args->io.I_ortb_float_in,&log->I_ortb))
+		return -1;
+
+	if(set_pointer_in_ptr(args->io.U_param_ptr_in,(u32 *)&log->U_param))
+		return -1;
+
+	if(set_pointer_in_ptr(args->io.I_param_ptr_in,(u32 *)&log->I_param))
+		return -1;
+
+	if(set_bit_ptr_struct(args->io.p_out,&log->P))
+		return -1;
+	if(set_bit_ptr_struct(args->io.z_out,&log->Z))
+		return -1;
+	if(set_bit_ptr_struct(args->io.w_out,&log->W))
+		return -1;
+
+	if(set_float_ptr(args->io.y_float_out,&log->y))
+		return -1;
+	if(set_float_ptr(args->io.g_float_out,&log->g))
+		return -1;
+	if(set_float_ptr(args->io.b_float_out,&log->b))
+		return -1;
+
+	log->przek = log->I_param->znam_wtor / log->U_param->znam_wtor;
+	log->y_rozr = (float)0.001 * 0.001 * args->params.yr * args->params.yr;// * log->przek * log->przek;
+	log->y_powr = log->y_rozr * args->params.kp * args->params.kp;
+
+	log->g_rozr = (float)0.001 * args->params.gr;// * log->przek;
+	log->g_powr = log->g_rozr * args->params.kp;
+
+	log->b_rozr = (float)0.001 * args->params.br;// * log->przek;
+	log->b_powr = log->b_rozr * args->params.kp;
+
+	log->umin_rozr = args->params.umin * args->params.umin;
+	log->umin_powr = log->umin_rozr * args->params.kp * args->params.kp;
+
+	log->imin_rozr = args->params.imin * args->params.imin;
+	log->imin_powr = log->imin_rozr * args->params.kp * args->params.kp;
+
+	log->td=(u32)(args->params.td*1000);
+
+
+	log->cos_shift = cosf(args->params.phi_corr*PI/180);
+	log->sin_shift = sinf(args->params.phi_corr*PI/180);
+
+	return 0;
+}
+
+void r21g(void *arguments, void *logic)
+{
+	struct r21g_logic *log = (struct r21g_logic *)logic;
+	struct r21g_args *args = (struct r21g_args *)arguments;
+	float y,g,b,m,g_new;
+
+	if((args->params.bity & 0x00000001) && !((args->params.bity & 0x00000002) && check_struct(&log->stan_bl))) // ON && unblocked
+	{
+		if(!*log->U_esk)
+			y=*log->I_esk / 0.000000001;
+		else
+			y=*log->I_esk / *log->U_esk;
+
+		m=((*log->U_ortb * *log->U_ortb) + (*log->U_orta * *log->U_orta));
+
+		if(!m)
+			m=0.000000001;
+
+		g=((*log->I_ortb * *log->U_ortb) + (*log->I_orta * *log->U_orta))/m;
+		b=((*log->I_orta * *log->U_ortb) - (*log->I_ortb * *log->U_orta))/m;
+//sprawdzic dzielenie przez zero
+
+		y*=log->przek*log->przek;
+		g*=log->przek;
+		b*=log->przek;
+
+		g_new=(log->cos_shift*g) - (log->sin_shift*b);
+		b=(log->sin_shift*g) + (log->cos_shift*b);
+		g=g_new;
+
+		*log->y=y;
+		*log->g=g;
+		*log->b=b;
+		//g=
+
+		sprawdz_P(&log->pobi,
+			*log->I_esk>log->imin_rozr,
+			*log->I_esk<log->imin_powr,
+			&log->lpi,
+			15,3);
+		sprawdz_P(&log->pobu,
+			*log->U_esk>log->umin_rozr,
+			*log->U_esk<log->umin_powr,
+			&log->lpu,
+			15,3);
+
+		if(log->pobu && log->pobi)
+		{
+			sprawdz_P(&log->poby,
+				y>log->y_rozr,
+				y<log->y_powr,
+				&log->lpy,
+				20,3);
+
+			switch(args->params.g_enum)
+			{
+				case S_FWD:
+					sprawdz_P(&log->pobg,
+						g>log->g_rozr,
+						g<log->g_powr,
+						&log->lpg,
+						20,3);
+					break;
+				case S_BKW:
+					g*=-1;
+					sprawdz_P(&log->pobg,
+						g>log->g_rozr,
+						g<log->g_powr,
+						&log->lpg,
+						20,3);
+					break;
+				case S_BID:
+					if(g<0)
+						g*=-1;
+					sprawdz_P(&log->pobg,
+						g>log->g_rozr,
+						g<log->g_powr,
+						&log->lpg,
+						20,3);
+					break;
+				default:
+					log->pobg=0;
+					break;
+			}
+
+			switch(args->params.b_enum)
+			{
+				case S_FWD:
+					sprawdz_P(&log->pobb,
+						b>log->b_rozr,
+						b<log->b_powr,
+						&log->lpb,
+						20,3);
+					break;
+				case S_BKW:
+					b*=-1;
+					sprawdz_P(&log->pobb,
+						b>log->b_rozr,
+						b<log->b_powr,
+						&log->lpb,
+						20,3);
+					break;
+				case S_BID:
+					if(b<0)
+						b*=-1;
+					sprawdz_P(&log->pobb,
+						b>log->b_rozr,
+						b<log->b_powr,
+						&log->lpb,
+						20,3);
+					break;
+				default:
+					log->pobb=0;
+					break;
+			}
+		}
+		else
+		{
+			log->poby=0;
+			log->pobg=0;
+			log->pobb=0;
+			log->lpy=0;
+			log->lpg=0;
+			log->lpb=0;
+		}
+
+		if(!args->params.log_enum)
+		{
+			log->p=1;
+
+			if(args->params.y_enum)
+				log->p&=log->poby;
+			if(args->params.g_enum)
+				log->p&=log->pobg;
+			if(args->params.b_enum)
+				log->p&=log->pobb;
+		}
+		else
+		{
+			log->p=0;
+
+			if(args->params.y_enum)
+				log->p|=log->poby;
+			if(args->params.g_enum)
+				log->p|=log->pobg;
+			if(args->params.b_enum)
+				log->p|=log->pobb;
+		}
+
+		if(!args->params.y_enum&&!args->params.g_enum&&!args->params.b_enum)
+			log->p=0;
+
+		if(log->p)
+		{
+			if(log->td_cnt>log->td)
+				log->z=1;
+			else
+				log->td_cnt+=LOOP_CYCLE_MS;
+		}
+		else
+		{
+			log->td_cnt=0;
+			log->z=0;
+		}
+
+		if(czy_test_R() && check_struct(&log->test))
+		{
+			log->p=1;
+			log->z=1;
+		}
+
+		check_and_set_struct(log->p,&log->P);
+		check_and_set_struct(log->z,&log->Z);
+
+		if(args->params.bity & 0x00000004) // na wylacz
+		{
+			check_and_set_struct(log->z,&log->W);
+		}
+	}
+	else
+	{
+		log->poby=0;
+		log->pobg=0;
+		log->pobb=0;
+		log->lpy=0;
+		log->lpg=0;
+		log->lpb=0;
+
+		clear_struct(&log->P);
+		clear_struct(&log->Z);
+		clear_struct(&log->W);
+	}
+}

src/21g.h

@@ -0,0 +1,123 @@
+/*
+ * 21g.h
+ *
+ *  Created on: 07-03-2018
+ *      Author: Krzysztof Jakubczyk
+ */
+
+#ifndef R21G_H_
+#define R21G_H_
+
+#include "tdefs.h"
+#include "helper.h"
+#include "analog_in.h"
+
+#define S_OFF	0
+#define S_FWD	1
+#define S_BKW	2
+#define S_BID	3
+
+struct r21g_logic
+{
+	struct binary_io stan_bl;
+	struct binary_io test;
+	float *U_esk;
+	float *U_orta;
+	float *U_ortb;
+	float *I_esk;
+	float *I_orta;
+	float *I_ortb;
+
+	struct analog_in_params *U_param;
+	struct analog_in_params *I_param;
+
+	struct binary_io P;
+	struct binary_io Z;
+	struct binary_io W;
+
+	float y_rozr;
+	float y_powr;
+	float g_rozr;
+	float g_powr;
+	float b_rozr;
+	float b_powr;
+	float u_rozr;
+	float u_powr;
+	float umin_rozr;
+	float umin_powr;
+	float imin_rozr;
+	float imin_powr;
+	u8 p;
+	u8 z;
+
+	u8 pobi;
+	u8 pobu;
+	u8 poby;
+	u8 pobg;
+	u8 pobb;
+
+	short lpi;
+	short lpu;
+	short lpy;
+	short lpg;
+	short lpb;
+
+	float *y;
+	float *g;
+	float *b;
+
+	float przek;
+	u32 td;
+	u32 td_cnt;
+	float cos_shift;
+	float sin_shift;
+};
+
+struct r21g_io
+{
+	u32 stan_bl_in;
+	u32 test_in;
+	u32 U_esk_float_in;
+	u32 U_orta_float_in;
+	u32 U_ortb_float_in;
+	u32 U_param_ptr_in;
+	u32 I_esk_float_in;
+	u32 I_orta_float_in;
+	u32 I_ortb_float_in;
+	u32 I_param_ptr_in;
+	u32 p_out;
+	u32 z_out;
+	u32 w_out;
+	u32 y_float_out;
+	u32 g_float_out;
+	u32 b_float_out;
+}__attribute__((__packed__));
+
+struct r21g_params
+{
+	u32 bity;
+	u32 y_enum;
+	double yr;
+	u32 g_enum;
+	double gr;
+	u32 b_enum;
+	double br;
+	double phi_corr;
+	double kp;
+	double td;
+	double umin;
+	double imin;
+	u32 log_enum;
+}__attribute__((__packed__));
+
+struct r21g_args
+{
+	struct r21g_io io;
+	struct r21g_params params;
+//	u16 crc;
+}__attribute__((__packed__));
+
+extern int r21g_initlog(void *arguments, void *logic);
+extern void r21g(void *arguments, void *logic);
+
+#endif /* 21G_H_ */

src/CBR.c

@@ -0,0 +1,371 @@
+/*
+ * CBR.c
+ *
+ *  Created on: 16-02-2017
+ *      Author: PS
+ */
+
+
+#include "CBR.h"
+#include "helper.h"
+#include "config.h"
+
+int CBR_initlog(void *arguments, void *logic)
+{
+	struct CBR_args *args = (struct CBR_args *)arguments;
+	struct CBR_logic *log = (struct CBR_logic *)logic;
+
+	if(set_bit_ptr_mask(args->io.we_W1_ON,&log->we_W1_ON,&log->we_W1_ON_bit_mask))
+		return -1;
+
+	if(set_bit_ptr_mask(args->io.we_W2_ON,&log->we_W2_ON,&log->we_W2_ON_bit_mask))
+		return -1;
+
+	if(set_bit_ptr_mask(args->io.we_W3_ON,&log->we_W3_ON,&log->we_W3_ON_bit_mask))
+		return -1;
+
+	if(set_bit_ptr_mask(args->io.we_W1_OFF,&log->we_W1_OFF,&log->we_W1_OFF_bit_mask))
+		return -1;
+
+	if(set_bit_ptr_mask(args->io.we_W2_OFF,&log->we_W2_OFF,&log->we_W2_OFF_bit_mask))
+		return -1;
+
+	if(set_bit_ptr_mask(args->io.we_W3_OFF,&log->we_W3_OFF,&log->we_W3_OFF_bit_mask))
+		return -1;
+
+	if(set_bit_ptr_mask(args->io.wy_W1_ON,&log->wy_W1_ON,&log->wy_W1_ON_bit_mask))
+		return -1;
+
+	if(set_bit_ptr_mask(args->io.wy_W2_ON,&log->wy_W2_ON,&log->wy_W2_ON_bit_mask))
+		return -1;
+
+	if(set_bit_ptr_mask(args->io.wy_W3_ON,&log->wy_W3_ON,&log->wy_W3_ON_bit_mask))
+		return -1;
+
+    if(set_bit_ptr_mask(args->io.zd_W_ON,&log->zd_W_ON,&log->zd_W_ON_bit_mask))
+		return -1;
+
+	if(set_bit_ptr_mask(args->io.zd_W_OFF,&log->zd_W_OFF,&log->zd_W_OFF_bit_mask))
+		return -1;
+
+	if(set_bit_ptr_mask(args->io.niezg_L1,&log->niezg_L1,&log->niezg_L1_bit_mask))
+		return -1;
+
+	if(set_bit_ptr_mask(args->io.niezg_L2,&log->niezg_L2,&log->niezg_L2_bit_mask))
+		return -1;
+
+	if(set_bit_ptr_mask(args->io.niezg_L3,&log->niezg_L3,&log->niezg_L3_bit_mask))
+		return -1;
+
+	log->nast_.licz_p = ((args->params.to) * 1000);
+	log->nast_.rodzaj = args->params.rodzaj;
+
+	log->licz_t1 = 0; // wyzerowanie czasu
+    log->licz_t2 = 0; // wyzerowanie czasu
+    log->licz_t3 = 0; // wyzerowanie czasu
+
+
+
+
+	return 0;
+}
+
+void CBR(void *arguments, void *logic)
+{
+	struct CBR_logic *log = (struct CBR_logic *)logic;
+
+	u8 t_W1_ON = ((*log->we_W1_ON & log->we_W1_ON_bit_mask) != 0) ? 1: 0;
+	u8 t_W2_ON = ((*log->we_W2_ON & log->we_W2_ON_bit_mask) != 0) ? 1: 0;
+	u8 t_W3_ON = ((*log->we_W3_ON & log->we_W3_ON_bit_mask) != 0) ? 1: 0;
+	u8 t_W1_OFF = ((*log->we_W1_OFF & log->we_W1_OFF_bit_mask) != 0) ? 1: 0;
+	u8 t_W2_OFF = ((*log->we_W2_OFF & log->we_W2_OFF_bit_mask) != 0) ? 1: 0;
+	u8 t_W3_OFF = ((*log->we_W3_OFF & log->we_W3_OFF_bit_mask) != 0) ? 1: 0;
+
+	u8 o_W1_ON = ((*log->wy_W1_ON & log->wy_W1_ON_bit_mask) != 0) ? 1: 0;
+	u8 o_W2_ON = ((*log->wy_W2_ON & log->wy_W2_ON_bit_mask) != 0) ? 1: 0;
+	u8 o_W3_ON = ((*log->wy_W3_ON & log->wy_W3_ON_bit_mask) != 0) ? 1: 0;
+
+	u8 o_zd_ON = ((*log->zd_W_ON & log->zd_W_ON_bit_mask) != 0) ? 1: 0;
+	u8 o_zd_OFF = ((*log->zd_W_OFF & log->zd_W_OFF_bit_mask) != 0) ? 1: 0;
+	u8 o_n_L1 = ((*log->niezg_L1 & log->niezg_L1_bit_mask) != 0) ? 1: 0;
+	u8 o_n_L2 = ((*log->niezg_L2 & log->niezg_L2_bit_mask) != 0) ? 1: 0;
+	u8 o_n_L3 = ((*log->niezg_L3 & log->niezg_L3_bit_mask) != 0) ? 1: 0;
+
+
+	switch(log->nast_.rodzaj)
+	{
+		case 0: //jednobitowo
+
+			o_n_L1 = 0;
+			o_n_L2 = 0;
+			o_n_L3 = 0;
+
+			if (t_W1_ON)
+			{
+				o_W1_ON = 1;
+				o_W2_ON = 1;
+				o_W3_ON = 1;
+				o_zd_ON = 1;
+				o_zd_OFF = 0;
+			}
+			else
+			{
+				o_W1_ON = 0;
+				o_W2_ON = 0;
+				o_W3_ON = 0;
+				o_zd_ON = 0;
+				o_zd_OFF = 1;
+			}
+			break;
+
+//*****************************************************************
+
+		case 1: //jednobitowo pofazowo
+
+			o_n_L1 = 0;
+			o_n_L2 = 0;
+			o_n_L3 = 0;
+
+			if (t_W1_ON)
+				o_W1_ON = 1;
+			else
+				o_W1_ON = 0;
+
+			if (t_W2_ON)
+				o_W2_ON = 1;
+			else
+				o_W2_ON = 0;
+
+			if (t_W3_ON)
+				o_W3_ON = 1;
+			else
+				o_W3_ON = 0;
+
+			if (t_W1_ON && t_W2_ON && t_W3_ON)
+			{
+				o_zd_ON = 1;
+				o_zd_OFF = 0;
+			}
+			else if (!t_W1_ON && !t_W2_ON && !t_W3_ON)
+			{
+				o_zd_OFF = 1;
+				o_zd_ON = 0;
+			}
+			else
+			{
+				o_zd_ON = 0;
+				o_zd_OFF = 0;
+			}
+			break;
+
+//*****************************************************************
+
+		case 2: //dwubitowo
+
+			if (t_W1_ON && !t_W1_OFF)
+			{
+				o_W1_ON = 1;
+				o_W2_ON = 1;
+				o_W3_ON = 1;
+				o_zd_ON = 1;
+				o_zd_OFF = 0;
+				o_n_L1 = 0;
+				o_n_L2 = 0;
+				o_n_L3 = 0;
+				log->licz_t1  = 0;
+			}
+			else if (!t_W1_ON && t_W1_OFF)
+			{
+				o_W1_ON = 0;
+				o_W2_ON = 0;
+				o_W3_ON = 0;
+				o_zd_ON = 0;
+				o_zd_OFF = 1;
+				o_n_L1 = 0;
+				o_n_L2 = 0;
+				o_n_L3 = 0;
+				log->licz_t1  = 0;
+			}
+			else  if (!t_W1_ON && !t_W1_OFF)
+			{
+				//pamieta stan - nie zmienia
+				log->licz_t1+=LOOP_CYCLE_MS;
+			}
+			else  if (t_W1_ON && t_W1_OFF)
+			{
+				o_W1_ON = 1;
+				o_W2_ON = 1;
+				o_W3_ON = 1;
+				o_zd_ON = 1;
+				o_zd_OFF = 0;
+				log->licz_t1+=LOOP_CYCLE_MS;
+			}
+
+			if (log->licz_t1 > log->nast_.licz_p)
+			{
+				o_n_L1 = 1;
+				o_n_L2 = 1;
+				o_n_L3 = 1;
+				log->licz_t1 = log->nast_.licz_p + (5*LOOP_CYCLE_MS);
+			}
+
+			break;
+
+//*****************************************************************
+
+		case 3: //dwubitowo pofazowo
+
+		// FAZA L1
+			if (t_W1_ON && !t_W1_OFF)
+			{
+				o_W1_ON = 1;
+				o_n_L1 = 0;
+				log->licz_t1  = 0;
+			}
+			else if (!t_W1_ON && t_W1_OFF)
+			{
+				o_W1_ON = 0;
+				o_n_L1 = 0;
+				log->licz_t1  = 0;
+			}
+			else  if (!t_W1_ON && !t_W1_OFF)
+			{
+				//pamieta stan - nie zmienia
+				log->licz_t1+=LOOP_CYCLE_MS;
+			}
+			else  if (t_W1_ON && t_W1_OFF)
+			{
+				o_W1_ON = 1;
+				log->licz_t1+=LOOP_CYCLE_MS;
+			}
+
+			if (log->licz_t1 > log->nast_.licz_p)
+			{
+				o_n_L1 = 1;
+				log->licz_t1 = log->nast_.licz_p + (5*LOOP_CYCLE_MS);
+			}
+
+		// FAZA L2
+			if (t_W2_ON && !t_W2_OFF)
+			{
+				o_W2_ON = 1;
+				o_n_L2 = 0;
+				log->licz_t2  = 0;
+			}
+			else if (!t_W2_ON && t_W2_OFF)
+			{
+				o_W2_ON = 0;
+				o_n_L2 = 0;
+				log->licz_t2  = 0;
+			}
+			else  if (!t_W2_ON && !t_W2_OFF)
+			{
+				//pamieta stan - nie zmienia
+				log->licz_t2+=LOOP_CYCLE_MS;
+			}
+			else  if (t_W2_ON && t_W2_OFF)
+			{
+				o_W2_ON = 1;
+				log->licz_t2+=LOOP_CYCLE_MS;
+			}
+
+			if (log->licz_t2 > log->nast_.licz_p)
+			{
+				o_n_L2 = 1;
+				log->licz_t2 = log->nast_.licz_p + (5*LOOP_CYCLE_MS);
+			}
+
+		// FAZA L3
+			if (t_W3_ON && !t_W3_OFF)
+			{
+				o_W3_ON  = 1;
+				o_n_L3 = 0;
+				log->licz_t3  = 0;
+			}
+			else if (!t_W3_ON && t_W3_OFF)
+			{
+				o_W3_ON  = 0;
+				o_n_L3 = 0;
+				log->licz_t3  = 0;
+			}
+			else  if (!t_W3_ON && !t_W3_OFF)
+			{
+				//pamieta stan - nie zmienia
+				log->licz_t3+=LOOP_CYCLE_MS;
+			}
+			else  if (t_W3_ON && t_W3_OFF)
+			{
+				o_W3_ON  = 1;
+				log->licz_t3+=LOOP_CYCLE_MS;
+			}
+
+			if (log->licz_t3 > log->nast_.licz_p)
+			{
+				o_n_L3 = 1;
+				log->licz_t3 = log->nast_.licz_p + (5*LOOP_CYCLE_MS);
+			}
+
+			if (o_W1_ON && o_W2_ON && o_W3_ON)
+			{
+				o_zd_ON = 1;
+				o_zd_OFF = 0;
+			}
+			else if (!o_W1_ON && !o_W2_ON && !o_W3_ON)
+			{
+				o_zd_ON = 0;
+				o_zd_OFF = 1;
+			}
+			else
+			{
+				o_zd_ON = 0;
+				o_zd_OFF = 0;
+			}
+
+			break;
+	default:
+		break;
+
+	}
+
+	if (o_W1_ON)
+		*log->wy_W1_ON |= log->wy_W1_ON_bit_mask;
+	else
+		*log->wy_W1_ON &= ~log->wy_W1_ON_bit_mask;
+
+	if (o_W2_ON)
+		*log->wy_W2_ON |= log->wy_W2_ON_bit_mask;
+	else
+		*log->wy_W2_ON &= ~log->wy_W2_ON_bit_mask;
+
+	if (o_W3_ON)
+		*log->wy_W3_ON |= log->wy_W3_ON_bit_mask;
+	else
+		*log->wy_W3_ON &= ~log->wy_W3_ON_bit_mask;
+
+	if (o_zd_ON)
+		*log->zd_W_ON |= log->zd_W_ON_bit_mask;
+	else
+		*log->zd_W_ON &= ~log->zd_W_ON_bit_mask;
+
+	if (o_zd_OFF)
+		*log->zd_W_OFF |= log->zd_W_OFF_bit_mask;
+	else
+		*log->zd_W_OFF &= ~log->zd_W_OFF_bit_mask;
+
+	if (o_n_L1)
+		*log->niezg_L1 |= log->niezg_L1_bit_mask;
+	else
+		*log->niezg_L1 &= ~log->niezg_L1_bit_mask;
+
+	if (o_n_L2)
+		*log->niezg_L2 |= log->niezg_L2_bit_mask;
+	else
+		*log->niezg_L2 &= ~log->niezg_L2_bit_mask;
+
+	if (o_n_L3)
+		*log->niezg_L3 |= log->niezg_L3_bit_mask;
+	else
+		*log->niezg_L3 &= ~log->niezg_L3_bit_mask;
+
+
+}

src/CBR.h

@@ -0,0 +1,96 @@
+/*
+ * CBR.h
+ *
+ *  Created on: 16-02-2017
+ *      Author: PS
+ */
+
+#ifndef CBR_H_
+#define CBR_H_
+
+
+//#include <stdint.h>
+#include "tdefs.h"
+
+struct Nastawy_przeliczone_CBR
+{
+    u32 licz_p;
+    u32 rodzaj;
+};
+
+struct CBR_logic
+{
+	u8* we_W1_ON;
+	u8 we_W1_ON_bit_mask;
+	u8* we_W2_ON;
+	u8 we_W2_ON_bit_mask;
+	u8* we_W3_ON;
+	u8 we_W3_ON_bit_mask;
+	u8* we_W1_OFF;
+	u8 we_W1_OFF_bit_mask;
+	u8* we_W2_OFF;
+	u8 we_W2_OFF_bit_mask;
+	u8* we_W3_OFF;
+	u8 we_W3_OFF_bit_mask;
+
+	u8* wy_W1_ON;
+	u8 wy_W1_ON_bit_mask;
+	u8* wy_W2_ON;
+	u8 wy_W2_ON_bit_mask;
+	u8* wy_W3_ON;
+	u8 wy_W3_ON_bit_mask;
+	u8* zd_W_ON;
+	u8 zd_W_ON_bit_mask;
+	u8* zd_W_OFF;
+	u8 zd_W_OFF_bit_mask;
+	u8* niezg_L1;
+	u8 niezg_L1_bit_mask;
+	u8* niezg_L2;
+	u8 niezg_L2_bit_mask;
+	u8* niezg_L3;
+	u8 niezg_L3_bit_mask;
+
+ struct Nastawy_przeliczone_CBR nast_;// struktura z parametramio
+
+ 	u32 licz_t1;
+    u32 licz_t2;
+ 	u32 licz_t3;
+
+};
+
+
+struct CBR_params
+{
+    u32 rodzaj;
+   	double to; ///< nastawa czasy dzialania
+}__attribute__((__packed__));
+
+struct CBR_io
+{
+	u32 we_W1_ON;
+	u32 we_W2_ON;
+	u32 we_W3_ON;
+	u32 we_W1_OFF;
+	u32 we_W2_OFF;
+	u32 we_W3_OFF;
+
+	u32 wy_W1_ON;
+	u32 wy_W2_ON;
+	u32 wy_W3_ON;
+	u32 zd_W_ON;
+	u32 zd_W_OFF;
+	u32 niezg_L1;
+	u32 niezg_L2;
+	u32 niezg_L3;
+}__attribute__((__packed__));
+
+struct CBR_args
+{
+	struct CBR_io io;
+	struct CBR_params params;
+}__attribute__((__packed__));
+
+extern void CBR(void *args, void *logic);
+extern int CBR_initlog(void *arguments, void *logic);
+
+#endif /* CBR_H_ */

src/Diff.h

@@ -0,0 +1,431 @@
+/*
+ * Diff.h
+ *
+ *  Created on: 12-04-2017
+ *      Author: Krzysztof Jakubczyk
+ */
+
+#ifndef DIFF_H_
+#define DIFF_H_
+
+#include "tdefs.h"
+#include "analog_in.h"
+#include "helper.h"
+#include "config.h"
+
+extern u16 pY_ZPrAE[25];
+extern u16 pD_ZPrAE[25];
+extern struct kom1_zprae Y2w_ZPrAE;
+extern struct kom2_zprae Y3w_ZPrAE;
+extern struct kom1_zprae D2w_ZPrAE;
+extern struct kom1_zprae D3w_ZPrAE;
+
+#define c1r 5 //ilosc powtorzen zadzialania bezwarunkowego
+#define c1p 30 //ilosc powtorzen odpadu bezwarunkowego
+#define c2r 2 //ilosc powtorzen zadzialania blokady 2h
+#define c2p 7 //ilosc powtorzen odpadu blokady 2h
+#define c3r 2 //ilosc powtorzen zadzialania blokady 5h
+#define c3p 10 //ilosc powtorzen odpadu blokady 5h
+#define c4r 5 //ilosc powtorzen zadzialania czasowej blokady
+#define c5r 20 //ilosc powtorzen zadzialania stabilizowanej strefy dzialania !!!!!!!!Pawel bylo 2
+#define c5p 2 //ilosc powtorzen odpadu stabilizowanej strefy dzialania
+
+	struct we_an_diff
+	{
+		u16 *samples_buf;
+		struct analog_in_params_extended *params;
+	};
+
+	struct licz
+	{
+		short l2h1[2];
+		short l2h2[2];
+		short l2h3[2];
+		short l5h1[2];
+		short l5h2[2];
+		short l5h3[2];
+		short Ir1[2];
+		short Ir2[2];
+		short Ir3[2];
+		short sbc1[2];
+		short sbc2[2];
+		short sbc3[2];
+		short chs1[2];
+		short chs2[2];
+		short chs3[2];
+
+	};
+
+	struct pobudzenia_czastkowe
+	{
+		u8 Irr1;
+		u8 Irr2;
+		u8 Irr3;
+		u8 Pb1;
+		u8 Ob1;
+		u8 BlZw1;
+		u8 Pb2;
+		u8 Ob2;
+		u8 BlZw2;
+		u8 Pb3;
+		u8 Ob3;
+		u8 BlZw3;
+		u8 Psf1;
+		u8 Psf2;
+		u8 Psf3;
+		u8 Bl2h_L1;
+		u8 Bl2h_L2;
+		u8 Bl2h_L3;
+		u8 Bl5h_L1;
+		u8 Bl5h_L2;
+		u8 Bl5h_L3;
+	};
+
+	struct wskazniki_prad_do_kompensacji
+	{
+		struct we_an_diff *Ip[4];
+		struct we_an_diff *Im[4];
+
+		float a_p[4][2];
+		float a_m[4][2];
+	};
+
+    struct Nastawy_przeliczone
+    {
+//		Adresy adr;
+
+		float khr_2h;///< wartosc rozruchowa blokady od 2 harmonicznej
+		float khp_2h;///< wartosc powrotowa blokady od 2 harmonicznej
+		float khr_5h;///< wartosc rozruchowa blokady od 5 harmonicznej
+		float khp_5h;///< wartosc powrotowa blokady od 5 harmonicznej
+		float Irr;///< wartosc rozruchowa dzialania bezwarunkowego
+		float Ipr;///< wartosc powrotowa dzialania bezwarunkowego
+		float Ihdr;///<wartosc rozruchowa pradu hamowania zwarcia zewnetrznego
+		float Irdr;///< wartosc rozruchowa pradu roznicowego zwarcia zewnetrznego
+		float kh1r;///<wartosc rozruchowa prosta 2
+		float kh1p;///<wartosc powrotowa prosta 2
+		float kh2r;///<wartosc rozruchowa prosta 3
+		float Ir3c;///< czesc stala nastawy odcinka 3
+		float Ip3c;///< czesc stala nastawy odcinka 3
+		float kh2p;///<wartosc powrotowa prosta 3
+		float kh1r2;///<wartosc rozruchowa prosta 2 (w kwadracie)
+		float kh1p2;///<wartosc powrotowa prosta 2 (w kwadracie)
+		float Iror;///<wartosc rozruchowa pradu prosta 1
+		float Irop;///<wartosc powrotowa pradu prosta 1
+		float Ir4;///< wartosc rozruchowa prosta 4
+		float Ip4;///< wartosc powrotowa prosta 4
+		float Ih1;///< wartosc pradu stabilizacji dla poczatku prostej 2
+		float Ihp;///< wartosc pradu stabilizacji dla poczatku prostej 3
+		float Ihg;///<wartosc pradu stabilizacji dla poczatku prostej 4
+		u16 t_sbc;///< czas blokady po stwierdzeniu zwarcia zewnetrznego
+        u32 tz; ///< opoznienie czasu zadzialania przekaznika
+		u8 on; ///< wartosc nastawy aktywnosci przekaznika 1- aktywny
+        u8 w; ///< wartosc nastawy dzialania na wylaczeniee 1 - wylaczenie 0 - tylko sygnalizacja
+        u8 bl; ///< wartosc nastawy aktywnosci blokady dzialania 1- blokada aktywna
+		u8 bl2h;///< wlaczenie blokady od drugiej harmonicznej
+		u8 bl5h;///< wlaczenie blokady od piatej harmonicznej
+		u8 sbc;///< wlaczenie strefy blokady czasowej
+		u8 h;///< wlaczenie granicznej stabilizacji
+		u8 r; ///< wlaczenie strefy bezwarunkowego wylaczenia
+		u8 cross_block; ///cross block do hrmonicznych
+		struct wskazniki_prad_do_kompensacji L[3]; ///< wskazniki pradow do wyliczenia skompensowanych wejsc faza 1,2,3
+		float a[4];///< wspolczynnik pradu do kompensacji
+		u16 buf_zero[SAMPLES_PER_MS*MAIN_FREQ_PERIOD_MS*2];
+		//WA::Nastawa_przeliczona n_zero;
+		//WA::Wyjscie wejscie_zero;
+		struct analog_in_params_extended n_zero;
+		struct we_an_diff wejscie_zero;
+
+		float wsp_filtr_sin_[SAMPLES_PER_MS*MAIN_FREQ_PERIOD_MS];
+		float wsp_filtr_cos_[SAMPLES_PER_MS*MAIN_FREQ_PERIOD_MS];
+		float wsp_filtr_sin2h_[SAMPLES_PER_MS*MAIN_FREQ_PERIOD_MS];
+		float wsp_filtr_cos2h_[SAMPLES_PER_MS*MAIN_FREQ_PERIOD_MS];
+		float wsp_filtr_sin5h_[SAMPLES_PER_MS*MAIN_FREQ_PERIOD_MS];
+		float wsp_filtr_cos5h_[SAMPLES_PER_MS*MAIN_FREQ_PERIOD_MS];
+		u8 p2d;
+		u8 p3d;
+#ifdef IZAZ600
+		u8 Rej3kHz_adr_wej_OK;
+#endif
+	};
+
+	struct wejscie_wew
+	{
+		float buf_Lr[SAMPLES_PER_MS*MAIN_FREQ_PERIOD_MS*2][6];
+		u8 nr_probki;
+		float orta[6];
+		float ortb[6];
+		float Ir[6];
+		float orta2h[3];
+		float ortb2h[3];
+		float I2h[3];
+		float orta5h[3];
+		float ortb5h[3];
+		float I5h[3];
+
+		float buf_ip[SAMPLES_PER_MS*MAIN_FREQ_PERIOD_MS*2][9];
+		float Ip[9];
+	};
+
+	enum typ_kompensacji
+	{
+		zero, ///< brak wejscia
+		A, /// 1,0,0	1
+		B, /// -1,0,0	0,57735
+		C, /// 1,-1,0	0,57735
+		D, /// -1,1,0	0,57735
+		E, /// 1,0,-1	0,57735
+		F, /// -1,0,1	0,57735
+		N, /// 0,1,0	1
+		O, /// 0,-1,0	1
+		U,
+		V,
+		W,
+		X,
+		Y,
+		Z
+	};
+
+	enum jaki_uklad
+	{
+		bez_GT, ///<blad nastaw (nastawy sprzeczne dzialanie jak odstawienie funkcji)
+		tylko_G, ///< tylko generator
+		tylko_T2w_Y, ///< tylko transformator z dwoma uzwojeniami gora w ukladzie Y
+		tylko_T2w_D, ///< tylko transformator z dwoma uzwojeniami gora w ukladzie D
+		tylko_T3w_Y, ///< tylko transformator z trzema uzwojeniami gora w ukladzie Y
+		tylko_T3w_D, ///< tylko transformator z trzema uzwojeniami gora w ukladzie D
+		blokGT_T2w_Y, ///< blok generator transformator z dwoma uzwojeniami gora w ukladzie Y
+		blokGT_T2w_D, ///< blok generator transformator z dwoma uzwojeniami gora w ukladzie D
+		blokGT_T3w_Y, ///< blok generator transformator z trzema uzwojeniami gora w ukladzie Y
+		blokGT_T3w_D ///< blok generator transformator z trzema uzwojeniami gora w ukladzie D
+	};
+
+	struct kompensacja
+	{
+		enum typ_kompensacji Ig; //prad gornej strony trafo
+		enum typ_kompensacji Id; //prad dolnej strony trafo
+		enum typ_kompensacji Io; //prad odczepu
+
+	};
+
+	struct kom1
+	{
+		struct kompensacja k[7];
+	};
+
+	struct kom1_zprae
+	{
+		struct kompensacja k[13];
+	};
+
+	struct kom2
+	{
+		struct kompensacja k[7][7];
+	};
+
+	struct kom2_zprae
+	{
+		struct kompensacja k[13][13];
+	};
+
+	struct nast_trafo
+	{
+		float PT12;///<przekladnia uzwojen 1-2 transformatora
+		float PT13;///<przekladnia uzwojen 1-3 transformatora
+
+		//u16 Tr_zas;///<strona zasilania ukladu zabezpieczenia rożnicowego
+		u16 GrP1; ///<fabryczna grupa polaczen uzwojen transformatora dla uzwojenia GN (1)
+		u16 GrP2; ///<fabryczna grupa polaczen uzwojen transformatora dla uzwojenia SN (2)
+		u16 GrP3; ///<fabryczna grupa polaczen uzwojen transformatora dla uzwojenia SN (3)
+	};
+
+	struct dane_wewnetrzne_Diff
+	{
+//		Wyjscia_rejestratora R; ///< dane ostatniego zaklocenia
+//		Time czas_; // moment wystapienia zaklocenia (rejestr tymczasowy - przed zapisem)
+		u32 dl_; // dlugosc czasu trwania zaklocenia (rejestr tymczasowy - przed zapisem)
+		float maxIr1; // maksymalna watosc pradu rożnicowego wejscia 1 (rejestr tymczasowy - przed zapisem)
+		float maxIr2; // maksymalna watosc pradu rożnicowego wejscia 2 (rejestr tymczasowy - przed zapisem)
+		float maxIr3; // maksymalna watosc pradu rożnicowego wejscia 3 (rejestr tymczasowy - przed zapisem)
+		float maxIh1; // maksymalna watosc pradu stabilizacji wejscia 1 (rejestr tymczasowy - przed zapisem)
+		float maxIh2; // maksymalna watosc pradu stabilizacji wejscia 2 (rejestr tymczasowy - przed zapisem)
+		float maxIh3; // maksymalna watosc pradu stabilizacji wejscia 3 (rejestr tymczasowy - przed zapisem)
+	    u32 licz_t; // licznik czasu od pobudzenia dla przekaznika czasowego
+		u8 wsk_rej; // nowy zapis rejestracji parametrow zaklocenia (spelnienie kryterium identyfikacji)
+		u8 sbc_P;
+ 	};
+
+
+struct diff_logic
+{
+	struct binary_io stan_bl;
+	u16 *I1_l1;
+	struct analog_in_params_extended *I1_l1_params;
+	u16 *I1_l2;
+	struct analog_in_params_extended *I1_l2_params;
+	u16 *I1_l3;
+	struct analog_in_params_extended *I1_l3_params;
+	u16 *I2_l1;
+	struct analog_in_params_extended *I2_l1_params;
+	u16 *I2_l2;
+	struct analog_in_params_extended *I2_l2_params;
+	u16 *I2_l3;
+	struct analog_in_params_extended *I2_l3_params;
+	u16 *I3_l1;
+	struct analog_in_params_extended *I3_l1_params;
+	u16 *I3_l2;
+	struct analog_in_params_extended *I3_l2_params;
+	u16 *I3_l3;
+	struct analog_in_params_extended *I3_l3_params;
+	u16 *I4_l1;
+	struct analog_in_params_extended *I4_l1_params;
+	u16 *I4_l2;
+	struct analog_in_params_extended *I4_l2_params;
+	u16 *I4_l3;
+	struct analog_in_params_extended *I4_l3_params;
+
+	struct binary_io test;
+
+	struct binary_io W;
+	struct binary_io Z;
+	struct binary_io P;
+	struct binary_io Pf1;
+	struct binary_io Pf2;
+	struct binary_io Pf3;
+	struct binary_io BL2h1;
+	struct binary_io BL2h2;
+	struct binary_io BL2h3;
+	struct binary_io BL5h1;
+	struct binary_io BL5h2;
+	struct binary_io BL5h3;
+	struct binary_io Zw1;
+	struct binary_io Zw2;
+	struct binary_io Zw3;
+	struct binary_io nieobs;
+	float *Ir1;
+	float *Ir2;
+	float *Ir3;
+	float *Ih1;
+	float *Ih2;
+	float *Ih3;
+	float *I2h1;
+	float *I2h2;
+	float *I2h3;
+	float *I5h1;
+	float *I5h2;
+	float *I5h3;
+	float *Ir_L1_ortb;
+	float *Ir_L2_ortb;
+	float *Ir_L3_ortb;
+//	float *Ih_L1_ortb;
+//	float *Ih_L2_ortb;
+//	float *Ih_L3_ortb;
+
+	enum jaki_uklad jaki_uklad;
+	struct dane_wewnetrzne_Diff dw;
+	struct licz l;
+	struct pobudzenia_czastkowe P_;
+	struct wejscie_wew w;
+    struct Nastawy_przeliczone nast_; // struktura z parametrami rozruchowymi
+	float Ir1_;
+	float Ir2_;
+	float Ir3_;
+	float Ih1_;
+	float Ih2_;
+	float Ih3_;
+
+	struct we_an_diff an_struct_i1_l1;
+	struct we_an_diff an_struct_i1_l2;
+	struct we_an_diff an_struct_i1_l3;
+	struct we_an_diff an_struct_i2_l1;
+	struct we_an_diff an_struct_i2_l2;
+	struct we_an_diff an_struct_i2_l3;
+	struct we_an_diff an_struct_i3_l1;
+	struct we_an_diff an_struct_i3_l2;
+	struct we_an_diff an_struct_i3_l3;
+	struct we_an_diff an_struct_i4_l1;
+	struct we_an_diff an_struct_i4_l2;
+	struct we_an_diff an_struct_i4_l3;
+
+//	float mul_I1[3];
+//	float mul_I2[3];
+//	float mul_I3[3];
+	//	struct Nastawy_przeliczone_Diff_1 nast_;
+};
+
+struct diff_io
+{
+	u32 stan_bl_in;
+	u32 ia_l1_ptr_in;
+	u32 ia_l1_params_ptr_in;
+	u32 ia_l2_ptr_in;
+	u32 ia_l2_params_ptr_in;
+	u32 ia_l3_ptr_in;
+	u32 ia_l3_params_ptr_in;
+	u32 ib_l1_ptr_in;
+	u32 ib_l1_params_ptr_in;
+	u32 ib_l2_ptr_in;
+	u32 ib_l2_params_ptr_in;
+	u32 ib_l3_ptr_in;
+	u32 ib_l3_params_ptr_in;
+	u32 ic_l1_ptr_in;
+	u32 ic_l1_params_ptr_in;
+	u32 ic_l2_ptr_in;
+	u32 ic_l2_params_ptr_in;
+	u32 ic_l3_ptr_in;
+	u32 ic_l3_params_ptr_in;
+	u32 id_l1_ptr_in;
+	u32 id_l1_params_ptr_in;
+	u32 id_l2_ptr_in;
+	u32 id_l2_params_ptr_in;
+	u32 id_l3_ptr_in;
+	u32 id_l3_params_ptr_in;
+	u32 test_in;
+
+	u32 w_out;
+	u32 z_out;
+	u32 p_out;
+	u32 pl1_out;
+	u32 pl2_out;
+	u32 pl3_out;
+	u32 bl_2h_L1_out;
+	u32 bl_2h_L2_out;
+	u32 bl_2h_L3_out;
+	u32 bl_5h_L1_out;
+	u32 bl_5h_L2_out;
+	u32 bl_5h_L3_out;
+	u32 zzew1_out;
+	u32 zzew2_out;
+	u32 zzew3_out;
+	u32 di_l1_float_out;
+	u32 di_l2_float_out;
+	u32 di_l3_float_out;
+	u32 ih_l1_float_out;
+	u32 ih_l2_float_out;
+	u32 ih_l3_float_out;
+	u32 i2h_l1_float_out;
+	u32 i2h_l2_float_out;
+	u32 i2h_l3_float_out;
+	u32 i5h_l1_float_out;
+	u32 i5h_l2_float_out;
+	u32 i5h_l3_float_out;
+	u32 ir_l1_ch_float_out;
+	u32 ir_l2_ch_float_out;
+	u32 ir_l3_ch_float_out;
+	u32 nieobs_out;
+//	u32 ih_l1_ch_float_out;
+//	u32 ih_l2_ch_float_out;
+//	u32 ih_l3_ch_float_out;
+}__attribute__((__packed__));
+
+
+extern int diff_init_io(struct diff_io *io, struct diff_logic *log);
+extern void kryterium2(struct diff_logic *log,float Ir, float Ih, u8 *pob);
+extern void kryterium3(struct diff_logic *log,float Ir, float Ih, u8 *pob);
+extern u8 kryterium1(short *licz, u8 pobudzenie, u8 powrot, u8 st, u16 powz, u16 powp);
+extern void przelicz_nastawy1(struct diff_logic *log,struct nast_trafo n);
+extern void przelicz_1200Hz_1(struct diff_logic *log);
+extern void przelicz_1200Hz_2(struct diff_logic *log);
+
+
+#endif /* DIFF_H_ */

src/Diff_1.c

@@ -0,0 +1,126 @@
+/*
+ * Diff_1.c
+ *
+ *  Created on: 01-03-2017
+ *      Author: Krzysztof Jakubczyk
+ */
+
+#include <math.h>
+
+#include "tdefs.h"
+#include "misc.h"
+
+#include "helper.h"
+#include "Diff.h"
+#include "Diff_1.h"
+
+int diff_1_initlog(void *arguments, void *logic)
+{
+	struct diff_1_args *args = (struct diff_1_args *)arguments;
+	struct diff_logic *log = (struct diff_logic *)logic;
+
+	if(diff_init_io(&args->io,log))
+		return -1;
+
+    log->nast_.on =  (args->params.bity & 0x0001)?1:0;
+    log->nast_.w =  (args->params.bity & 0x0002)?1:0;
+    log->nast_.bl =  (args->params.bity & 0x0004)?1:0;
+    log->nast_.bl2h =  (args->params.bity & 0x0008)?1:0;
+    log->nast_.bl5h =  (args->params.bity & 0x0010)?1:0;
+    log->nast_.sbc =  (args->params.bity & 0x0020)?1:0;
+    log->nast_.h =  (args->params.bity & 0x0040)?1:0;
+    log->nast_.r =  (args->params.bity & 0x0080)?1:0;
+    log->nast_.cross_block =  (args->params.bity & 0x0100)?1:0;
+
+	//ustawienie wartosci rozruchowych
+	log->nast_.khr_2h = args->params.k_2h * args->params.k_2h;
+	log->nast_.khp_2h = log->nast_.khr_2h * 0.98;//args->params.kp *args->params.kp;
+	log->nast_.khr_5h = args->params.k_5h * args->params.k_5h;
+	log->nast_.khp_5h = log->nast_.khr_5h * 0.98;//args->params.kp *args->params.kp;
+	log->nast_.Irr = args->params.Ir * 1.3577f;
+	log->nast_.Ipr = args->params.Ir * args->params.kp;
+	log->nast_.Ihdr = args->params.Ihd;
+	log->nast_.Irdr = args->params.rd;
+	log->nast_.kh1r = args->params.kh1;
+	log->nast_.kh1p = args->params.kh1 * args->params.kp;
+	log->nast_.kh2r = args->params.kh2;
+	log->nast_.kh2p = args->params.kh2 * args->params.kp;
+	log->nast_.Ir3c = args->params.Ihp * (args->params.kh1 - args->params.kh2);
+	log->nast_.Ip3c = log->nast_.Ir3c * args->params.kp;
+	log->nast_.Iror = args->params.Iro;
+	log->nast_.Irop = args->params.Iro * args->params.kp;
+	log->nast_.Ir4 = args->params.Ihg * args->params.kh2 + args->params.Ihp * (args->params.kh1 - args->params.kh2);
+	log->nast_.Ip4 = log->nast_.Ir4 * args->params.kp;
+	log->nast_.t_sbc = args->params.tbld * 1000;
+	log->nast_.Ih1 = args->params.Iro / args->params.kh1;
+	log->nast_.Ihp = args->params.Ihp;
+	log->nast_.Ihg = args->params.Ihg;
+
+	log->nast_.tz = args->params.t * 1000;
+
+//	log->nast_.ih_siemens = (args->params.Ih_typ == IH_SUM_IP) ? 1 : 0;
+//--------
+
+	struct nast_trafo n1;
+	n1.GrP1 = args->params.GrP1;
+	n1.GrP2 = args->params.GrP2;
+	n1.GrP3 = args->params.GrP3;
+	n1.PT12 = args->params.PT12;
+	n1.PT13 = args->params.PT13;
+//	n1.Tr_zas = args->params.Tr_zas;
+
+	przelicz_nastawy1(log,n1);
+
+	return 0;
+}
+
+void diff_1(void *arguments, void *logic)
+{
+	struct diff_logic *log = (struct diff_logic *)logic;
+
+    if(log->nast_.on)   // jesli zabezpieczenie aktywne
+    {
+		przelicz_1200Hz_1(log);
+
+		//Sprawdzenie pobudzenia w stabilizowanej strefie dzialania
+		kryterium2(log,log->Ir1_,log->Ih1_,&log->P_.Pb1);
+		kryterium2(log,log->Ir2_,log->Ih2_,&log->P_.Pb2);
+		kryterium2(log,log->Ir3_,log->Ih3_,&log->P_.Pb3);
+
+		przelicz_1200Hz_2(log);
+	} else {
+		*log->Ir1=0;
+		*log->Ir2=0;
+		*log->Ir3=0;
+		*log->Ih1=0;
+		*log->Ih2=0;
+		*log->Ih3=0;
+		*log->Ir_L1_ortb=0;
+		*log->Ir_L2_ortb=0;
+		*log->Ir_L3_ortb=0;
+	//	*log->Ih_L1_ortb=0;
+	  //*log->Ih_L2_ortb=0;
+	  //*log->Ih_L3_ortb=0;
+		*log->I2h1=0;
+		*log->I2h2=0;
+		*log->I2h3=0;
+		*log->I5h1=0;
+		*log->I5h2=0;
+		*log->I5h3=0;
+		clear_struct(&log->P);
+		clear_struct(&log->Pf1);
+		clear_struct(&log->Pf2);
+		clear_struct(&log->Pf3);
+		clear_struct(&log->W);
+		clear_struct(&log->Z);
+		clear_struct(&log->Zw1);
+		clear_struct(&log->Zw2);
+		clear_struct(&log->Zw3);
+		clear_struct(&log->BL2h1);
+		clear_struct(&log->BL2h2);
+		clear_struct(&log->BL2h3);
+		clear_struct(&log->BL5h1);
+		clear_struct(&log->BL5h2);
+		clear_struct(&log->BL5h3);
+	}
+}

src/Diff_1.h

@@ -0,0 +1,52 @@
+/*
+ * Diff_1.h
+ *
+ *  Created on: 01-03-2017
+ *      Author: Krzysztof Jakubczyk
+ */
+
+#ifndef DIFF_1_H_
+#define DIFF_1_H_
+
+#include "Diff.h"
+
+#include "tdefs.h"
+
+struct diff_1_params
+{
+	u32 bity; ///< nastawy bitowe;
+
+//	u32 Tr_zas;///<strona zasilania ukladu zabezpieczenia rożnicowego
+	u32 GrP1; ///<fabryczna grupa polaczen uzwojen transformatora dla uzwojenia GN (1)
+	u32 GrP2; ///<fabryczna grupa polaczen uzwojen transformatora dla uzwojenia SN (2)
+	u32 GrP3; ///<fabryczna grupa polaczen uzwojen transformatora dla uzwojenia SN (3)
+
+	double Iro;///< poczatkowy prad rozruchowy
+	double Ir;///< graniczny prad rozruchowy
+	double Ihg; ///< graniczny prad stabilizacji
+	double Ihp;///< prad hamujacy przegiecia
+	double Ihd;///< prad rozruchowy blokady czasowej pradu stabilizujacego
+	double tbld; ///< czas blokady dzialania po opuszczeniu strefy blokady czasowej
+	double rd; ///< przesuniecie strefy blokady czasowej od strefy dzialania
+	double kh1;///< wspolczynnik stabilizacji prosta 2
+	double kh2; ///< wspolczynnik stabilizacji prosta 3
+	double t;///< czas opoznienia dzialania
+	double kp;///< wspolczynnik powrotu
+	double k_2h;///< wspolczynnik blokowania druga harmoniczna
+	double k_5h;///< wspolczynnik blokowania piata harmoniczna
+	double PT12;///<przekladnia uzwojen 1-2 transformatora
+	double PT13;///<przekladnia uzwojen 1-3 transformatora
+
+}__attribute__((__packed__));
+
+struct diff_1_args
+{
+	struct diff_io io;
+	struct diff_1_params params;
+//	u16 crc;
+}__attribute__((__packed__));
+
+extern void diff_1(void *args, void *logic);
+extern int diff_1_initlog(void *arguments, void *logic);
+
+#endif /* DIFF_1_H_ */

src/Diff_1_bis.h

@@ -0,0 +1,249 @@
+/*
+ * Diff_1.h
+ *
+ *  Created on: 01-03-2017
+ *      Author: Krzysztof Jakubczyk
+ */
+
+#ifndef DIFF_1_BIS_H_
+#define DIFF_1_BIS_H_
+
+#include "Diff.h"
+
+//#include "pawel_usun_to.h"
+
+
+#include "tdefs.h"
+
+
+extern u16 pY_ZPrAE[25];
+extern u16 pD_ZPrAE[25];
+extern struct kom1_zprae Y2w_ZPrAE;
+extern struct kom2_zprae Y3w_ZPrAE;
+extern struct kom1_zprae D2w_ZPrAE;
+extern struct kom1_zprae D3w_ZPrAE;
+
+#define c1r 5 //ilosc powtorzen zadzialania bezwarunkowego
+#define c1p 30 //ilosc powtorzen odpadu bezwarunkowego
+#define c2r 2 //ilosc powtorzen zadzialania blokady 2h
+#define c2p 7 //ilosc powtorzen odpadu blokady 2h
+#define c3r 2 //ilosc powtorzen zadzialania blokady 5h
+#define c3p 10 //ilosc powtorzen odpadu blokady 5h
+#define c4r 5 //ilosc powtorzen zadzialania czasowej blokady
+#define c5r 20 //ilosc powtorzen zadzialania stabilizowanej strefy dzialania !!!!!!!!Pawel bylo 2
+#define c5p 2 //ilosc powtorzen odpadu stabilizowanej strefy dzialania
+
+struct diff_1_bis_io
+{
+	u32 stan_bl_in;
+	u32 ia_l1_ptr_in;
+	u32 ia_l1_params_ptr_in;
+	u32 ia_l2_ptr_in;
+	u32 ia_l2_params_ptr_in;
+	u32 ia_l3_ptr_in;
+	u32 ia_l3_params_ptr_in;
+	u32 ib_l1_ptr_in;
+	u32 ib_l1_params_ptr_in;
+	u32 ib_l2_ptr_in;
+	u32 ib_l2_params_ptr_in;
+	u32 ib_l3_ptr_in;
+	u32 ib_l3_params_ptr_in;
+	u32 ic_l1_ptr_in;
+	u32 ic_l1_params_ptr_in;
+	u32 ic_l2_ptr_in;
+	u32 ic_l2_params_ptr_in;
+	u32 ic_l3_ptr_in;
+	u32 ic_l3_params_ptr_in;
+	
+	/*
+	u32 id_l1_ptr_in;
+	u32 id_l1_params_ptr_in;
+	u32 id_l2_ptr_in;
+	u32 id_l2_params_ptr_in;
+	u32 id_l3_ptr_in;
+	u32 id_l3_params_ptr_in;
+	*/
+	
+	u32 test_in;
+
+	u32 w_out;
+	u32 z_out;
+	u32 p_out;
+	u32 pl1_out;
+	u32 pl2_out;
+	u32 pl3_out;
+	u32 bl_2h_L1_out;
+	u32 bl_2h_L2_out;
+	u32 bl_2h_L3_out;
+	u32 bl_5h_L1_out;
+	u32 bl_5h_L2_out;
+	u32 bl_5h_L3_out;
+	u32 zzew1_out;
+	u32 zzew2_out;
+	u32 zzew3_out;
+	u32 di_l1_float_out;
+	u32 di_l2_float_out;
+	u32 di_l3_float_out;
+	u32 ih_l1_float_out;
+	u32 ih_l2_float_out;
+	u32 ih_l3_float_out;
+	u32 i2h_l1_float_out;
+	u32 i2h_l2_float_out;
+	u32 i2h_l3_float_out;
+	u32 i5h_l1_float_out;
+	u32 i5h_l2_float_out;
+	u32 i5h_l3_float_out;
+	u32 ir_l1_ch_float_out;
+	u32 ir_l2_ch_float_out;
+	u32 ir_l3_ch_float_out;
+	u32 nieobs_out;
+	u32 pob_bezwar_out;
+//	u32 ih_l1_ch_float_out;
+//	u32 ih_l2_ch_float_out;
+//	u32 ih_l3_ch_float_out;
+}__attribute__((__packed__));
+
+struct diff_1_bis_logic
+{
+	struct binary_io stan_bl;
+	u16 *I1_l1;
+	struct analog_in_params_extended *I1_l1_params;
+	u16 *I1_l2;
+	struct analog_in_params_extended *I1_l2_params;
+	u16 *I1_l3;
+	struct analog_in_params_extended *I1_l3_params;
+	u16 *I2_l1;
+	struct analog_in_params_extended *I2_l1_params;
+	u16 *I2_l2;
+	struct analog_in_params_extended *I2_l2_params;
+	u16 *I2_l3;
+	struct analog_in_params_extended *I2_l3_params;
+	u16 *I3_l1;
+	struct analog_in_params_extended *I3_l1_params;
+	u16 *I3_l2;
+	struct analog_in_params_extended *I3_l2_params;
+	u16 *I3_l3;
+	struct analog_in_params_extended *I3_l3_params;
+	/*
+	u16 *I4_l1;
+	struct analog_in_params_extended *I4_l1_params;
+	u16 *I4_l2;
+	struct analog_in_params_extended *I4_l2_params;
+	u16 *I4_l3;
+	struct analog_in_params_extended *I4_l3_params;
+	*/
+	struct binary_io test;
+
+	struct binary_io W;
+	struct binary_io Z;
+	struct binary_io P;
+	struct binary_io Pf1;
+	struct binary_io Pf2;
+	struct binary_io Pf3;
+	struct binary_io BL2h1;
+	struct binary_io BL2h2;
+	struct binary_io BL2h3;
+	struct binary_io BL5h1;
+	struct binary_io BL5h2;
+	struct binary_io BL5h3;
+	struct binary_io Zw1;
+	struct binary_io Zw2;
+	struct binary_io Zw3;
+	struct binary_io nieobs;
+	struct binary_io pob_bezwar;
+	float *Ir1;
+	float *Ir2;
+	float *Ir3;
+	float *Ih1;
+	float *Ih2;
+	float *Ih3;
+	float *I2h1;
+	float *I2h2;
+	float *I2h3;
+	float *I5h1;
+	float *I5h2;
+	float *I5h3;
+	float *Ir_L1_ortb;
+	float *Ir_L2_ortb;
+	float *Ir_L3_ortb;
+//	float *Ih_L1_ortb;
+//	float *Ih_L2_ortb;
+//	float *Ih_L3_ortb;
+
+	enum jaki_uklad jaki_uklad;
+	struct dane_wewnetrzne_Diff dw;
+	struct licz l;
+	struct pobudzenia_czastkowe P_;
+	struct wejscie_wew w;
+    struct Nastawy_przeliczone nast_; // struktura z parametrami rozruchowymi
+	
+	float Irr2;
+	float Irr2_p;
+	float Ir1_;
+	float Ir2_;
+	float Ir3_;
+	float Ih1_;
+	float Ih2_;
+	float Ih3_;
+
+	u8 algorytm;
+
+	struct we_an_diff an_struct_i1_l1;
+	struct we_an_diff an_struct_i1_l2;
+	struct we_an_diff an_struct_i1_l3;
+	struct we_an_diff an_struct_i2_l1;
+	struct we_an_diff an_struct_i2_l2;
+	struct we_an_diff an_struct_i2_l3;
+	struct we_an_diff an_struct_i3_l1;
+	struct we_an_diff an_struct_i3_l2;
+	struct we_an_diff an_struct_i3_l3;
+	struct we_an_diff an_struct_i4_l1;
+	struct we_an_diff an_struct_i4_l2;
+	struct we_an_diff an_struct_i4_l3;
+
+//	float mul_I1[3];
+//	float mul_I2[3];
+//	float mul_I3[3];
+	//	struct Nastawy_przeliczone_Diff_1 nast_;
+};
+
+
+struct diff_1_bis_params
+{
+	u32 bity; ///< nastawy bitowe;
+
+//	u32 Tr_zas;///<strona zasilania ukladu zabezpieczenia ro¿nicowego
+	u32 GrP1; ///<fabryczna grupa polaczen uzwojen transformatora dla uzwojenia GN (1)
+	u32 GrP2; ///<fabryczna grupa polaczen uzwojen transformatora dla uzwojenia SN (2)
+	u32 GrP3; ///<fabryczna grupa polaczen uzwojen transformatora dla uzwojenia SN (3)
+
+	double Iro;///< poczatkowy prad rozruchowy
+	double Ir;///< graniczny prad rozruchowy
+	double Ihg; ///< graniczny prad stabilizacji
+	double Ihp;///< prad hamujacy przegiecia
+	double Ihd;///< prad rozruchowy blokady czasowej pradu stabilizujacego
+	double tbld; ///< czas blokady dzialania po opuszczeniu strefy blokady czasowej
+	double rd; ///< przesuniecie strefy blokady czasowej od strefy dzialania
+	double kh1;///< wspolczynnik stabilizacji prosta 2
+	double kh2; ///< wspolczynnik stabilizacji prosta 3
+	double t;///< czas opoznienia dzialania
+	double kp;///< wspolczynnik powrotu
+	double k_2h;///< wspolczynnik blokowania druga harmoniczna
+	double k_5h;///< wspolczynnik blokowania piata harmoniczna
+	double PT12;///<przekladnia uzwojen 1-2 transformatora
+	double PT13;///<przekladnia uzwojen 1-3 transformatora
+
+}__attribute__((__packed__));
+
+struct diff_1_bis_args
+{
+	struct diff_1_bis_io io;
+	struct diff_1_bis_params params;
+//	u16 crc;
+}__attribute__((__packed__));
+
+
+extern void diff_1_bis(void *args, void *logic);
+extern int diff_1_bis_initlog(void *arguments, void *logic);
+
+#endif /* DIFF_1_BIS_H_ */

src/Diff_2.c

@@ -0,0 +1,124 @@
+/*
+ * Diff_2.c
+ *
+ *  Created on: 08-05-2017
+ *      Author: Krzysztof Jakubczyk
+ */
+
+#include <math.h>
+
+#include "tdefs.h"
+#include "misc.h"
+
+#include "helper.h"
+#include "Diff.h"
+#include "Diff_2.h"
+
+int diff_2_initlog(void *arguments, void *logic)
+{
+	struct diff_2_args *args = (struct diff_2_args *)arguments;
+	struct diff_logic *log = (struct diff_logic *)logic;
+
+	if(diff_init_io(&args->io,log))
+		return -1;
+
+    log->nast_.on =  (args->params.bity & 0x0001)?1:0;
+    log->nast_.w =  (args->params.bity & 0x0002)?1:0;
+    log->nast_.bl =  (args->params.bity & 0x0004)?1:0;
+    log->nast_.bl2h =  (args->params.bity & 0x0008)?1:0;
+    log->nast_.bl5h =  (args->params.bity & 0x0010)?1:0;
+    log->nast_.sbc =  (args->params.bity & 0x0020)?1:0;
+    log->nast_.h =  (args->params.bity & 0x0040)?1:0;
+    log->nast_.r =  (args->params.bity & 0x0080)?1:0;
+
+	//ustawienie wartosci rozruchowych
+	log->nast_.khr_2h = args->params.k_2h * args->params.k_2h;
+	log->nast_.khp_2h = log->nast_.khr_2h * args->params.kp *args->params.kp;
+	log->nast_.khr_5h = args->params.k_5h * args->params.k_5h;
+	log->nast_.khp_5h = log->nast_.khr_5h * args->params.kp *args->params.kp;
+	log->nast_.Irr = args->params.Ir * 1.3577f;
+	log->nast_.Ipr = args->params.Ir * args->params.kp;
+	log->nast_.Ihdr = args->params.Ihd;
+	log->nast_.Irdr = args->params.rd;
+	log->nast_.kh1r = args->params.kh1;
+	log->nast_.kh1p = log->nast_.kh1r * args->params.kp;
+
+	log->nast_.kh1r2 = args->params.kh1 * args->params.kh1;
+	log->nast_.kh1p2 = log->nast_.kh1r2 * args->params.kp * args->params.kp;
+	log->nast_.Ir4 = args->params.Ihg * args->params.kh1 * args->params.Ihg * args->params.kh1 + args->params.Iro * args->params.Iro;
+	log->nast_.Ip4 = log->nast_.Ir4 * args->params.kp * args->params.kp;
+	log->nast_.Iror = args->params.Iro * args->params.Iro;
+	log->nast_.Irop = log->nast_.Iror * args->params.kp * args->params.kp;
+	log->nast_.t_sbc = args->params.tbld * 1000;
+	log->nast_.Ihg = args->params.Ihg * args->params.Ihg;
+
+	log->nast_.tz = args->params.t * 1000;
+
+
+	//--------
+
+	struct nast_trafo n1;
+	n1.GrP1 = args->params.GrP1;
+	n1.GrP2 = args->params.GrP2;
+	n1.GrP3 = args->params.GrP3;
+	n1.PT12 = args->params.PT12;
+	n1.PT13 = args->params.PT13;
+	//n1.Tr_zas = args->params.Tr_zas;
+
+	przelicz_nastawy1(log,n1);
+
+	return 0;
+}
+
+void diff_2(void *arguments, void *logic)
+{
+	struct diff_logic *log = (struct diff_logic *)logic;
+
+    if(log->nast_.on)   // jesli zabezpieczenie aktywne
+    {
+		przelicz_1200Hz_1(log);
+
+		//Sprawdzenie pobudzenia w stabilizowanej strefie dzialania
+
+
+		kryterium3(log,log->Ir1_,log->Ih1_,&log->P_.Pb1);
+		kryterium3(log,log->Ir2_,log->Ih2_,&log->P_.Pb2);
+		kryterium3(log,log->Ir3_,log->Ih3_,&log->P_.Pb3);
+
+		przelicz_1200Hz_2(log);
+	} else {
+		*log->Ir1=0;
+		*log->Ir2=0;
+		*log->Ir3=0;
+		*log->Ih1=0;
+		*log->Ih2=0;
+		*log->Ih3=0;
+		*log->Ir_L1_ortb=0;
+		*log->Ir_L2_ortb=0;
+		*log->Ir_L3_ortb=0;
+		//*log->Ih_L1_ortb=0;
+		//*log->Ih_L2_ortb=0;
+		//*log->Ih_L3_ortb=0;
+		*log->I2h1=0;
+		*log->I2h2=0;
+		*log->I2h3=0;
+		*log->I5h1=0;
+		*log->I5h2=0;
+		*log->I5h3=0;
+		clear_struct(&log->P);
+		clear_struct(&log->Pf1);
+		clear_struct(&log->Pf2);
+		clear_struct(&log->Pf3);
+		clear_struct(&log->W);
+		clear_struct(&log->Z);
+		clear_struct(&log->Zw1);
+		clear_struct(&log->Zw2);
+		clear_struct(&log->Zw3);
+		clear_struct(&log->BL2h1);
+		clear_struct(&log->BL2h2);
+		clear_struct(&log->BL2h3);
+		clear_struct(&log->BL5h1);
+		clear_struct(&log->BL5h2);
+		clear_struct(&log->BL5h3);
+	}
+}

src/Diff_2.h

@@ -0,0 +1,49 @@
+/*
+ * Diff_2.h
+ *
+ *  Created on: 08-05-2017
+ *      Author: Krzysztof Jakubczyk
+ */
+
+#ifndef DIFF_2_H_
+#define DIFF_2_H_
+
+#include "Diff.h"
+
+#include "tdefs.h"
+
+struct diff_2_params
+{
+	u32 bity; ///< nastawy bitowe;
+
+	u32 Tr_zas;///<strona zasilania ukladu zabezpieczenia rożnicowego
+	u32 GrP1; ///<fabryczna grupa polaczen uzwojen transformatora dla uzwojenia GN (1)
+	u32 GrP2; ///<fabryczna grupa polaczen uzwojen transformatora dla uzwojenia SN (2)
+	u32 GrP3; ///<fabryczna grupa polaczen uzwojen transformatora dla uzwojenia SN (3)
+
+	double Iro;///< poczatkowy prad rozruchowy
+	double Ir;///< graniczny prad rozruchowy
+	double Ihg; ///< graniczny prad stabilizacji
+	double Ihd;///< prad rozruchowy blokady czasowej pradu stabilizujacego
+	double tbld; ///< czas blokady dzialania po opuszczeniu strefy blokady czasowej
+	double rd; ///< przesuniecie strefy blokady czasowej od strefy dzialania
+	double kh1;///< wspolczynnik stabilizacji prosta 2
+	double t;///< czas opoznienia dzialania
+	double kp;///< wspolczynnik powrotu
+	double k_2h;///< wspolczynnik blokowania druga harmoniczna
+	double k_5h;///< wspolczynnik blokowania piata harmoniczna
+	double PT12;///<przekladnia uzwojen 1-2 transformatora
+	double PT13;///<przekladnia uzwojen 1-3 transformatora
+}__attribute__((__packed__));
+
+struct diff_2_args
+{
+	struct diff_io io;
+	struct diff_2_params params;
+//	u16 crc;
+}__attribute__((__packed__));
+
+extern void diff_2(void *args, void *logic);
+extern int diff_2_initlog(void *arguments, void *logic);
+
+#endif /* DIFF_1_H_ */

src/LMZ.c

@@ -0,0 +1,791 @@
+/*
+ * LMZ.c
+ *
+ *  Created on: 23-05-2017
+ *      Author: Krzysztof Jakubczyk
+ */
+
+#include <math.h>
+
+#include "tdefs.h"
+#include "misc.h"
+
+#include "helper.h"
+#include "LMZ.h"
+
+
+int LMZ_initlog(void *arguments, void *logic)
+{
+	struct LMZ_args *args = (struct LMZ_args *)arguments;
+	struct LMZ_logic *log = (struct LMZ_logic *)logic;
+	struct analog_in_params *pwi,*pwu,*pwio2;
+
+	if(set_pointer_in_ptr(args->io.we_zdist_ptr_in,(u32 *)&log->nast_.WYA))
+		return -1;
+
+	if(set_bit_ptr_struct(args->io.we_zdistl_p1_in,&log->WE_ZDistL_Pzf[0]))
+		return -1;
+	if(set_bit_ptr_struct(args->io.we_zdistl_p1w_in,&log->WE_ZDistL_Pzf[1]))
+		return -1;
+
+	if(set_float_ptr(args->io.ioii_orta_float_in,&log->IoII_orta))
+		return -1;
+	if(set_float_ptr(args->io.ioii_ortb_float_in,&log->IoII_ortb))
+		return -1;
+	if(set_pointer_in_ptr(args->io.ioii_params_ptr_in,(u32 *)&log->IoII_params))
+		return -1;
+
+	if(set_bit_ptr_struct(args->io.clr_in,&log->clr))
+		return -1;
+	if(set_bit_ptr_struct(args->io.p_out,&log->P))
+		return -1;
+	if(set_float_ptr(args->io.distance_float_out,&log->distance))
+		return -1;
+ 
+	#ifdef LMZ_DEBUG
+	if(set_float_ptr(args->io.debug_out,&log->debug))
+		return -1;
+	if(set_float_ptr(args->io.debug1_out,&log->debug1))
+		return -1;   
+	if(set_float_ptr(args->io.debug2_out,&log->debug2))
+		return -1;    
+ 	if(set_float_ptr(args->io.debug3_out,&log->debug3))
+		return -1;   
+	if(set_float_ptr(args->io.debug4_out,&log->debug4))
+		return -1; 
+	#endif
+  log->nast_.on_ = (args->params.bity & 0x0001) ? 1 : 0;
+	log->nast_.L2t = (args->params.bity & 0x0002) ? 1 : 0;
+
+
+	pwu = log->nast_.WYA->Zdist_dw->log_ptr->param_U;
+	pwi = log->nast_.WYA->Zdist_dw->log_ptr->param_I;
+	pwio2 = log->IoII_params;
+
+
+	log->nast_.a.r = args->params.R1 * pwi->znam_pierw / pwu->znam_pierw;
+	log->nast_.a.i = -args->params.X1 * pwi->znam_pierw / pwu->znam_pierw;
+	log->nast_.b.r = (args->params.R0 - args->params.R1) * pwi->znam_pierw / pwu->znam_pierw;
+	log->nast_.b.i = -(args->params.X0 - args->params.X1) * pwi->znam_pierw / pwu->znam_pierw;
+	log->nast_.c.r = args->params.Rm * pwio2->znam_pierw / pwu->znam_pierw;
+	log->nast_.c.i = -args->params.Xm * pwio2->znam_pierw / pwu->znam_pierw;
+
+  log->nast_.kziem.r = ((args->params.R0 / args->params.R1)-1)/3;
+  log->nast_.kziem.i = -((args->params.X0 / args->params.X1)-1)/3;
+
+	if(log->nast_.L2t==0)
+	{
+		log->nast_.c.r = 0;
+		log->nast_.c.i = 0;
+	}
+
+
+	return 0;
+}
+
+/**
+Wylicza iloczyn dwoch liczb zespolonych
+*/
+struct zespolona p_z(struct zespolona *a,
+					 struct zespolona *b)
+{
+	struct zespolona result;
+	result.r = a->r * b->r - a->i * b->i;
+	result.i = a->r * b->i + a->i * b->r;
+	return(result);
+}
+
+/**
+Wylicza iloczyn dwoch liczb zespolonych
+*/
+struct zespolona dziel(struct zespolona *a,
+					 struct zespolona *b)
+{
+	struct zespolona result;
+	result.r = ((a->r * b->r) + (a->i * b->i))/((b->r * b->r) +(b->i * b->i));
+	result.i = ((a->i * b->r) - (a->r * b->i))/((b->r * b->r) +(b->i * b->i));
+	return(result);
+}
+
+/**
+Wylicza dane dla odlegoci w ptli jednofazowej
+*/
+float
+wylicz_dane_1f(struct LMZ_logic *log,
+	u16 nr_pr,	//indeks pooenia wektora wyliczanych danych w buforze
+	u16 nr_I //numer prdu wejciowego
+)
+{
+	struct zespolona temp;
+	struct zespolona loc1,loc2,loc3;
+	struct zespolona *i1,*ip;
+	float loc4;
+
+  struct zespolona imped;
+  struct zespolona k3io;
+
+
+	i1 = &log->dw.dp[nr_pr].IL1 + nr_I;
+	ip = &log->dw.Im[nr_pr % (MAIN_FREQ_PERIOD_MS/LOOP_CYCLE_MS)].IL1 + nr_I;
+
+	loc4 = (float)1.0 / (i1->r * i1->r + i1->i * i1->i);
+	loc1.r = i1->r * loc4;
+	loc1.i = (-i1->i) * loc4;
+
+	loc2 = p_z(&log->dw.dp[nr_pr].Io,&log->nast_.b);
+	loc3 = p_z(&log->dw.dp[nr_pr].Io2,&log->nast_.c);
+	loc2.r += loc3.r;
+	loc2.i += loc3.i;
+	loc3 = p_z(&loc2,&loc1);
+	log->dw.zz.r = log->nast_.a.r - loc3.r;
+	log->dw.zz.i = log->nast_.a.i - loc3.i;
+
+	log->dw.zi = *i1;
+
+	log->dw.zibis.r = i1->r - ip->r;
+	log->dw.zibis.i = i1->i - ip->i;
+ 
+  float ignac = 1;
+
+	temp = p_z(&log->dw.zz,&log->dw.zi);
+	
+  float wynik = ( ignac * (log->dw.zu.i * log->dw.zibis.r - log->dw.zu.r * log->dw.zibis.i )
+			/ (temp.i * log->dw.zibis.r - temp.r * log->dw.zibis.i ));
+      
+  return wynik;
+
+}
+
+
+/**
+Wylicza dane dla odlegoci w ptli midzyfazowej
+*/
+float wylicz_dane_mf(struct LMZ_logic *log,
+	u16 nr_pr,	//indeks pooenia wektora wyliczanych danych w buforze
+	u16 nr_I1, //numer prdu wejciowego 1
+	u16 nr_I2 //numer prdu wejciowego 2
+)
+{
+	struct zespolona temp;
+	struct zespolona *i1,*ip1;
+	struct zespolona *i2,*ip2;
+
+	i1 = &log->dw.dp[nr_pr].IL1 + nr_I1;
+	ip1 = &log->dw.Im[nr_pr % (MAIN_FREQ_PERIOD_MS/LOOP_CYCLE_MS)].IL1 + nr_I1;
+	i2 = &log->dw.dp[nr_pr].IL1 + nr_I2;
+	ip2 = &log->dw.Im[nr_pr % (MAIN_FREQ_PERIOD_MS/LOOP_CYCLE_MS)].IL1 + nr_I2;
+
+	log->dw.zz = log->nast_.a;
+
+	log->dw.zi.r = i1->r - i2->r;
+	log->dw.zi.i = i1->i - i2->i;
+
+	log->dw.zibis.r = i1->r - i2->r - ip1->r + ip2->r;
+	log->dw.zibis.i = i1->i - i2->i - ip1->i + ip2->i;
+
+	temp = p_z(&log->dw.zz,&log->dw.zi);
+
+	return( (log->dw.zu.i * log->dw.zibis.r - log->dw.zu.r * log->dw.zibis.i )
+			/ (temp.i * log->dw.zibis.r - temp.r * log->dw.zibis.i ));
+
+}
+
+void zapisz_p(struct LMZ_logic *log)
+{
+	float *wsk;
+	int i;
+
+	log->dw.wsk_buf++;
+
+	for(i=0;i<6;i++)
+	{
+		log->dw.P[log->dw.wsk_buf][i] = (log->nast_.WYA->Zdist_dw->P[0][i] || log->nast_.WYA->Zdist_dw->P[1][i])?1:0;
+	}
+
+	wsk = &log->dw.dp[log->dw.wsk_buf].IL1.r;
+	*wsk = *log->nast_.WYA->Zdist_dw->log_ptr->I1_orta;
+	wsk++;
+	*wsk = *log->nast_.WYA->Zdist_dw->log_ptr->I1_ortb;
+	wsk++;
+	*wsk = *log->nast_.WYA->Zdist_dw->log_ptr->I2_orta;
+	wsk++;
+	*wsk = *log->nast_.WYA->Zdist_dw->log_ptr->I2_ortb;
+	wsk++;
+	*wsk = *log->nast_.WYA->Zdist_dw->log_ptr->I3_orta;
+	wsk++;
+	*wsk = *log->nast_.WYA->Zdist_dw->log_ptr->I3_ortb;
+	wsk++;
+	*wsk = -*log->nast_.WYA->Zdist_dw->log_ptr->sI0_orta;//poprawiono
+	wsk++;
+	*wsk = -*log->nast_.WYA->Zdist_dw->log_ptr->sI0_ortb;//poprawiono
+	wsk++;
+	*wsk = *log->IoII_orta;
+	wsk++;
+	*wsk = *log->IoII_ortb;
+	wsk++;
+	*wsk = *log->nast_.WYA->Zdist_dw->log_ptr->U1_orta;
+	wsk++;
+	*wsk = *log->nast_.WYA->Zdist_dw->log_ptr->U1_ortb;
+	wsk++;
+	*wsk = *log->nast_.WYA->Zdist_dw->log_ptr->U2_orta;
+	wsk++;
+	*wsk = *log->nast_.WYA->Zdist_dw->log_ptr->U2_ortb;
+	wsk++;
+	*wsk = *log->nast_.WYA->Zdist_dw->log_ptr->U3_orta;
+	wsk++;
+	*wsk = *log->nast_.WYA->Zdist_dw->log_ptr->U3_ortb;
+	wsk++;
+	*wsk = *log->nast_.WYA->Zdist_dw->log_ptr->U12_orta;
+	wsk++;
+	*wsk = *log->nast_.WYA->Zdist_dw->log_ptr->U12_ortb;
+	wsk++;
+	*wsk = *log->nast_.WYA->Zdist_dw->log_ptr->U23_orta;
+	wsk++;
+	*wsk = *log->nast_.WYA->Zdist_dw->log_ptr->U23_ortb;
+	wsk++;
+	*wsk = *log->nast_.WYA->Zdist_dw->log_ptr->U31_orta;
+	wsk++;
+	*wsk = *log->nast_.WYA->Zdist_dw->log_ptr->U31_ortb;
+}
+
+void zapisz_pre(struct LMZ_logic *log)
+{
+	float *wsk;
+
+	wsk = &log->dw.Ip[log->dw.wsk_buf_pre].IL1.r;
+	*wsk = *log->nast_.WYA->Zdist_dw->log_ptr->I1_orta;
+	wsk++;
+	*wsk = *log->nast_.WYA->Zdist_dw->log_ptr->I1_ortb;
+	wsk++;
+	*wsk = *log->nast_.WYA->Zdist_dw->log_ptr->I2_orta;
+	wsk++;
+	*wsk = *log->nast_.WYA->Zdist_dw->log_ptr->I2_ortb;
+	wsk++;
+	*wsk = *log->nast_.WYA->Zdist_dw->log_ptr->I3_orta;
+	wsk++;
+	*wsk = *log->nast_.WYA->Zdist_dw->log_ptr->I3_ortb;
+
+	log->dw.wsk_buf_pre++;
+	if(log->dw.wsk_buf_pre>MAIN_FREQ_PERIOD_MS/LOOP_CYCLE_MS*3-1) log->dw.wsk_buf_pre = 0;
+}
+
+
+void LMZ(void *arguments, void *logic)
+{
+	struct LMZ_logic *log = (struct LMZ_logic *)logic;
+	u16 local;
+	int k;
+
+    if(log->nast_.on_)   // jesli zabezpieczenie aktywne
+    {
+		zapisz_pre(log);
+		switch(log->status_rej_LMZ)
+		{
+			case oczekiwanie:
+
+				if(check_struct(&log->WE_ZDistL_Pzf[0]) || check_struct(&log->WE_ZDistL_Pzf[1]))
+				{
+					log->status_rej_LMZ = sledzenie;// stan_nieustalony;
+					log->dw.wsk_buf = 0; //dodane
+					zapisz_p(log);//dodane
+
+					//dw.czas_ = time;
+					log->dw.licz1 = 10;//20;
+					          
+          if (log->dw.wsk_buf_pre == 0)
+            local = MAIN_FREQ_PERIOD_MS/LOOP_CYCLE_MS*3-2;
+          else if (log->dw.wsk_buf_pre == 1)
+            local = MAIN_FREQ_PERIOD_MS/LOOP_CYCLE_MS*3-1;
+          else
+            local = log->dw.wsk_buf_pre - 2 ;
+          
+           
+					for(k=0;k<MAIN_FREQ_PERIOD_MS/LOOP_CYCLE_MS;k++)
+					{
+						if (local>MAIN_FREQ_PERIOD_MS/LOOP_CYCLE_MS*3-1) local -= MAIN_FREQ_PERIOD_MS/LOOP_CYCLE_MS*3;
+						log->dw.Im[k] = log->dw.Ip[local];
+						local++;
+					}
+				}
+				break;
+
+			case stan_nieustalony:
+				if(log->dw.licz1>LOOP_CYCLE_MS)
+					log->dw.licz1-=LOOP_CYCLE_MS;
+				else
+					log->dw.licz1=0;
+
+				if(!log->dw.licz1)
+				{
+					if(check_struct(&log->WE_ZDistL_Pzf[0]) || check_struct(&log->WE_ZDistL_Pzf[1]))
+					{
+						log->status_rej_LMZ = sledzenie;
+						log->dw.wsk_buf = 0;
+						zapisz_p(log);
+						log->dw.licz1 = 10;
+					} else {
+						log->status_rej_LMZ = oczekiwanie;
+					}
+				}
+				break;
+
+			case sledzenie:
+
+				zapisz_p(log);
+
+
+				if (log->dw.wsk_buf==MAIN_FREQ_PERIOD_MS/LOOP_CYCLE_MS*5-1)
+				{
+					log->status_rej_LMZ = blokada;
+					log->dw.wsk_rej = 1;
+				} else {
+					if(!check_struct(&log->WE_ZDistL_Pzf[0]) && !check_struct(&log->WE_ZDistL_Pzf[1]))
+					{
+						if(log->dw.licz1>LOOP_CYCLE_MS)
+							log->dw.licz1-=LOOP_CYCLE_MS;
+						else
+							log->dw.licz1=0;
+					} else {
+						log->dw.licz1 = 10;
+					}
+					if(!log->dw.licz1)
+					{
+						if (log->dw.wsk_buf<MAIN_FREQ_PERIOD_MS/LOOP_CYCLE_MS)
+						{
+							log->status_rej_LMZ = oczekiwanie;
+						} else {
+							log->status_rej_LMZ = blokada;
+							log->dw.wsk_rej = 1;
+						}
+
+					}
+
+				}
+				break;
+
+			case blokada:
+				if (!log->dw.wsk_rej && !(check_struct(&log->WE_ZDistL_Pzf[0]) || check_struct(&log->WE_ZDistL_Pzf[1])))
+				{
+					log->status_rej_LMZ = oczekiwanie;
+				}
+				break;
+
+			default:
+			 	break;
+		}
+	}
+}
+
+void LMZ_20hz(void *arguments, void *logic)
+{
+	struct LMZ_logic *log = (struct LMZ_logic *)logic;
+	u16 licz[6], temp, temp1;
+	u16 czas_mf, czas_1f, zwarcie_mf, zwarcie_1f, roznica;
+	u16 czas_4, czas_5, czas_6;
+	float local;
+	u16 k;
+	int i;
+	u8 startbuf = 0;
+	float sr1, sr2, sr3, iloraz;
+
+	if(log->dw.wsk_rej) // przypisanie parametrow zaklocenia jesli zebra dostatecznie wielk ilo danych
+    {
+		//wyliczanie petli dla strefy 1
+   
+		licz[0]=0;
+		licz[1]=0;
+		licz[2]=0;
+		licz[3]=0;
+		licz[4]=0;
+		licz[5]=0;
+
+		for(i=0;i<log->dw.wsk_buf;i++)
+		{
+			//okrelenie ktra ptla bya pobudzona najduej (kryterium wyboru)
+			for(k=0;k<6;k++)
+			{
+				if(log->dw.P[i][k]) licz[k]++;
+			}
+		}
+		temp = 0;
+		temp1 = 0;  
+    	czas_1f = 0;
+		czas_mf = 0;
+		zwarcie_mf = 0;
+		zwarcie_1f = 0;
+   
+    	//zwarcia miedzyfazowe
+    	for(k=3;k<6;k++)
+		{
+			if(licz[k]>temp1)
+			{
+				temp1 = licz[k];
+				temp = k+1;
+        		czas_mf = temp1;
+        		zwarcie_mf = k+1;
+			}
+		}
+ 
+    	czas_4 = licz[3];
+    	czas_5 = licz[4];
+    	czas_6 = licz[5];
+ 
+    	//zwarcia jednofazowe
+    	for(k=0;k<3;k++)
+		{
+			if(licz[k]>czas_1f)
+			{
+          		czas_1f = licz[k];
+          		zwarcie_1f = k+1;
+      		}
+    	}
+       	
+    	for(k=0;k<3;k++)
+		{
+			if(licz[k]>temp1)
+			{
+				temp1 = licz[k];
+				temp = k+1;
+			}
+		}
+       
+		if (czas_1f > czas_mf)
+    	{
+			roznica = czas_1f - czas_mf;
+		}
+    	else
+    	{
+			roznica = czas_mf - czas_1f;
+    	}
+    
+		//wyznaczanie przedzialu z ktorego beda wyioczane dane
+		if(log->dw.wsk_buf<25)
+		{
+			startbuf=0;
+			log->dw.wsk_buf-=(log->dw.wsk_buf-20);
+		}
+		else if(log->dw.wsk_buf>=25 && log->dw.wsk_buf<35)
+		{
+			startbuf=(log->dw.wsk_buf-25);
+			log->dw.wsk_buf-=5;
+		}
+		else if(log->dw.wsk_buf>=35 && log->dw.wsk_buf<40)
+		{
+			startbuf=5;
+			log->dw.wsk_buf-=10;
+		}
+		else if(log->dw.wsk_buf>=40 && log->dw.wsk_buf<50)
+		{
+			startbuf=10;
+			log->dw.wsk_buf-=10;
+		}
+		else if(log->dw.wsk_buf>=50 && log->dw.wsk_buf<=60)
+		{
+			startbuf=15;
+			log->dw.wsk_buf-=15;
+		}
+		else
+		{
+			startbuf=20;
+			log->dw.wsk_buf-=20;
+		}
+
+    	sr1 = 0;
+    	sr2 = 0;
+    	sr3 = 0; 
+    
+		//wyliczenie sredniej wartosci pradow w oknie zwarcia
+		for(i=0;i<(log->dw.wsk_buf - startbuf);i++)
+		{
+			float r = log->dw.dp[i+startbuf].IL1.r;
+			float ii = log->dw.dp[i+startbuf].IL1.i;
+			float esk = sqrt((r * r + ii * ii) * 0.5);
+			sr1 +=esk;
+      
+			r = log->dw.dp[i+startbuf].IL2.r;
+			ii = log->dw.dp[i+startbuf].IL2.i;
+			esk = sqrt((r * r + ii * ii) * 0.5);
+			sr2 +=esk;
+      
+			r = log->dw.dp[i+startbuf].IL3.r;
+			ii = log->dw.dp[i+startbuf].IL3.i;
+			esk = sqrt((r * r + ii * ii) * 0.5);
+			sr3 +=esk;
+		}
+		sr1 = sr1 / (log->dw.wsk_buf - startbuf);  
+		sr2 = sr2 / (log->dw.wsk_buf - startbuf);
+		sr3 = sr3 / (log->dw.wsk_buf - startbuf);
+  
+		float procent = 1;
+      
+		#ifdef LMZ_DEBUG
+		*log->debug1 = (float)czas_1f;
+		*log->debug2 = (float)czas_4;
+		*log->debug3 = (float)czas_5;
+		*log->debug4 = (float)czas_6;
+		#endif
+  
+		float d1 = 1;
+		float d2 = 1;
+
+		//gdy zwarcie jest miedzyfazowe i sa pobudzone jednoczesnie dwie petle, wybierz wlasciwa
+		//na podstawie pradow
+		if (czas_mf > 20/LOOP_CYCLE_MS) //zwarcie miedzyfazowe
+		{
+        	if ((czas_4 > 20/LOOP_CYCLE_MS) && (czas_5 > 20/LOOP_CYCLE_MS) && (czas_6 > 20/LOOP_CYCLE_MS))
+        	{
+        	//zwarcie 3 fazowe nic nie rob
+			}
+			else
+			{
+				if ((czas_4 > 20/LOOP_CYCLE_MS) && (czas_5 > 20/LOOP_CYCLE_MS))  //L1L2 i L2L3
+				{
+					if (czas_4 > czas_5)
+	                	procent = (float)czas_5 / (float)czas_4;
+					else
+						procent = (float)czas_4 / (float)czas_5;
+	            
+	            	if (procent > 0.7)
+					{
+						float iloraz12 = 1;
+						float iloraz23 = 1;                    
+						d1 = sr1;
+						d2 = sr2;                       
+						if (d1 > d2)
+							iloraz12 = d1 / d2;
+						else
+							iloraz12 = d2 / d1;
+	                
+						d1 = sr2;
+						d2 = sr3;                                
+	              		if (d1 > d2)
+							iloraz23 = d1 / d2;
+						else
+							iloraz23 = d2 / d1;
+	                
+						if (iloraz12 > iloraz23)
+						{
+							temp = 5;
+							zwarcie_mf = 5;
+						}
+						else
+						{
+							temp = 4;
+							zwarcie_mf = 4;
+						}
+					}
+				}
+	               
+				if ((czas_4 > 20/LOOP_CYCLE_MS) && (czas_6 > 20/LOOP_CYCLE_MS))  //L1L2 i L3L1
+				{
+					if (czas_4 > czas_6)
+						procent = (float)czas_6 / (float)czas_4;
+					else
+						procent = (float)czas_4 / (float)czas_6;
+	            
+					if (procent > 0.7)
+					{
+						float iloraz12 = 1;
+						float iloraz31 = 1;
+		   				d1 = sr1;
+						d2 = sr2;
+		   				if (d1 > d2)
+							iloraz12 = d1 / d2;
+						else
+							iloraz12 = d2 / d1;
+		                
+						d1 = sr3;
+						d2 = sr1;                                
+						if (d1 > d2)
+							iloraz31 = d1 / d2;
+						else
+							iloraz31 = d2 / d1;
+		                
+						if (iloraz12 > iloraz31)
+						{
+							temp = 6;
+							zwarcie_mf = 6;
+						}
+						else
+						{
+							temp = 4;
+							zwarcie_mf = 4;
+						}
+					}
+				}
+	       
+				if ((czas_5 > 20/LOOP_CYCLE_MS) && (czas_6 > 20/LOOP_CYCLE_MS))  //L2L3 i L3L1
+				{
+					if (czas_5 > czas_6)
+						procent = (float)czas_6 / (float)czas_5;
+					else
+						procent = (float)czas_5 / (float)czas_6;
+		            
+					if (procent > 0.7)
+					{
+						float iloraz23 = 1;
+						float iloraz31 = 1;
+		                     
+						d1 = sr2;
+						d2 = sr3;
+		                       
+						if (d1 > d2)
+							iloraz23 = d1 / d2;
+						else
+							iloraz23 = d2 / d1;
+		                
+						d1 = sr3;
+						d2 = sr1;
+		                                
+						if (d1 > d2)
+							iloraz31 = d1 / d2;
+						else
+							iloraz31 = d2 / d1;
+		                
+						if (iloraz23 > iloraz31)
+						{
+							temp = 6;
+							zwarcie_mf = 6;
+						}
+						else
+						{
+							temp = 5;
+							zwarcie_mf = 5; 
+						}
+					}
+				}      
+			}    
+		}
+           
+		if (zwarcie_mf == 4)
+		{
+			d1 = sr1;
+			d2 = sr2;
+		}
+		else if (zwarcie_mf == 5)
+		{
+			d1 = sr2;
+			d2 = sr3;
+		}
+		if (zwarcie_mf == 6)
+		{
+			d1 = sr3;
+			d2 = sr1;
+		}
+	     
+		if (d1 > d2)
+			iloraz = d1 / d2;
+		else
+			iloraz = d2 / d1; 
+	      
+		procent = 1;
+	      
+		if (czas_1f != 0)
+			procent = (float)czas_mf / (float)czas_1f;
+	           
+		if ((czas_mf > 20/LOOP_CYCLE_MS) && (czas_1f > 20/LOOP_CYCLE_MS) && (procent > 0.5) && (zwarcie_mf != 0))
+		{
+			if (iloraz < 3)
+				temp = zwarcie_mf;
+			else
+				temp = zwarcie_1f;    
+		}
+	  	
+	  	#ifdef LMZ_DEBUG
+		*log->debug = temp;
+	  	#endif
+	  	
+		switch(temp)
+		{
+			case 1://zwarcie RE
+				for(i=0;i<(log->dw.wsk_buf - startbuf);i++)
+				{
+					log->dw.zu = log->dw.dp[i+startbuf].UL1;
+					log->dw.odl_b[i] = wylicz_dane_1f(log,i+startbuf,0);
+				}
+				break;
+			case 2://zwarcie SE
+				for(i=0;i<(log->dw.wsk_buf - startbuf);i++)
+				{
+					log->dw.zu = log->dw.dp[i+startbuf].UL2;
+					log->dw.odl_b[i] = wylicz_dane_1f(log,i+startbuf,1);
+				}
+				break;
+			case 3://zwarcie TE
+				for(i=0;i<(log->dw.wsk_buf-startbuf);i++)
+				{
+					log->dw.zu = log->dw.dp[i+startbuf].UL3;
+					log->dw.odl_b[i] = wylicz_dane_1f(log,i+startbuf,2);
+				}
+				break;
+			case 4://zwarcie RS
+				for(i=0;i<(log->dw.wsk_buf-startbuf);i++)
+				{
+					log->dw.zu = log->dw.dp[i+startbuf].UL12;
+					log->dw.odl_b[i] = wylicz_dane_mf(log,i+startbuf,0,1);
+				}
+				break;
+			case 5://zwarcie ST
+				for(i=0;i<(log->dw.wsk_buf-startbuf);i++)
+				{
+					log->dw.zu = log->dw.dp[i+startbuf].UL23;
+					log->dw.odl_b[i] = wylicz_dane_mf(log,i+startbuf,1,2);
+				}
+				break;
+			case 6://zwarcie TE
+				for(i=0;i<(log->dw.wsk_buf-startbuf);i++)
+				{
+					log->dw.zu = log->dw.dp[i+startbuf].UL31;
+					log->dw.odl_b[i] = wylicz_dane_mf(log,i+startbuf,2,0);
+				}
+				break;
+			case 0: //error
+				break;
+		}
+
+////---------------------------
+
+	//szukanie wyniku - mediana z wyliczonych wartoci
+	for(i=0;i<(log->dw.wsk_buf-startbuf);i++)
+	{
+		temp1 = i+1;
+		while(temp1)
+		{
+			temp1--;
+			if(log->dw.odl_b[temp1+1]>log->dw.odl_b[temp1])
+			{
+				local = log->dw.odl_b[temp1];
+				log->dw.odl_b[temp1] = log->dw.odl_b[temp1+1];
+				log->dw.odl_b[temp1+1] = local;
+			}
+			else
+				{
+					temp1 = 0;
+				}
+			}
+		}
+
+		if(temp)
+		{
+			set_struct(&log->P);
+			if((log->dw.wsk_buf-startbuf) % 2)
+			{
+				*log->distance=log->dw.odl_b[(log->dw.wsk_buf-startbuf)/2 + 1];
+			}
+			else
+			{
+				*log->distance=(log->dw.odl_b[(log->dw.wsk_buf-startbuf)/2 + 1] + log->dw.odl_b[(log->dw.wsk_buf-startbuf)/2]) / 2;
+			}
+			//------------------------------------------------
+		}
+
+		log->dw.wsk_rej = 0; // zerowanie wskaznika powstania nowego zaklocenia
+    }
+
+	if(check_struct(&log->clr))
+	{
+		*log->distance=0;
+		clear_struct(&log->P);
+
+	}
+}

src/LMZ.h

@@ -0,0 +1,143 @@
+/*
+ * LMZ.h
+ *
+ *  Created on: 23-05-2017
+ *      Author: Krzysztof Jakubczyk
+ */
+
+#ifndef LMZ_H_
+#define LMZ_H_
+
+#include "tdefs.h"
+#include "ZDistA.h"
+#include "analog_in.h"
+
+struct zespolona
+{
+	float r;
+	float i;
+};
+
+struct Nastawy_przeliczone_LMZ
+{
+	struct Wyjscia_ZDistA *WYA;
+	//R_ZDistL::dane_wewnetrzne *WYL;
+	struct zespolona a; //wsp鏊czynnik
+	struct zespolona b; //wsp鏊czynnik
+	struct zespolona c; //wsp鏊czynnik
+  struct zespolona kziem; //wsp鏊czynnik
+    u8 on_; ///< wartosc nastawy aktywnosci przekaznika 1- aktywny
+    u8 L2t; ///< linia dwutorowa
+};
+
+struct dane_probek
+{
+	struct zespolona IL1; // dane pr鉅u faza 1
+	struct zespolona IL2; // dane pr鉅u faza 2
+	struct zespolona IL3; // dane pr鉅u faza 3
+	struct zespolona Io; // dane pr鉅u zerpwego
+	struct zespolona Io2; // dane pr鉅u zerowego toru r闚noleg貫go
+	struct zespolona UL1; //napi璚ie faza 1
+	struct zespolona UL2; //napi璚ie faza 2
+	struct zespolona UL3; //napi璚ie faza 3
+	struct zespolona UL12; //napi璚ie miedzyfazowe 1-2
+	struct zespolona UL23; //napi璚ie mi璠zyfazowe 2-3
+	struct zespolona UL31; //napi璚ie miedzyfazowe 3-1
+};
+
+struct prad_pz
+{
+	struct zespolona IL1;//bufor pradu z przed zwarcia faza 1
+	struct zespolona IL2;//bufor pradu z przed zwarcia faza 2
+	struct zespolona IL3;//bufor pradu z przed zwarcia faza 3
+};
+
+struct dane_wewnetrzne
+{
+//		Wyjscia_rejestratora R; ///< dane ostatniego zak堯cenia
+//		Time czas_; // moment wystapienia zaklocenia (rejestr tymczasowy - przed zapisem)
+	short wsk_buf;//aktualne polozenie w buforze pr鏏ek (w trakcie rejestracji)
+	short wsk_buf_pre;//aktualne polozenie w buforze pr鏏ek z przed zwarcia
+	short licz1;
+	u16 wsk_p; //wskaznik do okreslenia pradu
+	float dl_; // dlugosc czasu trwania zaklocenia (rejestr tymczasowy - przed zapisem)
+	float odl_b[MAIN_FREQ_PERIOD_MS/LOOP_CYCLE_MS*5];//odleg這𨀣 pojedynczej iteracji
+	struct dane_probek dp[MAIN_FREQ_PERIOD_MS/LOOP_CYCLE_MS*5]; // ortogonalne kana這w wejsciowych
+	struct prad_pz Ip[MAIN_FREQ_PERIOD_MS/LOOP_CYCLE_MS*3]; //bufor biezacy pamietania probek z przed zwarcia
+	struct prad_pz Im[MAIN_FREQ_PERIOD_MS/LOOP_CYCLE_MS]; //bufor pamietania probek z przed zwarcia "zatrza𦨭i皻a"
+	u8 P[MAIN_FREQ_PERIOD_MS/LOOP_CYCLE_MS*5][6];
+	struct zespolona zz;
+	struct zespolona zi;
+	struct zespolona zu;
+	struct zespolona zibis;
+	u8 wsk_rej;
+};
+
+struct LMZ_logic
+{
+	struct binary_io WE_ZDistL_Pzf[2];
+	float *IoII_orta;
+	float *IoII_ortb;
+	struct analog_in_params *IoII_params;
+	struct binary_io clr;
+	struct binary_io P;
+	float *distance;
+  
+	#ifdef LMZ_DEBUG
+	float *debug;
+	float *debug1;
+	float *debug2;
+	float *debug3;
+	float *debug4;
+	#endif
+
+	struct dane_wewnetrzne dw;
+	struct Nastawy_przeliczone_LMZ nast_;// struktura z parametrami
+	enum rej_ost status_rej_LMZ;
+};
+
+struct LMZ_io
+{
+	u32 we_zdist_ptr_in;
+	u32 we_zdistl_p1_in;
+	u32 we_zdistl_p1w_in;
+	u32 ioii_orta_float_in;
+	u32 ioii_ortb_float_in;
+	u32 ioii_params_ptr_in;
+	u32 clr_in;
+	u32 p_out;
+	u32 distance_float_out;
+
+	#ifdef LMZ_DEBUG
+	u32 debug_out;
+	u32 debug1_out;
+	u32 debug2_out;
+	u32 debug3_out;
+	u32 debug4_out;
+	#endif
+
+}__attribute__((__packed__));
+
+struct LMZ_params
+{
+	u32 bity; ///< nastawy bitowe;
+    double R1;///< Rezystancja jednostkowa dla sk豉dowej zgodnej
+	double X1;///<Reaktancja jednostkowa dla sk豉dowej zgodnej
+	double R0;///<Rezystancja jednostkowa dla sk豉dowej zerowej
+	double X0;///<Reaktancja jednostkowa dla sk豉dowej zerowej
+	double Rm;///<Rezystancja jednostkowa dla sk豉dowej wzajemnej
+	double Xm;///<Reaktancja jednostkowa dla sk豉dowej wzajemnej
+}__attribute__((__packed__));
+
+struct LMZ_args
+{
+	struct LMZ_io io;
+	struct LMZ_params params;
+//	u16 crc;
+}__attribute__((__packed__));
+
+extern void LMZ(void *args, void *logic);
+extern void LMZ_20hz(void *args, void *logic);
+extern int LMZ_initlog(void *arguments, void *logic);
+
+#endif /* LMZ_H_ */

src/LRW.c

@@ -0,0 +1,410 @@
+/*
+ * LRW.c
+ *
+ *  Created on: 15-03-2022
+ *      Author: 
+ *      Pawe Skoczykoda
+ */
+
+
+#include "tdefs.h"
+#include "misc.h"
+#include "helper.h"
+
+
+#include "LRW.h"
+
+void set_default(void *logic)
+{
+	struct LRW_logic *log = (struct LRW_logic *)logic;	
+	
+	log->ret_I_L1 = 0;
+	log->ret_I_L2 = 0;
+	log->ret_I_L3 = 0;
+	log->ret_W_L1 = 0;
+	log->ret_W_L2 = 0;
+	log->ret_W_L3 = 0;
+	log->ret_I_3f = 0;
+	log->ret_W_3f = 0;
+	log->wy_T1 = 0;
+	log->wy_T2 = 0;
+	log->wy_T2_I = 0;
+	log->wy_T2_W = 0;
+	
+	log->pob_I_L1 = 0;
+	log->pob_I_L2 = 0;
+	log->pob_I_L3 = 0;
+	log->pob_W_L1 = 0;
+	log->pob_W_L2 = 0;
+	log->pob_W_L3 = 0;
+	log->pob_I_3f = 0;
+	log->pob_W_3f = 0;		
+	log->pob_T2_I = 0;
+	log->pob_T2_W = 0;
+	log->wy_pob = 0;
+	
+	log->t_I_L1 = 0;
+	log->t_I_L2 = 0;
+	log->t_I_L3 = 0;
+	log->t_W_L1 = 0;
+	log->t_W_L2 = 0;
+	log->t_W_L3 = 0;	
+	log->t_I_3f = 0;
+	log->t_W_3f = 0;
+	log->t_I_2 = 0;
+	log->t_W_2 = 0;
+	
+}	
+
+int LRW_initlog(void *arguments, void *logic)
+{
+	struct LRW_args *args = (struct LRW_args *)arguments;
+	struct LRW_logic *log = (struct LRW_logic *)logic;
+
+	if(set_bit_ptr_struct(args->io.stan_bl,&log->stan_bl))
+		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_on_L2_in,&log->w_on_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.wyl_L1_in,&log->wyl_L1))
+		return -1;
+	if(set_bit_ptr_struct(args->io.wyl_L2_in,&log->wyl_L2))
+		return -1;
+	if(set_bit_ptr_struct(args->io.wyl_L3_in,&log->wyl_L3))
+		return -1;
+	if(set_bit_ptr_struct(args->io.test_in,&log->test))
+		return -1;
+		
+	if(set_bit_ptr_struct(args->io.retrip_I_L1_out,&log->retrip_I_L1))
+		return -1;
+	if(set_bit_ptr_struct(args->io.retrip_I_L2_out,&log->retrip_I_L2))
+		return -1;
+	if(set_bit_ptr_struct(args->io.retrip_I_L3_out,&log->retrip_I_L3))
+		return -1;	
+	if(set_bit_ptr_struct(args->io.retrip_W_L1_out,&log->retrip_W_L1))
+		return -1;
+	if(set_bit_ptr_struct(args->io.retrip_W_L2_out,&log->retrip_W_L2))
+		return -1;
+	if(set_bit_ptr_struct(args->io.retrip_W_L3_out,&log->retrip_W_L3))
+		return -1;
+
+	if(set_bit_ptr_struct(args->io.retrip_I_3f_out,&log->retrip_I_3f))
+		return -1;
+	if(set_bit_ptr_struct(args->io.retrip_W_3f_out,&log->retrip_W_3f))
+		return -1;
+
+	if(set_bit_ptr_struct(args->io.T2_I_out,&log->T2_I))
+		return -1;
+	if(set_bit_ptr_struct(args->io.T2_W_out,&log->T2_W))
+		return -1;
+
+	if(set_bit_ptr_struct(args->io.T1_out,&log->T1))
+		return -1;
+	if(set_bit_ptr_struct(args->io.T2_out,&log->T2))
+		return -1;
+
+	if(set_bit_ptr_struct(args->io.pob_out,&log->pob))
+		return -1;
+
+	if(set_float_ptr(args->io.I1_float_in,&log->I1))
+		return -1;
+
+	if(set_float_ptr(args->io.I2_float_in,&log->I2))
+		return -1;
+
+	if(set_float_ptr(args->io.I3_float_in,&log->I3))
+		return -1;
+
+	log->nast_.on_ = (args->params.bity & 0x0001)?1:0;
+	log->kryt_pr = (args->params.bity & 0x0002)?1:0;
+	log->kryt_wyl = (args->params.bity & 0x0004)?1:0;
+	log->nast_.full_period = (args->params.bity & 0x0008)?1:0;
+    log->nast_.limit1_ = args->params.Wr_ *  args->params.Wr_; // wyliczenie wartosci rozruchowej algorytmu
+    log->nast_.limit2_ = log->nast_.limit1_ * args->params.kp_ * args->params.kp_; // wyliczenie wartosci powrotowej algorytmu
+
+	log->t1_limit = (u32)((args->params.t1_) * 1000 / LOOP_CYCLE_MS);
+	log->t2_limit = (u32)((args->params.t2_) * 1000 / LOOP_CYCLE_MS);
+		
+	set_default(log);
+		
+	return 0;
+}
+
+void LRW(void *arguments, void *logic)
+{
+	struct LRW_logic *log = (struct LRW_logic *)logic;
+
+
+    if(log->nast_.on_)   // jesli zabezpieczenie aktywne
+    {
+		u8 blokada = check_struct(&log->stan_bl)?1:0;
+		u8 w_on_L1 = check_struct(&log->w_on_L1)?1:0;
+		u8 w_on_L2 = check_struct(&log->w_on_L2)?1:0;
+		u8 w_on_L3 = check_struct(&log->w_on_L3)?1:0;
+		u8 wyl_L1 = check_struct(&log->wyl_L1)?1:0;
+		u8 wyl_L2 =  check_struct(&log->wyl_L2)?1:0;
+		u8 wyl_L3 =  check_struct(&log->wyl_L3)?1:0;
+		u8 test =  check_struct(&log->test)?1:0;
+
+
+		sprawdz_P(&log->dw.pob1,
+			*log->I1>log->nast_.limit1_,
+			*log->I1<log->nast_.limit2_,
+			&log->dw.lp1,
+			log->nast_.full_period?20:3,3); //realizacja przekaznika faza 1
+
+		sprawdz_P(&log->dw.pob2,
+			*log->I2>log->nast_.limit1_,
+			*log->I2<log->nast_.limit2_,
+			&log->dw.lp2,
+			log->nast_.full_period?20:3,3); //realizacja przekaznika faza 2
+
+		sprawdz_P(&log->dw.pob3,
+			*log->I3>log->nast_.limit1_,
+			*log->I3<log->nast_.limit2_,
+			&log->dw.lp3,
+			log->nast_.full_period?20:3,3); //realizacja przekaznika faza 3
+
+
+		log->dw.pob = log->dw.pob1 || log->dw.pob2 || log->dw.pob3;
+
+		log->pob_I_L1 = wyl_L1 && !wyl_L2 && !wyl_L3 && log->dw.pob1 && log->kryt_pr;
+		log->pob_I_L2 = !wyl_L1 && wyl_L2 && !wyl_L3 && log->dw.pob2 && log->kryt_pr;
+		log->pob_I_L3 = !wyl_L1 && !wyl_L2 && wyl_L3 && log->dw.pob3 && log->kryt_pr;
+
+		log->pob_W_L1 = wyl_L1 && !wyl_L2 && !wyl_L3 && w_on_L1 && log->kryt_wyl;
+		log->pob_W_L2 = !wyl_L1 && wyl_L2 && !wyl_L3 && w_on_L2 && log->kryt_wyl;
+		log->pob_W_L3 = !wyl_L1 && !wyl_L2 && wyl_L3 && w_on_L3 && log->kryt_wyl;
+
+		u8 min_2faz =  (wyl_L1 && wyl_L2) || (wyl_L2 && wyl_L3) || (wyl_L1 && wyl_L3);
+		u8 suma_on = w_on_L1 || w_on_L2 || w_on_L3;
+		
+		log->pob_I_3f = min_2faz && log->dw.pob && log->kryt_pr;
+		log->pob_W_3f = min_2faz && suma_on && log->kryt_wyl;
+
+		log->pob_T2_I = log->pob_I_L1 || log->pob_I_L2 || log->pob_I_L3 || log->pob_I_3f;
+		log->pob_T2_W = log->pob_W_L1 || log->pob_W_L2 || log->pob_W_L3 || log->pob_W_3f;
+
+		//obsluga wejscia testu przekaznika
+		if (czy_test_R() && test)
+		{
+			log->pob_I_L1 = 1;
+			log->pob_I_L2 = 1;
+			log->pob_I_L3 = 1;
+			log->pob_W_L1 = 1;
+			log->pob_W_L2 = 1;
+			log->pob_W_L3 = 1;
+			
+			log->pob_I_3f = 1;
+			log->pob_W_3f = 1;
+			
+			log->pob_T2_I = 1;
+			log->pob_T2_W = 1;
+		}
+
+         //realizacja blokady dzialania przekaznika
+		if(blokada)
+		{
+			log->dw.pob1 = log->dw.pob2 = log->dw.pob3 = 0;
+			log->pob_I_L1 = 0;
+			log->pob_I_L2 = 0;
+			log->pob_I_L3 = 0;
+			log->pob_W_L1 = 0;
+			log->pob_W_L2 = 0;
+			log->pob_W_L3 = 0;
+			
+			log->pob_I_3f = 0;
+			log->pob_W_3f = 0;
+			
+			log->pob_T2_I = 0;
+			log->pob_T2_W = 0;
+		}
+        
+        log->wy_pob = log->pob_T2_I || log->pob_T2_W;
+		//sekcja timerow
+       
+       if (log->pob_I_L1)
+       {
+       		if (++log->t_I_L1 > log->t1_limit)
+       		{
+       			log->ret_I_L1 = 1;
+       			log->t_I_L1 = log->t1_limit + 10;
+       		}     	
+       }
+       else
+       {	
+			log->t_I_L1 = 0;
+			log->ret_I_L1 = 0;
+       }
+       
+       if (log->pob_I_L2)
+       {
+       		if (++log->t_I_L2 > log->t1_limit)
+       		{
+       			log->ret_I_L2 = 1;
+       			log->t_I_L2 = log->t1_limit + 10;
+       		}     	
+       }
+       else
+       {	
+			log->t_I_L2 = 0;
+			log->ret_I_L2 = 0;
+       }
+       
+       if (log->pob_I_L3)
+       {
+       		if (++log->t_I_L3 > log->t1_limit)
+       		{
+       			log->ret_I_L3 = 1;
+       			log->t_I_L3 = log->t1_limit + 10;
+       		}     	
+       }
+       else
+       {	
+			log->t_I_L3 = 0;
+			log->ret_I_L3 = 0;
+       }
+       
+       if (log->pob_W_L1)
+       {
+       		if (++log->t_W_L1 > log->t1_limit)
+       		{
+       			log->ret_W_L1 = 1;
+       			log->t_W_L1 = log->t1_limit + 10;
+       		}     	
+       }
+       else
+       {	
+			log->t_W_L1 = 0;
+			log->ret_W_L1 = 0;
+       }
+       
+       if (log->pob_W_L2)
+       {
+       		if (++log->t_W_L2 > log->t1_limit)
+       		{
+       			log->ret_W_L2 = 1;
+       			log->t_W_L2 = log->t1_limit + 10;
+       		}     	
+       }
+       else
+       {	
+			log->t_W_L2 = 0;
+			log->ret_W_L2 = 0;
+       }      
+       
+       if (log->pob_W_L3)
+       {
+       		if (++log->t_W_L3 > log->t1_limit)
+       		{
+       			log->ret_W_L3 = 1;
+       			log->t_W_L3 = log->t1_limit + 10;
+       		}     	
+       }
+       else
+       {	
+			log->t_W_L3 = 0;
+			log->ret_W_L3 = 0;
+       }
+       
+       if (log->pob_I_3f)
+       {
+       		if (++log->t_I_3f > log->t1_limit)
+       		{
+       			log->ret_I_3f = 1;
+       			log->t_I_3f = log->t1_limit + 10;
+       		}     	
+       }
+       else
+       {	
+			log->t_I_3f = 0;
+			log->ret_I_3f = 0;
+       }
+       
+       if (log->pob_W_3f)
+       {
+       		if (++log->t_W_3f > log->t1_limit)
+       		{
+       			log->ret_W_3f = 1;
+       			log->t_W_3f = log->t1_limit + 10;
+       		}     	
+       }
+       else
+       {	
+			log->t_W_3f = 0;
+			log->ret_W_3f = 0;
+       }      
+       
+       if (log->pob_T2_I)
+       {
+       		if (++log->t_I_2 > log->t2_limit)
+       		{
+       			log->wy_T2_I = 1;
+       			log->t_I_2  = log->t2_limit + 10;
+       		}     	
+       }
+       else
+       {	
+			log->wy_T2_I = 0;
+			log->t_I_2  = 0;
+       }     
+       
+       if (log->pob_T2_W)
+       {
+       		if (++log->t_W_2 > log->t2_limit)
+       		{
+       			log->wy_T2_W = 1;
+       			log->t_W_2  = log->t2_limit + 10;
+       		}     	
+       }
+       else
+       {	
+			log->wy_T2_W = 0;
+			log->t_W_2  = 0;
+       }       
+               
+        log->wy_T1 = log->ret_I_L1 || log->ret_I_L2 || log->ret_I_L3 || log->ret_W_L1 || log->ret_W_L2 ||
+        log->ret_W_L3 || log->ret_I_3f || log->ret_W_3f;
+        
+        log->wy_T2 = log->wy_T2_I || log->wy_T2_W;
+		
+		check_and_set_struct(log->ret_I_L1,&log->retrip_I_L1);
+		check_and_set_struct(log->ret_I_L2,&log->retrip_I_L2);
+		check_and_set_struct(log->ret_I_L3,&log->retrip_I_L3);
+		check_and_set_struct(log->ret_W_L1,&log->retrip_W_L1);
+		check_and_set_struct(log->ret_W_L2,&log->retrip_W_L2);
+		check_and_set_struct(log->ret_W_L3,&log->retrip_W_L3);				
+		check_and_set_struct(log->ret_I_3f,&log->retrip_I_3f);	
+		check_and_set_struct(log->ret_W_3f,&log->retrip_W_3f);		
+		check_and_set_struct(log->wy_T2_I,&log->T2_I);
+		check_and_set_struct(log->wy_T2_W,&log->T2_W);
+		check_and_set_struct(log->wy_T1,&log->T1);	
+		check_and_set_struct(log->wy_T2,&log->T2);
+		check_and_set_struct(log->wy_pob,&log->pob);	
+
+    } 
+    else
+    {
+		set_default(log);
+		
+		clear_struct(&log->retrip_I_L1);
+		clear_struct(&log->retrip_I_L2);
+		clear_struct(&log->retrip_I_L3);
+		clear_struct(&log->retrip_W_L1);
+		clear_struct(&log->retrip_W_L2);
+		clear_struct(&log->retrip_W_L3);
+		clear_struct(&log->retrip_I_3f);
+		clear_struct(&log->retrip_W_3f);
+		clear_struct(&log->T1);
+		clear_struct(&log->T2);
+		clear_struct(&log->T2_I);
+		clear_struct(&log->T2_W);
+	}
+}
+
+
+

src/LRW.h

@@ -0,0 +1,167 @@
+/*
+ * LRW.h
+ *
+ *  Created on: 29-11-2014
+ *      Author: Krzysztof Jakubczyk
+ */
+
+#ifndef LRW_H__
+#define LRW_H__
+
+//#include "pawel_usun_to.h"
+
+#include "tdefs.h"
+
+    struct Nastawy_przeliczone_lrw
+    {
+        float limit1_; ///< wartosc rozruchowa
+        float limit2_; ///< wartosc powrotu
+        u32 t_; ///< opoznienie czasu zadzialania przekaznika     
+        u8 on_; ///< wartosc nastawy aktywnosci przekaznika 1- aktywny
+        u8 full_period;
+    };
+
+	struct dane_wewnetrzne_lrw
+	{
+//		Wyjscia_rejestratora R; ///< dane ostatniego zaklocenia
+//		Time czas_; // moment wystapienia zaklocenia (rejestr tymczasowy - przed zapisem)
+		short lp1; ///<licznik filtracji pobudzen faza 1
+		short lp2; ///<licznik filtracji pobudzen faza 2
+		short lp3; ///<licznik filtracji pobudzen faza 3
+	    u32 licz_t_; // licznik czasu od pobudzenia dla przekaznika czasowego
+		u8 wsk_rej; // nowy zapis rejestracji parametrow zaklocenia (spelnienie kryterium identyfikacji)
+		u8 pob;///< pobudzenie przekaznika
+		u8 pob1;///< pobudzenie przekaznika faza 1
+		u8 pob2;///< pobudzenie przekaznika faza 2
+		u8 pob3;///< pobudzenie przekaznika faza 3
+		u8 zad;///< zadzialanie przekaznika
+	};
+
+struct LRW_logic
+{
+	struct binary_io stan_bl;
+	float *I1;
+	float *I2;
+	float *I3;
+	
+	struct binary_io w_on_L1;
+	struct binary_io w_on_L2;
+	struct binary_io w_on_L3;	
+	struct binary_io wyl_L1;
+	struct binary_io wyl_L2;
+	struct binary_io wyl_L3;
+	struct binary_io test;
+	
+	struct binary_io retrip_I_L1;
+	struct binary_io retrip_I_L2;
+	struct binary_io retrip_I_L3;
+	struct binary_io retrip_W_L1;
+	struct binary_io retrip_W_L2;
+	struct binary_io retrip_W_L3;	
+	struct binary_io retrip_I_3f;
+	struct binary_io retrip_W_3f;
+	struct binary_io T2_I;
+	struct binary_io T2_W;	
+	struct binary_io T1;
+	struct binary_io T2;
+	struct binary_io pob;
+	
+	u8 kryt_pr;
+	u8 kryt_wyl;
+
+	u8 ret_I_L1;
+	u8 ret_I_L2;
+	u8 ret_I_L3;
+	u8 ret_W_L1;
+	u8 ret_W_L2;
+	u8 ret_W_L3;
+	u8 ret_I_3f;
+	u8 ret_W_3f;
+	u8 wy_T2_I;
+	u8 wy_T2_W;
+	u8 wy_T1;
+	u8 wy_T2;
+	
+	u8 pob_I_L1;
+	u8 pob_I_L2;
+	u8 pob_I_L3;
+	u8 pob_W_L1;
+	u8 pob_W_L2;
+	u8 pob_W_L3;
+	u8 pob_I_3f;
+	u8 pob_W_3f;
+	u8 pob_T2_I;
+	u8 pob_T2_W;
+	u8 wy_pob;
+	
+	u32 t1_limit;
+	u32 t2_limit;
+	
+	u32 t_I_L1;
+	u32 t_I_L2;
+	u32 t_I_L3;
+	u32 t_W_L1;
+	u32 t_W_L2;
+	u32 t_W_L3;	
+	u32 t_I_3f;
+	u32 t_W_3f;
+	u32 t_I_2;
+	u32 t_W_2;
+		
+	struct dane_wewnetrzne_lrw dw;
+	struct Nastawy_przeliczone_lrw nast_;// struktura z parametrami
+};
+
+struct LRW_io
+{
+	u32 stan_bl;
+	u32 I1_float_in;
+	u32 I2_float_in;
+	u32 I3_float_in;	
+	u32 w_on_L1_in;
+	u32 w_on_L2_in;
+	u32 w_on_L3_in;
+	u32 wyl_L1_in;
+	u32 wyl_L2_in;
+	u32 wyl_L3_in;	
+	u32 test_in;
+	
+	u32 retrip_I_L1_out;
+	u32 retrip_I_L2_out;
+	u32 retrip_I_L3_out;
+	u32 retrip_W_L1_out;
+	u32 retrip_W_L2_out;
+	u32 retrip_W_L3_out;
+	
+	u32 retrip_I_3f_out;
+	u32 retrip_W_3f_out;
+	
+	u32 T2_I_out;
+	u32 T2_W_out;
+	u32 T1_out;
+	u32 T2_out;
+	u32 pob_out;
+
+}__attribute__((__packed__));
+
+struct LRW_params
+{
+	u32 bity; ///< nastawy bitowe;
+    double Wr_; ///< wartosc nastawy rozruchowej przekaznika w krotnosciach wartosci znamionowej
+    double kp_; ///< wartosc nastawy wspolczynnika powrotu
+    double t1_; ///< wartosc nastawy czasu T1 w sekundach
+    double t2_; ///< wartosc nastawy czasu T2 w sekundach
+
+}__attribute__((__packed__));
+
+struct LRW_args
+{
+	struct LRW_io io;
+	struct LRW_params params;
+//	u16 crc;
+}__attribute__((__packed__));
+
+extern void LRW(void *args, void *logic);
+extern int LRW_initlog(void *arguments, void *logic);
+
+#endif /* LRW_H__ */

src/R87L.h

@@ -0,0 +1,289 @@
+/*
+ * R87L.h
+ *
+ *  Created on: 20-05-2019
+ *      Author: Krzysztof Jakubczyk
+ */
+
+#ifndef R87L_H_
+#define R87L_H_
+
+#include "tdefs.h"
+#include "analog_in.h"
+#include "mkstream.h"
+#include "Diff.h"
+
+#define R87L_START_DELAY	100
+#define R87L_NO_STREAM_BLOK_WYL_TIME	10000 // 10s
+
+#define	R87L_COMM_W_L1 			(1<<0)
+#define	R87L_COMM_W_L2 			(1<<1)
+#define	R87L_COMM_W_L3 			(1<<2)
+#define R87L_COMM_BLOK			(1<<3)
+#define R87L_COMM_PRZEGLAD		(1<<4)
+#define R87L_COMM_BLOK_WYL		(1<<5)
+
+
+	struct wskazniki_prad_do_kompensacji_87l
+	{
+		float /*struct we_an_diff*/ *Ip[4];
+		float /*struct we_an_diff*/ *Im[4];
+		float /*struct we_an_diff*/ *Ip_prev[4];
+		float /*struct we_an_diff*/ *Im_prev[4];
+
+		float a_p[4][2];
+		float a_m[4][2];
+		float a_pi0[3];
+	};
+
+    struct Nastawy_przeliczone_87
+    {
+		float khr_2h;///< wartosc rozruchowa blokady od 2 harmonicznej
+		float khp_2h;///< wartosc powrotowa blokady od 2 harmonicznej
+		float khr_5h;///< wartosc rozruchowa blokady od 5 harmonicznej
+		float khp_5h;///< wartosc powrotowa blokady od 5 harmonicznej
+		float Irr;///< wartosc rozruchowa dzialania bezwarunkowego
+		float Ipr;///< wartosc powrotowa dzialania bezwarunkowego
+		float Ihdr;///<wartosc rozruchowa pradu hamowania zwarcia zewnetrznego
+		float Irdr;///< wartosc rozruchowa pradu roznicowego zwarcia zewnetrznego
+		float kh1r;///<wartosc rozruchowa prosta 2
+		float kh1p;///<wartosc powrotowa prosta 2
+		float kh2r;///<wartosc rozruchowa prosta 3
+		float Ir3c;///< czesc stala nastawy odcinka 3
+		float Ip3c;///< czesc stala nastawy odcinka 3
+		float kh2p;///<wartosc powrotowa prosta 3
+		float kh1r2;///<wartosc rozruchowa prosta 2 (w kwadracie)
+		float kh1p2;///<wartosc powrotowa prosta 2 (w kwadracie)
+		float Iror;///<wartosc rozruchowa pradu prosta 1
+		float Irop;///<wartosc powrotowa pradu prosta 1
+		float Ir4;///< wartosc rozruchowa prosta 4
+		float Ip4;///< wartosc powrotowa prosta 4
+		float Ih1;///< wartosc pradu stabilizacji dla poczatku prostej 2
+		float Ihp;///< wartosc pradu stabilizacji dla poczatku prostej 3
+		float Ihg;///<wartosc pradu stabilizacji dla poczatku prostej 4
+		float I2h_min;
+		float I5h_min;
+		u16 t_sbc;///< czas blokady po stwierdzeniu zwarcia zewnetrznego
+        u32 tz; ///< opoznienie czasu zadzialania przekaznika
+		u8 on; ///< wartosc nastawy aktywnosci przekaznika 1- aktywny
+        u8 w; ///< wartosc nastawy dzialania na wylaczeniee 1 - wylaczenie 0 - tylko sygnalizacja
+        u8 bl; ///< wartosc nastawy aktywnosci blokady dzialania 1- blokada aktywna
+		u8 bl2h;///< wlaczenie blokady od drugiej harmonicznej
+		u8 bl5h;///< wlaczenie blokady od piatej harmonicznej
+		u8 sbc;///< wlaczenie strefy blokady czasowej
+		u8 h;///< wlaczenie granicznej stabilizacji
+		u8 r; ///< wlaczenie strefy bezwarunkowego wylaczenia
+		u8 cross_block; ///cross block do hrmonicznych
+		u8 przyspiesz_dzialanie;
+		u8 przyjmuj_zadzialania;
+		u8 rozwijajace;
+	//	u8 test_1str;
+		struct wskazniki_prad_do_kompensacji_87l L[3]; ///< wskazniki pradow do wyliczenia skompensowanych wejsc faza 1,2,3
+		float a[4];///< wspolczynnik pradu do kompensacji
+		struct stream_frame zero_frame;
+		float zero;
+		float wsp_filtr_sin_[20*2];
+		float wsp_filtr_cos_[20*2];
+		float wsp_filtr_sin2h_[20*2];
+		float wsp_filtr_cos2h_[20*2];
+		float wsp_filtr_sin5h_[20*2];
+		float wsp_filtr_cos5h_[20*2];
+		u8 p2d;
+		u8 p3d;
+		u8 stream_cnt;
+	};
+
+	struct wejscie_wew_87
+	{
+		float buf_Lr[(MAIN_FREQ_PERIOD_MS/LOOP_CYCLE_MS)*2*2][6];
+		u8 nr_probki;
+		float orta[6];
+		float ortb[6];
+		float Ir[6];
+		float orta2h[3];
+		float ortb2h[3];
+		float I2h[3];
+		float orta5h[3];
+		float ortb5h[3];
+		float I5h[3];
+
+		float buf_ip[(MAIN_FREQ_PERIOD_MS/LOOP_CYCLE_MS)*2*2][9];
+		float Ip[9];
+	};
+
+
+struct r87l_logic
+{
+	struct stream_frame *stream[3];
+	struct binary_io streams_ok;
+	struct binary_io test;
+	struct binary_io stan_bl;
+	struct binary_io test_1str;
+	struct binary_io W;
+	struct binary_io Wf[3];
+	struct binary_io Z;
+	struct binary_io Zf[3];
+	struct binary_io P;
+	struct binary_io Pf[3];
+
+	struct Nastawy_przeliczone_87 nast_; // struktura z parametrami rozruchowymi
+
+	struct binary_io BL2h1;
+	struct binary_io BL2h2;
+	struct binary_io BL2h3;
+	struct binary_io BL5h1;
+	struct binary_io BL5h2;
+	struct binary_io BL5h3;
+	struct binary_io Zw1;
+	struct binary_io Zw2;
+	struct binary_io Zw3;
+	struct binary_io nieobs;
+	struct binary_io blok;
+	struct binary_io zezw_w1f;
+	struct binary_io przeglad;
+	struct binary_io blok_w;
+	float *Ir1;
+	float *Ir2;
+	float *Ir3;
+	float *Ih1;
+	float *Ih2;
+	float *Ih3;
+	float *I2h1;
+	float *I2h2;
+	float *I2h3;
+	float *I5h1;
+	float *I5h2;
+	float *I5h3;
+	float *Ir_L1_ortb;
+	float *Ir_L2_ortb;
+	float *Ir_L3_ortb;
+
+	struct licz l;
+	struct pobudzenia_czastkowe P_;
+	struct dane_wewnetrzne_Diff dw;
+	enum jaki_uklad jaki_uklad;
+//	struct pobudzenia_czastkowe P_;
+	struct wejscie_wew_87 w;
+	float Ir1_;
+	float Ir2_;
+	float Ir3_;
+	float Ih1_;
+	float Ih2_;
+	float Ih3_;
+
+	float A[3][3];
+	float A_prev[3][3];
+	u32 *comm_bits;
+
+	u8 n[3];
+	u32 licz_t[3];
+	u8 my_addr;
+	u16 startup_timer;
+	u16 przegl_prev[3];
+	u16 bits_prev[3];
+	u16 no_stream_timer;
+	u8 blok_z_zew_prev;
+
+	struct stream_frame *ownstream;
+	struct stream_frame *original_stream;
+};
+
+struct r87l_io
+{
+	u32 stan_bl_in;
+	u32 test_in;
+	u32 stream1_ptr_in;
+	u32 stream2_ptr_in;
+	u32 stream3_ptr_in;
+	u32 streams_ok_in;
+	u32 zezw_w1f_in;
+	u32 przeglad_in;
+	//u32 test_1str_in;
+	//u32 ownstream_ptr_in;
+
+	u32 W_out;
+	u32 WL1_out;
+	u32 WL2_out;
+	u32 WL3_out;
+	u32 Z_out;
+	u32 ZL1_out;
+	u32 ZL2_out;
+	u32 ZL3_out;
+	u32 P_out;
+	u32 PL1_out;
+	u32 PL2_out;
+	u32 PL3_out;
+	u32 bl_2h_L1_out;
+	u32 bl_2h_L2_out;
+	u32 bl_2h_L3_out;
+	u32 bl_5h_L1_out;
+	u32 bl_5h_L2_out;
+	u32 bl_5h_L3_out;
+	u32 zzew1_out;
+	u32 zzew2_out;
+	u32 zzew3_out;
+	u32 di_l1_float_out;
+	u32 di_l2_float_out;
+	u32 di_l3_float_out;
+	u32 ih_l1_float_out;
+	u32 ih_l2_float_out;
+	u32 ih_l3_float_out;
+	u32 i2h_l1_float_out;
+	u32 i2h_l2_float_out;
+	u32 i2h_l3_float_out;
+	u32 i5h_l1_float_out;
+	u32 i5h_l2_float_out;
+	u32 i5h_l3_float_out;
+	u32 ir_l1_ch_float_out;
+	u32 ir_l2_ch_float_out;
+	u32 ir_l3_ch_float_out;
+	u32 nieobs_out;
+	u32 blok_out;
+	u32 comm_bits_float_out;
+	u32 blok_w_out;
+}__attribute__((__packed__));
+
+
+struct r87l_params
+{
+	u32 bity;
+	u32 GrP1; ///<fabryczna grupa polaczen uzwojen transformatora dla uzwojenia GN (1)
+	u32 GrP2; ///<fabryczna grupa polaczen uzwojen transformatora dla uzwojenia SN (2)
+	u32 GrP3; ///<fabryczna grupa polaczen uzwojen transformatora dla uzwojenia SN (3)
+
+	double Iro;///< poczatkowy prad rozruchowy
+	double Ir;///< graniczny prad rozruchowy
+	double Ihg; ///< graniczny prad stabilizacji
+	double Ihp;///< prad hamujacy przegiecia
+	double Ihd;///< prad rozruchowy blokady czasowej pradu stabilizujacego
+	double tbld; ///< czas blokady dzialania po opuszczeniu strefy blokady czasowej
+	double rd; ///< przesuniecie strefy blokady czasowej od strefy dzialania
+	double kh1;///< wspolczynnik stabilizacji prosta 2
+	double kh2; ///< wspolczynnik stabilizacji prosta 3
+	double t;///< czas opoznienia dzialania
+	double kp;///< wspolczynnik powrotu
+	double k_2h;///< wspolczynnik blokowania druga harmoniczna
+	double k_5h;///< wspolczynnik blokowania piata harmoniczna
+	double PT12;///<przekladnia uzwojen 1-2 transformatora
+	double PT13;///<przekladnia uzwojen 1-3 transformatora
+	u32 adres; //adres wlasnego strumienia danych
+}__attribute__((__packed__));
+
+struct r87l_args
+{
+	struct r87l_io io;
+	struct r87l_params params;
+//	u16 crc;
+}__attribute__((__packed__));
+
+extern void R87L(void *args, void *logic);
+extern int R87L_initlog(void *arguments, void *logic);
+extern u8 r87l_kryterium1(short *licz, u8 pobudzenie, u8 powrot, u8 st, unsigned short powz, unsigned short powp);
+extern void r87l_kryterium2(struct r87l_logic *log,float Ir, float Ih, u8 *pob, u8 idx);
+extern void r87l_przelicz_5h(struct r87l_logic *log,uint16_t Lnr);
+extern void r87l_przelicz_2h(struct r87l_logic *log,uint16_t Lnr);
+extern void r87l_przelicz_1h(struct r87l_logic *log, uint16_t Lnr);
+
+
+
+#endif

src/R87L_8.h

@@ -0,0 +1,269 @@
+/*
+ * R87L_8.h
+ *
+ *  Created on: 24-05-2024
+ *      Author: Krzysztof Jakubczyk
+ */
+
+#ifndef R87L_8_H_
+#define R87L_8_H_
+
+#include "tdefs.h"
+#include "analog_in.h"
+#include "mkstream.h"
+#include "Diff.h"
+
+	struct wskazniki_prad_do_kompensacji_87l_8
+	{
+		float /*struct we_an_diff*/ *Ip[8];
+		float /*struct we_an_diff*/ *Im[8];
+		float /*struct we_an_diff*/ *Ip_prev[8];
+		float /*struct we_an_diff*/ *Im_prev[8];
+
+		float a_p[8][2];
+		float a_m[8][2];
+		float a_pi0[8];
+	};
+
+    struct Nastawy_przeliczone_87_8
+    {
+		float khr_2h;///< wartosc rozruchowa blokady od 2 harmonicznej
+		float khp_2h;///< wartosc powrotowa blokady od 2 harmonicznej
+		float khr_5h;///< wartosc rozruchowa blokady od 5 harmonicznej
+		float khp_5h;///< wartosc powrotowa blokady od 5 harmonicznej
+		float Irr;///< wartosc rozruchowa dzialania bezwarunkowego
+		float Ipr;///< wartosc powrotowa dzialania bezwarunkowego
+		float Ihdr;///<wartosc rozruchowa pradu hamowania zwarcia zewnetrznego
+		float Irdr;///< wartosc rozruchowa pradu roznicowego zwarcia zewnetrznego
+		float kh1r;///<wartosc rozruchowa prosta 2
+		float kh1p;///<wartosc powrotowa prosta 2
+		float kh2r;///<wartosc rozruchowa prosta 3
+		float Ir3c;///< czesc stala nastawy odcinka 3
+		float Ip3c;///< czesc stala nastawy odcinka 3
+		float kh2p;///<wartosc powrotowa prosta 3
+		float kh1r2;///<wartosc rozruchowa prosta 2 (w kwadracie)
+		float kh1p2;///<wartosc powrotowa prosta 2 (w kwadracie)
+		float Iror;///<wartosc rozruchowa pradu prosta 1
+		float Irop;///<wartosc powrotowa pradu prosta 1
+		float Ir4;///< wartosc rozruchowa prosta 4
+		float Ip4;///< wartosc powrotowa prosta 4
+		float Ih1;///< wartosc pradu stabilizacji dla poczatku prostej 2
+		float Ihp;///< wartosc pradu stabilizacji dla poczatku prostej 3
+		float Ihg;///<wartosc pradu stabilizacji dla poczatku prostej 4
+		float I2h_min;
+		float I5h_min;
+		u16 t_sbc;///< czas blokady po stwierdzeniu zwarcia zewnetrznego
+        u32 tz; ///< opoznienie czasu zadzialania przekaznika
+		u8 on; ///< wartosc nastawy aktywnosci przekaznika 1- aktywny
+        u8 w; ///< wartosc nastawy dzialania na wylaczeniee 1 - wylaczenie 0 - tylko sygnalizacja
+        u8 bl; ///< wartosc nastawy aktywnosci blokady dzialania 1- blokada aktywna
+		u8 bl2h;///< wlaczenie blokady od drugiej harmonicznej
+		u8 bl5h;///< wlaczenie blokady od piatej harmonicznej
+		u8 sbc;///< wlaczenie strefy blokady czasowej
+		u8 h;///< wlaczenie granicznej stabilizacji
+		u8 r; ///< wlaczenie strefy bezwarunkowego wylaczenia
+		u8 cross_block; ///cross block do hrmonicznych
+		u8 przyspiesz_dzialanie;
+		u8 przyjmuj_zadzialania;
+		u8 rozwijajace;
+	//	u8 test_1str;
+		struct wskazniki_prad_do_kompensacji_87l_8 L[3]; ///< wskazniki pradow do wyliczenia skompensowanych wejsc faza 1,2,3
+		float a[8];///< wspolczynnik pradu do kompensacji
+		struct stream_frame zero_frame;
+		float zero;
+		float wsp_filtr_sin_[20*2];
+		float wsp_filtr_cos_[20*2];
+		float wsp_filtr_sin2h_[20*2];
+		float wsp_filtr_cos2h_[20*2];
+		float wsp_filtr_sin5h_[20*2];
+		float wsp_filtr_cos5h_[20*2];
+		u8 p2d;
+		u8 p3d;
+		u8 stream_cnt;
+	};
+
+    struct wejscie_wew_87_8
+    {
+    	float buf_Lr[(MAIN_FREQ_PERIOD_MS/LOOP_CYCLE_MS)*2*2][6];
+    	u8 nr_probki;
+    	float orta[6];
+    	float ortb[6];
+    	float Ir[6];
+    	float orta2h[3];
+    	float ortb2h[3];
+    	float I2h[3];
+    	float orta5h[3];
+    	float ortb5h[3];
+    	float I5h[3];
+
+    	float buf_ip[(MAIN_FREQ_PERIOD_MS/LOOP_CYCLE_MS)*2*2][24];
+    	float Ip[9];
+    };
+
+struct r87l_8_logic
+{
+	struct stream_frame *stream[8];
+	struct binary_io streams_ok;
+	struct binary_io test;
+	struct binary_io stan_bl;
+	struct binary_io test_1str;
+	struct binary_io W;
+	struct binary_io Wf[3];
+	struct binary_io Z;
+	struct binary_io Zf[3];
+	struct binary_io P;
+	struct binary_io Pf[3];
+
+	struct Nastawy_przeliczone_87_8 nast_; // struktura z parametrami rozruchowymi
+
+	struct binary_io BL2h1;
+	struct binary_io BL2h2;
+	struct binary_io BL2h3;
+	struct binary_io BL5h1;
+	struct binary_io BL5h2;
+	struct binary_io BL5h3;
+	struct binary_io Zw1;
+	struct binary_io Zw2;
+	struct binary_io Zw3;
+	struct binary_io nieobs;
+	struct binary_io blok;
+	struct binary_io zezw_w1f;
+	struct binary_io przeglad;
+	struct binary_io blok_w;
+	float *Ir1;
+	float *Ir2;
+	float *Ir3;
+	float *Ih1;
+	float *Ih2;
+	float *Ih3;
+	float *I2h1;
+	float *I2h2;
+	float *I2h3;
+	float *I5h1;
+	float *I5h2;
+	float *I5h3;
+	float *Ir_L1_ortb;
+	float *Ir_L2_ortb;
+	float *Ir_L3_ortb;
+
+	struct licz l;
+	struct pobudzenia_czastkowe P_;
+	struct dane_wewnetrzne_Diff dw;
+	enum jaki_uklad jaki_uklad;
+//	struct pobudzenia_czastkowe P_;
+	struct wejscie_wew_87_8 w;
+	float Ir1_;
+	float Ir2_;
+	float Ir3_;
+	float Ih1_;
+	float Ih2_;
+	float Ih3_;
+
+	float A[8][3];
+	float A_prev[8][3];
+	u32 *comm_bits;
+
+	u8 n[3];
+	u32 licz_t[3];
+	u8 my_addr;
+	u16 startup_timer;
+	u16 przegl_prev[8];
+	u16 bits_prev[8];
+	u16 no_stream_timer;
+	u8 blok_z_zew_prev;
+
+	struct stream_frame *ownstream;
+	struct stream_frame *original_stream;
+};
+
+struct r87l_8_io
+{
+	u32 stan_bl_in;
+	u32 test_in;
+	u32 stream1_ptr_in;
+	u32 stream2_ptr_in;
+	u32 stream3_ptr_in;
+	u32 stream4_ptr_in;
+	u32 stream5_ptr_in;
+	u32 stream6_ptr_in;
+	u32 stream7_ptr_in;
+	u32 stream8_ptr_in;
+	u32 streams_ok_in;
+	u32 zezw_w1f_in;
+	u32 przeglad_in;
+	u32 test_1str_in;
+	u32 ownstream_ptr_in;
+	u32 W_out;
+	u32 WL1_out;
+	u32 WL2_out;
+	u32 WL3_out;
+	u32 Z_out;
+	u32 ZL1_out;
+	u32 ZL2_out;
+	u32 ZL3_out;
+	u32 P_out;
+	u32 PL1_out;
+	u32 PL2_out;
+	u32 PL3_out;
+	u32 bl_2h_L1_out;
+	u32 bl_2h_L2_out;
+	u32 bl_2h_L3_out;
+	u32 bl_5h_L1_out;
+	u32 bl_5h_L2_out;
+	u32 bl_5h_L3_out;
+	u32 zzew1_out;
+	u32 zzew2_out;
+	u32 zzew3_out;
+	u32 di_l1_float_out;
+	u32 di_l2_float_out;
+	u32 di_l3_float_out;
+	u32 ih_l1_float_out;
+	u32 ih_l2_float_out;
+	u32 ih_l3_float_out;
+	u32 i2h_l1_float_out;
+	u32 i2h_l2_float_out;
+	u32 i2h_l3_float_out;
+	u32 i5h_l1_float_out;
+	u32 i5h_l2_float_out;
+	u32 i5h_l3_float_out;
+	u32 ir_l1_ch_float_out;
+	u32 ir_l2_ch_float_out;
+	u32 ir_l3_ch_float_out;
+	u32 nieobs_out;
+	u32 blok_out;
+	u32 comm_bits_float_out;
+	u32 blok_w_out;
+}__attribute__((__packed__));
+
+
+struct r87l_8_params
+{
+	u32 bity;
+	long liczba_jednostek;
+	double Iro;///< poczatkowy prad rozruchowy
+	double Ir;///< graniczny prad rozruchowy
+	double Ihg; ///< graniczny prad stabilizacji
+	double Ihp;///< prad hamujacy przegiecia
+	double Ihd;///< prad rozruchowy blokady czasowej pradu stabilizujacego
+	double tbld; ///< czas blokady dzialania po opuszczeniu strefy blokady czasowej
+	double rd; ///< przesuniecie strefy blokady czasowej od strefy dzialania
+	double kh1;///< wspolczynnik stabilizacji prosta 2
+	double kh2; ///< wspolczynnik stabilizacji prosta 3
+	double t;///< czas opoznienia dzialania
+	double kp;///< wspolczynnik powrotu
+	double k_2h;///< wspolczynnik blokowania druga harmoniczna
+	double k_5h;///< wspolczynnik blokowania piata harmoniczna
+	u32 adres; //adres wlasnego strumienia danych
+}__attribute__((__packed__));
+
+struct r87l_8_args
+{
+	struct r87l_8_io io;
+	struct r87l_8_params params;
+//	u16 crc;
+}__attribute__((__packed__));
+
+extern void R87L_8(void *args, void *logic);
+extern int R87L_8_initlog(void *arguments, void *logic);
+
+#endif

src/RNT.c

@@ -0,0 +1,837 @@
+/*
+ * RNT.c
+ *
+ *  Created on: 14-11-2018
+ *      Author: Krzysztof Jakubczyk
+ */
+
+#include "tdefs.h"
+#include "misc.h"
+
+#include "RNT.h"
+#include "analog_in.h"
+/*#include "helper.h"
+#include "ZDistL.h"
+*/
+#include <math.h>
+
+
+int rnt_initlog(void *arguments, void *logic)
+{
+	struct rnt_args *args = (struct rnt_args *)arguments;
+	struct rnt_logic *log = (struct rnt_logic *)logic;
+
+	if(set_bit_ptr_struct(args->io.stan_bl_in,&log->stan_bl_))
+		return -1;
+
+	if(set_bit_ptr_struct(args->io.man_in,&log->man_))
+		return -1;
+
+	if(set_bit_ptr_struct(args->io.auto_in,&log->auto_))
+		return -1;
+
+	if(set_float_ptr(args->io.orta_U1_float_in,&log->orta_U1_))
+		return -1;
+
+	if(set_float_ptr(args->io.ortb_U1_float_in,&log->ortb_U1_))
+		return -1;
+
+	if(set_float_ptr(args->io.kwampl_U1_float_in,&log->kwampl_U1_))
+		return -1;
+
+	if(set_bit_ptr_struct(args->io.kon_U1_in,&log->kon_U1_))
+		return -1;
+
+	if(set_float_ptr(args->io.orta_I1_float_in,&log->orta_I1_))
+		return -1;
+
+	if(set_float_ptr(args->io.ortb_I1_float_in,&log->ortb_I1_))
+		return -1;
+
+	if(set_float_ptr(args->io.kwampl_I1_float_in,&log->kwampl_I1_))
+		return -1;
+
+	if(set_float_ptr(args->io.orta_U2_float_in,&log->orta_U2_))
+		return -1;
+
+	if(set_float_ptr(args->io.ortb_U2_float_in,&log->ortb_U2_))
+		return -1;
+
+	if(set_float_ptr(args->io.kwampl_U2_float_in,&log->kwampl_U2_))
+		return -1;
+
+	if(set_bit_ptr_struct(args->io.kon_U2_in,&log->kon_U2_))
+		return -1;
+
+	if(set_float_ptr(args->io.orta_I2_float_in,&log->orta_I2_))
+		return -1;
+
+	if(set_float_ptr(args->io.ortb_I2_float_in,&log->ortb_I2_))
+		return -1;
+
+	if(set_float_ptr(args->io.kwampl_I2_float_in,&log->kwampl_I2_))
+		return -1;
+
+	if(set_float_ptr(args->io.nr_zacz_in,&log->nr_zacz_))
+		return -1;
+
+	if(set_bit_ptr_struct(args->io.zo_zacz_in,&log->zo_zacz_))
+		return -1;
+
+	if(set_bit_ptr_struct(args->io.kon_u_nr_zacz_in,&log->kon_u_nr_zacz_))
+		return -1;
+
+
+	if(set_bit_ptr_struct(args->io.bieg_in,&log->bieg_))
+		return -1;
+
+
+	if(set_bit_ptr_struct(args->io.gora_in,&log->gora_))
+		return -1;
+
+	if(set_bit_ptr_struct(args->io.dol_in,&log->dol_))
+		return -1;
+
+	if(set_bit_ptr_struct(args->io.aktU1z_in,&log->aktU1z_))
+		return -1;
+
+	if(set_bit_ptr_struct(args->io.aktU2z_in,&log->aktU2z_))
+		return -1;
+
+	if(set_bit_ptr_struct(args->io.aktU3z_in,&log->aktU3z_))
+		return -1;
+
+	if(set_bit_ptr_struct(args->io.aktU4z_in,&log->aktU4z_))
+		return -1;
+
+	if(set_bit_ptr_struct(args->io.bl_gora_in,&log->bl_gora_))
+		return -1;
+
+	if(set_bit_ptr_struct(args->io.bl_dol_in,&log->bl_dol_))
+		return -1;
+
+
+	if(set_bit_ptr_struct(args->io.test_in,&log->test_))
+		return -1;
+
+	if(set_bit_ptr_struct(args->io.kas_in,&log->kas_))
+		return -1;
+
+
+	if(set_bit_ptr_struct(args->io.gora_out,&log->gora_out_))
+		return -1;
+
+	if(set_bit_ptr_struct(args->io.dol_out,&log->dol_out_))
+		return -1;
+
+	if(set_bit_ptr_struct(args->io.e_bieg_out,&log->e_bieg_out_))
+		return -1;
+	if(set_bit_ptr_struct(args->io.e_poz_out,&log->e_poz_out_))
+		return -1;
+
+	if(set_bit_ptr_struct(args->io.pob_G_out,&log->pob_G))
+		return -1;
+
+	if(set_bit_ptr_struct(args->io.pob_D_out,&log->pob_D))
+		return -1;
+	if(set_bit_ptr_struct(args->io.blok_out,&log->blok_out_))
+		return -1;
+	if(set_bit_ptr_struct(args->io.blok_trw_out,&log->blok_trw_out_))
+		return -1;
+
+	if(set_bit_ptr_struct(args->io.ster_poz_in,&log->ster_poz_))
+		return -1;
+	if(set_float_ptr(args->io.zad_zacz_in,&log->nr_zacz_zad))
+		return -1;
+
+	if(set_bit_ptr_struct(args->io.blok_trw_in,&log->blok_trw_))
+		return -1;
+	if(set_bit_ptr_struct(args->io.blad_trybu_out,&log->blad_trybu_out_))
+		return -1;
+
+
+
+	if(set_float_ptr(args->io.Uodn_float_out,&log->U_odn))
+		return -1;
+	if(set_float_ptr(args->io.tg_out,&log->tg_out))
+		return -1;
+	if(set_float_ptr(args->io.td_out,&log->td_out))
+		return -1;
+
+
+	if(set_pointer_in_ptr(args->io.I1_params_ptr_in,(u32 *)&log->I_params[0]))
+		return -1;
+	if(set_pointer_in_ptr(args->io.I2_params_ptr_in,(u32 *)&log->I_params[1]))
+		return -1;
+	if(set_pointer_in_ptr(args->io.U1_params_ptr_in,(u32 *)&log->U_params[0]))
+		return -1;
+	if(set_pointer_in_ptr(args->io.U2_params_ptr_in,(u32 *)&log->U_params[1]))
+		return -1;
+
+
+	////
+	//status_rej = oczekiwanie;
+
+	
+	log->nast_.tryb = args->params.tryb;
+	
+
+	log->nast_.t1 = ((args->params.t1) * 1000); //czas dzialania t1
+	log->nast_.t2 = ((args->params.t2) * 1000); //czas dzialania t2
+	
+	log->nast_.dUzr = args->params.dUz; //napicie nieczuoci
+	log->nast_.dUzp = log->nast_.dUzr * args->params.kp; //napicie nieczuoci
+
+	log->nast_.Uz1 = args->params.Uz1 ; //napicie zadane nr 1
+	log->nast_.Uz2 = args->params.Uz2 ; //napicie zadane nr 2
+	log->nast_.Uz3 = args->params.Uz3 ; //napicie zadane nr 3
+	log->nast_.Uz4 = args->params.Uz4 ; //napicie zadane nr 4
+
+
+	log->nast_.t_ster_zacz = ((args->params.t_ster_zacz) * 1000); //czas sterowania przecznikiem zaczepw
+	log->nast_.t_poz_zacz = ((args->params.t_poz_zacz) * 1000); //czas odpowiedzi pozycji przecznika zaczepw
+	log->nast_.t_imp_ster = ((args->params.t_imp_ster) * 1000);// czas impulsu gra/d
+	log->nast_.on = ((args->params.akt & 0x0001)!=0) ? 1:0;
+	log->nast_.kon_biegu = ((args->params.akt & 0x0002)!=0) ? 1:0;
+	log->nast_.kon_poz_ster = ((args->params.akt & 0x0004)!=0) ? 1:0;
+	log->nast_.akt_kon_U1 = ((args->params.akt & 0x0008)!=0) ? 1:0;
+	log->nast_.akt_kon_U2 = ((args->params.akt & 0x0010)!=0) ? 1:0;
+	log->nast_.akt_kon_Uzacz = ((args->params.akt & 0x0020)!=0) ? 1:0;
+	log->nast_.akt_blok_biegu = ((args->params.akt & 0x0040)!=0) ? 1:0;
+	log->nast_.akt_blok_pozycja = ((args->params.akt & 0x0080)!=0) ? 1:0;
+	log->nast_.akt_mfazowe = ((args->params.akt & 0x0100)!=0) ? 1:0;
+
+	log->nast_.akt_komp1 = ((args->params.akt_komp1 & 0x0001)!=0) ? 1:0;
+	log->nast_.akt_komp2 = ((args->params.akt_komp2 & 0x0001)!=0) ? 1:0;
+
+
+	log->_stan_man = CZEKANIE_NA_STEROWANIE_MANUAL;
+	log->dw.blokada_trw = 0;
+	log->dw.timer_blokad_pod_nap1 = 0;
+	log->dw.timer_blokad_pod_nap2 = 0;
+
+	log->mul[0]=(log->I_params[0]->znam_pierw / log->U_params[0]->znam_pierw);
+	log->mul[1]=(log->I_params[1]->znam_pierw / log->U_params[1]->znam_pierw);
+	
+	log->nast_.R1 = args->params.R1 * log->mul[0];
+	log->nast_.X1 = - (args->params.X1 * log->mul[0]);
+	
+	log->nast_.R2 = args->params.R2 * log->mul[1];
+	log->nast_.X2 = - (args->params.X2 * log->mul[1]);
+		
+	return 0;
+}
+
+
+void rnt(void *arguments, void *logic)
+{
+	//struct rnt_args *args = (struct rnt_args *)arguments;
+	struct rnt_logic *log = (struct rnt_logic *)logic;
+	float local_orta_U1_ ,local_ortb_U1_,local_orta_U2_ ,local_ortb_U2_, local_kwa_U_, local_Uz;
+	float local_U_;
+
+	//u8 wk,wk2,l_nrl;
+	u8 blok; //blokada 
+
+
+//check_struct(&log->stan_bl_) - sprawdzenie blokady
+//check_and_set_struct(log->dw.,&log->gora_out_);
+//set_struct(&log->gora_out_);
+//log->dw.go
+
+    if(log->nast_.on)   // jesli zabezpieczenie aktywne
+    {
+		log->w.kwampl_U1_ = *log->kwampl_U1_;
+		log->w.kwampl_U2_ = *log->kwampl_U2_;
+		log->w.kwampl_I1_ = *log->kwampl_I1_;
+		log->w.kwampl_I2_ = *log->kwampl_I2_;
+		if (log->nast_.akt_mfazowe)
+			{
+			log->w.orta_U1_ = *log->ortb_U1_;
+			log->w.orta_U2_ = *log->ortb_U2_;
+			log->w.ortb_U1_ = -*log->orta_U1_;
+			log->w.ortb_U2_ = -*log->orta_U2_;
+			log->w.orta_I1_ = *log->orta_I1_ * 1.73f;
+			log->w.orta_I2_ = *log->orta_I2_ * 1.73f;
+			log->w.ortb_I1_ = *log->ortb_I1_ * 1.73f;
+			log->w.ortb_I2_ = *log->ortb_I2_ * 1.73f;
+			}
+		else
+			{
+			log->w.orta_U1_ = *log->orta_U1_;
+			log->w.orta_U2_ = *log->orta_U2_;
+			log->w.ortb_U1_ = *log->ortb_U1_;
+			log->w.ortb_U2_ = *log->ortb_U2_;
+			log->w.orta_I1_ = *log->orta_I1_;
+			log->w.orta_I2_ = *log->orta_I2_;
+			log->w.ortb_I1_ = *log->ortb_I1_;
+			log->w.ortb_I2_ = *log->ortb_I2_;
+			}
+		log->w.nr_zacz_ = *log->nr_zacz_;
+		log->w.nr_zacz_zad = *log->nr_zacz_zad;
+
+		//sprawdzenie czy mona sterowa w dol
+		log->dw.blokada_ster_dol  = (check_struct(&log->bl_dol_))!=0 ? 1:0;
+		//sprawdzenie czy mona sterowa w gore
+		log->dw.blokada_ster_gora = (check_struct(&log->bl_gora_))!=0 ? 1:0;
+
+		if (check_struct(&log->kas_))
+			{
+				//kasowanie
+				clear_struct(&log->e_bieg_out_);
+				clear_struct(&log->e_poz_out_);
+			}
+
+		if (check_struct(&log->kas_))
+			{
+				if (!check_struct(&log->blok_trw_))
+				{
+					log->dw.blokada_trw = 0;
+				}
+				
+			}
+		if (check_struct(&log->blok_trw_))
+				{
+				log->dw.blokada_trw = 1;
+
+				}
+		check_and_set_struct(log->dw.blokada_trw, &log->blok_trw_out_);
+		
+		
+		if (check_struct(&log->man_) && (!check_struct(&log->ster_poz_)) && (!check_struct(&log->auto_)))
+		{
+			//tryb rczny
+			clear_struct(&log->blad_trybu_out_);
+			blok = check_struct(&log->stan_bl_);
+			check_and_set_struct( blok, &log->blok_out_);
+			//sprawdzenie blokady trwalej
+			blok |= check_struct(&log->blok_trw_out_);
+			
+			clear_struct(&log->pob_G);
+			clear_struct(&log->pob_D);
+			*log->U_odn = 0;
+			*log->tg_out = 0;
+			*log->td_out = 0;
+		}
+		else
+		if (!check_struct(&log->man_)&&(!check_struct(&log->ster_poz_))&&(check_struct(&log->auto_)))
+		{
+			//tryb automatyczny	
+			clear_struct(&log->blad_trybu_out_);
+
+			//sprawdzanie kompensacji linii 1
+			if (log->nast_.akt_komp1)
+				{
+					local_orta_U1_ = log->w.orta_U1_ - ((log->w.orta_I1_ * log->nast_.R1 - log->w.ortb_I1_ * log->nast_.X1));
+					local_ortb_U1_ = log->w.ortb_U1_ - ((log->w.orta_I1_ * log->nast_.X1 + log->w.ortb_I1_ * log->nast_.R1));
+				}
+				else
+				{
+					local_orta_U1_ = log->w.orta_U1_;
+					local_ortb_U1_ = log->w.ortb_U1_;
+				}
+			//sprawdzanie kompensacji linii 2
+			if (log->nast_.akt_komp2)
+				{
+					local_orta_U2_ = log->w.orta_U2_ - ((log->w.orta_I2_ * log->nast_.R2 - log->w.ortb_I2_ * log->nast_.X2));
+					local_ortb_U2_ = log->w.ortb_U2_ - ((log->w.orta_I2_ * log->nast_.X2 + log->w.ortb_I2_ * log->nast_.R2));
+				}
+				else
+				{
+					local_orta_U2_ = log->w.orta_U2_;
+					local_ortb_U2_ = log->w.ortb_U2_;
+				}
+			
+			blok = check_struct(&log->stan_bl_);
+			//sprawdzenie blokady trwalej
+			blok |= check_struct(&log->blok_trw_out_);
+
+			switch(log->nast_.tryb) ///< nastawa trybu dziaania 0-U1 1-U2 2-redniaU1/U2 3-maxU1/U2
+				{
+					case U1:
+						//U1
+						local_kwa_U_= (local_orta_U1_ * local_orta_U1_ + local_ortb_U1_* local_ortb_U1_);
+						if (check_struct(&log->kon_U1_) && log->nast_.akt_kon_U1)
+							log->dw.timer_blokad_pod_nap1 = 0;
+						log->dw.timer_blokad_pod_nap1 +=LOOP_CYCLE_MS;;
+						//blok |= (check_struct(&log->kon_U1_) && log->nast_.akt_kon_U1);
+						blok |=(log->dw.timer_blokad_pod_nap1 < TP_OP_BLOKADY_NAP);
+						break;
+					case U2:
+						//U2
+						local_kwa_U_= (local_orta_U2_ * local_orta_U2_ + local_ortb_U2_* local_ortb_U2_);
+						if (check_struct(&log->kon_U2_) && log->nast_.akt_kon_U2)
+							log->dw.timer_blokad_pod_nap2 = 0;
+						log->dw.timer_blokad_pod_nap2 +=LOOP_CYCLE_MS;;
+						//blok |= (check_struct(&log->kon_U1_) && log->nast_.akt_kon_U1);
+						blok |=(log->dw.timer_blokad_pod_nap2 < TP_OP_BLOKADY_NAP);
+						//blok |= (check_struct(&log->kon_U2_) && log->nast_.akt_kon_U2);
+						break;
+					case sredniaU1U2:
+						//redniaU1/U2
+						local_kwa_U_ = (local_orta_U1_ * local_orta_U1_ + local_ortb_U1_* local_ortb_U1_);
+						local_kwa_U_ += (local_orta_U2_ * local_orta_U2_ + local_ortb_U2_* local_ortb_U2_);
+						local_kwa_U_ *= 0.5f;
+						//blok |= (check_struct(&log->kon_U1_) && log->nast_.akt_kon_U1);
+						//blok |= (check_struct(&log->kon_U2_) && log->nast_.akt_kon_U2);
+
+						if (check_struct(&log->kon_U1_) && log->nast_.akt_kon_U1)
+							log->dw.timer_blokad_pod_nap1 = 0;
+						log->dw.timer_blokad_pod_nap1 +=LOOP_CYCLE_MS;;
+						blok |=(log->dw.timer_blokad_pod_nap1 < TP_OP_BLOKADY_NAP);
+
+
+						if (check_struct(&log->kon_U2_) && log->nast_.akt_kon_U2)
+							log->dw.timer_blokad_pod_nap2 = 0;
+						log->dw.timer_blokad_pod_nap2 +=LOOP_CYCLE_MS;;
+						blok |=(log->dw.timer_blokad_pod_nap2 < TP_OP_BLOKADY_NAP);
+
+						break;
+					case maxU1U2:
+						//max U1/U2 
+						//blok |= (check_struct(&log->kon_U1_) && log->nast_.akt_kon_U1);
+						//blok |= (check_struct(&log->kon_U2_) && log->nast_.akt_kon_U2);
+						if (check_struct(&log->kon_U1_) && log->nast_.akt_kon_U1)
+							log->dw.timer_blokad_pod_nap1 = 0;
+						log->dw.timer_blokad_pod_nap1 +=LOOP_CYCLE_MS;;
+						blok |=(log->dw.timer_blokad_pod_nap1 < TP_OP_BLOKADY_NAP);
+
+
+						if (check_struct(&log->kon_U2_) && log->nast_.akt_kon_U2)
+							log->dw.timer_blokad_pod_nap2 = 0;
+						log->dw.timer_blokad_pod_nap2 +=LOOP_CYCLE_MS;;
+						blok |=(log->dw.timer_blokad_pod_nap2 < TP_OP_BLOKADY_NAP);
+
+						if ((log->w.kwampl_U1_)>(log->w.kwampl_U2_)) 
+						{
+						local_kwa_U_= (local_orta_U1_ * local_orta_U1_ + local_ortb_U1_* local_ortb_U1_);
+						}
+						else
+						{
+						local_kwa_U_= (local_orta_U2_ * local_orta_U2_ + local_ortb_U2_* local_ortb_U2_);
+						}
+						break;
+					default:
+						break;
+				}
+			//
+			blok |= (check_struct(&log->kon_u_nr_zacz_) && log->nast_.akt_kon_Uzacz);
+			check_and_set_struct( blok, &log->blok_out_);
+
+			//w local_kwa_U_ - kwadrat napicia odniesienia
+			local_kwa_U_ *= 0.5f;
+			local_U_ = sqrtf (local_kwa_U_);
+			*log->U_odn = local_kwa_U_;
+			
+			//Wybr napicia Uz - napicie zadane
+			if (check_struct(&log->aktU1z_))
+				local_Uz = log->nast_.Uz1;
+				else
+				if (check_struct(&log->aktU2z_))
+					local_Uz = log->nast_.Uz2;
+					else
+					if (check_struct(&log->aktU3z_))
+						local_Uz = log->nast_.Uz3;
+						else
+						if (check_struct(&log->aktU4z_))
+							local_Uz = log->nast_.Uz4;
+							else
+							local_Uz = log->nast_.Uz1;
+			//porownanie war pobudzenia
+			//local_Uz - local_kwa_U_ ;
+			sprawdz_P(&log->dw.pob_D,
+					  ((local_Uz - local_U_ ) < (- log->nast_.dUzr)),
+					  ((local_Uz - local_U_ ) > (- log->nast_.dUzp)),
+					  &log->dw.lp_D,
+					  100,100
+					  );
+			sprawdz_P(&log->dw.pob_G,
+					  ((local_Uz - local_U_ ) > log->nast_.dUzr),
+					  ((local_Uz - local_U_ ) < log->nast_.dUzp),
+					  &log->dw.lp_G,
+					  100,100
+					  );
+			check_and_set_struct((log->dw.pob_G > 0)&&(!blok)&&(!log->dw.blokada_ster_gora),&log->pob_G);
+			check_and_set_struct((log->dw.pob_D > 0)&&(!blok)&&(!log->dw.blokada_ster_dol),&log->pob_D);
+		}
+		else
+		if (!check_struct(&log->man_)&&(check_struct(&log->ster_poz_))&&(!check_struct(&log->auto_)))
+			{
+			//tryb nr zaczepu
+			clear_struct(&log->blad_trybu_out_);
+			//jesli zadany jest nr zaczepu 
+			blok = check_struct(&log->stan_bl_);
+			blok |= (check_struct(&log->kon_u_nr_zacz_) && log->nast_.akt_kon_Uzacz);
+			check_and_set_struct( blok, &log->blok_out_);
+			//sprawdzenie blokady trwalej
+			blok |= check_struct(&log->blok_trw_out_);
+		
+			//(check_struct(&log->ster_poz_)) == 1
+			if (((log->w.nr_zacz_zad) < (log->w.nr_zacz_)) && (!log->dw.blokada_ster_dol) && (!blok))
+				{
+					log->dw.pob_D = 1;
+					log->dw.pob_G = 0;
+				}
+				else
+				if (((log->w.nr_zacz_zad) > (log->w.nr_zacz_)) && (!log->dw.blokada_ster_gora) && (!blok))
+				{
+					log->dw.pob_D = 0;
+					log->dw.pob_G = 1;
+				}
+				else
+				{
+					log->dw.pob_D = 0;
+					log->dw.pob_G = 0;
+				}
+
+			check_and_set_struct((log->dw.pob_G > 0)&&(!blok)&&(!log->dw.blokada_ster_gora) ,&log->pob_G);
+			check_and_set_struct((log->dw.pob_D > 0)&&(!blok)&&(!log->dw.blokada_ster_dol) ,&log->pob_D);
+			}
+			else
+			{
+				//blad wyboru rodzaju pracy
+				clear_struct(&log->pob_D);
+				clear_struct(&log->pob_G);
+				set_struct( &log->blok_out_);
+				set_struct(&log->blad_trybu_out_);
+
+			}
+		//
+		
+		switch (log->_stan_man)
+			{
+				case CZEKANIE_NA_STEROWANIE_MANUAL:
+					if (!check_struct(&log->man_))
+					{
+						//sprawdzenie czy nie przeczy na AUTO
+						log->_stan_man = CZEKANIE_NA_STEROWANIE_AUTO;
+						log->licz_t1G = log->licz_t2G = 0;
+						log->licz_t1D = log->licz_t2D = 0;
+					}
+					else
+					{
+					if(check_struct(&log->gora_) && (!check_struct(&log->dol_)) && (!log->dw.blokada_ster_gora) && (!blok))
+					{
+						*log->tg_out = 0;
+						*log->td_out = 0;
+						log->licznik_ster_gora+=LOOP_CYCLE_MS;
+						if (log->licznik_ster_gora > T_STER_RECZNEGO)					
+						{
+							log->_stan_man = STEROWANIE_W_GORE;
+							log->licznik_ster_gora =0;
+						}
+						log->licznik_ster_dol =0;
+					}
+						else
+						//log->dw.pob_G;
+					if(check_struct(&log->dol_) && (!check_struct(&log->gora_)) && (!log->dw.blokada_ster_dol) && (!blok))
+					{
+						log->licznik_ster_dol+=LOOP_CYCLE_MS;
+						if (log->licznik_ster_dol > T_STER_RECZNEGO)					
+						{
+						log->_stan_man = STEROWANIE_W_DOL;
+						log->licznik_ster_dol =0;
+						}
+						log->licznik_ster_gora =0;
+					}
+					else
+					{
+						log->licznik_ster_dol = 0;
+						log->licznik_ster_gora = 0;
+						clear_struct(&log->gora_out_);
+						clear_struct(&log->dol_out_);
+
+					}
+					}
+					break;
+				case CZEKANIE_NA_STEROWANIE_NR_POZYCJI:
+					if (!check_struct(&log->ster_poz_))
+					{
+						//sprawdzenie czy nie przeczy na AUTO
+						log->_stan_man = CZEKANIE_NA_STEROWANIE_AUTO;
+						log->licz_t1G = log->licz_t2G = 0;
+						log->licz_t1D = log->licz_t2D = 0;
+					}
+					else
+					{
+					if(log->dw.pob_G && (!log->dw.pob_D) && (!log->dw.blokada_ster_gora) && (!blok))
+					{
+					//(check_struct(&log->ster_poz_)) == 1
+									//gora nr pozycji
+									if (log->licz_t2G < log->nast_.t2)
+									{
+										log->licz_t2G += LOOP_CYCLE_MS;
+									}
+									else
+									{
+									log->_stan_man = STEROWANIE_W_GORE;
+									log->licz_t2G = 0;
+									}
+
+					*log->tg_out = (float)(log->nast_.t2 - log->licz_t2G) * 0.001f;
+					*log->td_out = 0;
+
+					}
+					else
+					if((log->dw.pob_D) && (!log->dw.pob_G) && (!log->dw.blokada_ster_dol) && (!blok))
+					{
+									//dol nr pozycji
+									if (log->licz_t2D < log->nast_.t2)
+									{
+										log->licz_t2D += LOOP_CYCLE_MS;
+									}
+									else
+									{
+									log->_stan_man = STEROWANIE_W_DOL;
+									log->licz_t2D = 0;
+									}
+					*log->td_out = (float)(log->nast_.t2 - log->licz_t2D) * 0.001f;
+					*log->tg_out = 0;
+					}
+					}
+					break;
+				case CZEKANIE_NA_STEROWANIE_AUTO:
+					if (check_struct(&log->man_))
+					{
+						//sprawdzenie czy nie przeczy na MANUAL
+						log->_stan_man = CZEKANIE_NA_STEROWANIE_MANUAL;
+					}
+					else
+					if (check_struct(&log->ster_poz_))
+					{
+						//sprawdzenie czy nie przeczy na NR_POZ
+						log->_stan_man = CZEKANIE_NA_STEROWANIE_NR_POZYCJI;
+					}
+					else
+					if (log->dw.pob_G && (!log->dw.pob_D) && (!log->dw.blokada_ster_gora)&& (!blok))
+					{
+						//gora auto
+						if (log->licz_t1G < log->nast_.t1)
+						{
+							log->licz_t1G += LOOP_CYCLE_MS * ((local_Uz - local_U_ ) / log->nast_.dUzr);
+						}
+						else
+						if (log->licz_t2G < log->nast_.t2)
+						{
+							log->licz_t2G += LOOP_CYCLE_MS;
+						}
+						else
+						{
+						log->_stan_man = STEROWANIE_W_GORE;
+						log->licz_t1G = log->licz_t2G = 0;
+						}
+					*log->tg_out = (float)((log->nast_.t1 + log->nast_.t2 - log->licz_t1G - log->licz_t2G) * 0.001f);
+					*log->td_out = 0;
+					}
+						else
+					if(log->dw.pob_D && (!log->dw.pob_G) && (!log->dw.blokada_ster_dol)&& (!blok))
+					{
+						//dol auto
+						if (log->licz_t1D < log->nast_.t1)
+						{
+							log->licz_t1D += LOOP_CYCLE_MS *((local_Uz - local_U_ ) / -log->nast_.dUzr);
+						}
+						else
+						if (log->licz_t2D < log->nast_.t2)
+						{
+							log->licz_t2D += LOOP_CYCLE_MS;
+						}
+						else
+						{
+						log->_stan_man = STEROWANIE_W_DOL;
+						log->licz_t1D = log->licz_t2D = 0;
+						}
+					*log->td_out = (log->nast_.t1 + log->nast_.t2 - log->licz_t1D - log->licz_t2D) * 0.001f;
+					*log->tg_out = 0;
+					}
+					else
+					{
+						*log->td_out = 0;
+						*log->tg_out = 0;
+						log->licz_t1G = log->licz_t2G = 0;
+						log->licz_t1D = log->licz_t2D = 0;
+						clear_struct(&log->gora_out_);
+						clear_struct(&log->dol_out_);
+					}
+					break;
+			//gora
+				case STEROWANIE_W_GORE:
+						*log->td_out = 0;
+						*log->tg_out = 0;
+						set_struct(&log->gora_out_);
+						log->_stan_man = IMPULS_W_GORE;
+						log->licznik_ster_biegu = 0;
+						log->licznik_ster_gora = 0;
+						log->nr_zaczepu_przed_ster = log->w.nr_zacz_;
+						clear_struct(&log->e_bieg_out_);
+						clear_struct(&log->e_poz_out_);
+						log->dw.byl_bieg = 0;
+
+					break;
+				case IMPULS_W_GORE:
+					log->licznik_ster_gora+=LOOP_CYCLE_MS;
+					if ((log->licznik_ster_gora > log->nast_.t_imp_ster))
+					{
+						log->licznik_ster_gora = 0;
+						log->licznik_poz_gora = 0;
+						log->_stan_man = SPRAWDZENIE_ODP_PRZE_ZACZEPOW_GORA;
+						clear_struct(&log->gora_out_);
+						if ((log->nast_.kon_biegu) && (!(log->dw.byl_bieg & 0x1 >0) ))
+								set_struct(&log->e_bieg_out_);
+					}
+					else
+					{
+						if ((log->nast_.kon_biegu) && (check_struct(&log->bieg_)))
+						{
+							log->dw.byl_bieg |=1;
+							log->licznik_ster_biegu+=LOOP_CYCLE_MS;
+							if (((log->licznik_ster_biegu > log->nast_.t_ster_zacz)))
+								{
+									set_struct(&log->e_bieg_out_);
+								}
+						}
+
+
+					}
+					
+					break;
+				case SPRAWDZENIE_ODP_PRZE_ZACZEPOW_GORA:
+				//sprawdzenie odpowiedzi przecznika zaczepw tj.  czas max, zmiana nr +1, itp
+				//trzeba si zastanowic jak kontrolowa sygna BIEG_PRZE_ZACZ??
+					if ((((log->nast_.kon_biegu)&&((!check_struct(&log->bieg_))&&(log->dw.byl_bieg & 0x01))||(check_struct(&log->e_bieg_out_))||(!(log->nast_.kon_biegu)))) && (!check_struct(&log->zo_zacz_)))
+						{
+							log->_stan_man = KONIEC_STEROWANIA;
+							if ((log->nast_.kon_poz_ster)&&(log->w.nr_zacz_ <= log->nr_zaczepu_przed_ster))							
+							{
+								set_struct(&log->e_poz_out_);
+							}
+						}
+						else
+						{
+						log->licznik_ster_biegu+=LOOP_CYCLE_MS;
+						if (((log->licznik_ster_biegu > log->nast_.t_ster_zacz))&&(check_struct(&log->bieg_))&&(log->nast_.kon_biegu))
+							{
+								log->_stan_man = KONIEC_STEROWANIA;
+								set_struct(&log->e_bieg_out_);
+							}
+						}
+					break;
+			//dol		
+				case STEROWANIE_W_DOL:
+						*log->td_out = 0;
+						*log->tg_out = 0;
+						set_struct(&log->dol_out_);
+						log->_stan_man = IMPULS_W_DOL;
+						log->licznik_ster_dol = 0;
+						log->licznik_ster_biegu = 0;
+						log->nr_zaczepu_przed_ster = log->w.nr_zacz_;
+						clear_struct(&log->e_bieg_out_);
+						clear_struct(&log->e_poz_out_);
+						log->dw.byl_bieg =0;
+					break;
+				case IMPULS_W_DOL:
+					{
+					log->licznik_ster_dol+=LOOP_CYCLE_MS;
+					if ((log->licznik_ster_dol > log->nast_.t_imp_ster))
+					{
+						log->licznik_ster_gora = 0;
+						log->licznik_poz_gora = 0;
+						log->_stan_man = SPRAWDZENIE_ODP_PRZE_ZACZEPOW_DOL;
+						clear_struct(&log->dol_out_);
+						if ((log->nast_.kon_biegu) && (!(log->dw.byl_bieg & 0x1 > 0)))
+								set_struct(&log->e_bieg_out_);
+					}
+					else
+					{
+						if ((log->nast_.kon_biegu) && (check_struct(&log->bieg_)))
+						{
+							 log->dw.byl_bieg |=1;
+							 log->licznik_ster_biegu+=LOOP_CYCLE_MS;
+							 if (((log->licznik_ster_biegu > log->nast_.t_ster_zacz)))
+									{
+										set_struct(&log->e_bieg_out_);
+									}
+						}
+
+
+					}
+					}
+					
+					break;
+				case SPRAWDZENIE_ODP_PRZE_ZACZEPOW_DOL:
+				//sprawdzenie odpowiedzi przecznika zaczepw tj.  czas max, zmiana nr +1, itp
+					if ((((log->nast_.kon_biegu)&&((!check_struct(&log->bieg_))&&(log->dw.byl_bieg & 0x01))||(check_struct(&log->e_bieg_out_))||(!(log->nast_.kon_biegu)))) && (!check_struct(&log->zo_zacz_)))
+					//if ((log->nast_.kon_biegu)&&(!check_struct(&log->bieg_))||(!(log->nast_.kon_biegu)))
+						{
+							log->_stan_man = KONIEC_STEROWANIA;
+							if ((log->nast_.kon_poz_ster)&&(log->w.nr_zacz_ >= log->nr_zaczepu_przed_ster))							
+							{
+								set_struct(&log->e_poz_out_);
+							}
+						}
+						else
+						{
+						log->licznik_ster_biegu+=LOOP_CYCLE_MS;
+						if (((log->licznik_ster_biegu > log->nast_.t_ster_zacz))&&(check_struct(&log->bieg_))&&(log->nast_.kon_biegu))
+							{
+								log->_stan_man = KONIEC_STEROWANIA;
+								set_struct(&log->e_bieg_out_);
+							}
+						}
+					break;
+				case KONIEC_STEROWANIA:
+					if (check_struct(&log->man_))
+						{
+							//sprawdzenie czy nie przeczy na MANUAL
+							log->_stan_man = CZEKANIE_NA_STEROWANIE_MANUAL;
+						}
+					else
+						if (check_struct(&log->ster_poz_))
+						{
+							//sprawdzenie czy nie przeczy na NR_POZ
+							log->_stan_man = CZEKANIE_NA_STEROWANIE_NR_POZYCJI;
+						}
+					else
+						{
+							//sprawdzenie czy nie przeczy na AUTO
+							log->_stan_man = CZEKANIE_NA_STEROWANIE_AUTO;
+							log->licz_t1G = log->licz_t2G = 0;
+							log->licz_t1D = log->licz_t2D = 0;
+						}
+					break;
+
+				
+				default:
+					log->_stan_man = CZEKANIE_NA_STEROWANIE_MANUAL;
+					break;
+				
+			}
+	
+	}
+	else
+	{
+		clear_struct(&log->gora_out_);
+		clear_struct(&log->dol_out_);
+		clear_struct(&log->e_bieg_out_);
+		clear_struct(&log->e_poz_out_);
+		clear_struct(&log->pob_G);
+		clear_struct(&log->pob_D);
+		*log->U_odn = 0;
+	}
+}
+
+void rnt_100hz(void *arguments, void *logic)
+{
+	struct rnt_logic *log = (struct rnt_logic *)logic;
+//	int t;
+
+    if(log->nast_.on)   // jesli zabezpieczenie aktywne
+    {
+    }
+}
+
+void rnt_20hz(void *arguments, void *logic)
+{
+	//struct rnt_logic *log = (struct rnt_logic *)logic;
+
+}

src/RNT.h

@@ -0,0 +1,324 @@
+/*
+ * RNT.h
+ *
+ *  Created on: 14-11-2018
+ *      Author: Krzysztof Jakubczyk
+ */
+
+#ifndef RNT_H_
+#define RNT_H_
+
+#include "tdefs.h"
+#include "helper.h"
+
+#define T_STER_RECZNEGO	 	1
+#define TP_OP_BLOKADY_NAP	500
+
+enum _stan_man_rnt
+{
+  	CZEKANIE_NA_STEROWANIE_MANUAL = 0,
+	CZEKANIE_NA_STEROWANIE_NR_POZYCJI = 1,
+	CZEKANIE_NA_STEROWANIE_AUTO = 2,
+
+   	STEROWANIE_W_GORE = 5,
+	IMPULS_W_GORE = 6,
+   	SPRAWDZENIE_ODP_PRZE_ZACZEPOW_GORA = 7,
+
+   	STEROWANIE_W_DOL = 11,
+	IMPULS_W_DOL = 12,
+   	SPRAWDZENIE_ODP_PRZE_ZACZEPOW_DOL = 13,
+	
+   	KONIEC_STEROWANIA = 20
+};
+
+
+struct Nastawy_przeliczone_rnt
+{
+	float R1; ///< wartosc rezystancji linii po str. pierwotnej
+	float X1; ///< wartosc reaktancji linii po str. pierwotnej
+	float R2; ///< wartosc rezystancji linii po str. pierwotnej
+	float X2; ///< wartosc reaktancji linii po str. pierwotnej
+    short tryb; ///< nastawa trybu działania 0-U1 1-U2 2-średniaU1/U2 3-maxU1/U2
+    int t1; ///< opoznienie czasu zadzialania przekaznika
+    int t2; ///< opoznienie czasu zadzialania przekaznika
+
+    float dUzr; ///< wartosc rozruchowa do napięcia nieczułości 
+    float dUzp; ///< wartosc powrotu do napięcia nieczułości 
+	
+    float Uz1; ///< wartosc napięcia zadanego nr 1
+    float Uz2; ///< wartosc napięcia zadanego nr 2
+    float Uz3; ///< wartosc napięcia zadanego nr 3
+    float Uz4; ///< wartosc napięcia zadanego nr 4
+
+	int t_imp_ster; /// czas implusu sterującego gora/doł
+    int t_ster_zacz; ///< czas maks sterowania
+	int t_poz_zacz; /// czas odpowiedzi pozycji zaczepu
+	
+	float kp; ///< wspolczynnik powrotu dla Uz
+	
+    u8 on; ///< wartosc nastawy aktywnosci przekaznika 1- aktywny
+	u8 kon_biegu; /// kontrola biegu sterowania przełącznikiem zaczepów (wg dodatkowego wejscia BIEG)
+	u8 kon_poz_ster; /// kontrola pozycji zaczepu przy sterowaniu (porównanie nr zaczepu przed i po sterowaniu)
+	u8 akt_kon_U1; /// kontrola zabezpieczenia pomiaru U1
+	u8 akt_kon_U2; /// kontrola zabezpieczenia pomiaru U2
+	u8 akt_kon_Uzacz; /// kontrola zabezpieczenia napięcia zaczepu
+	u8 akt_blok_biegu; /// aktywnosc blokady od biegu przełącznika zaczepów
+	u8 akt_blok_pozycja; /// aktywnosc blokady od niewlasciwej pozycji zaczepu po sterowaniu
+	u8 akt_mfazowe; /// aktywne pomiary między fazowe
+	
+    u8 akt_komp1; ///< czy kompensacja 1 jest aktywana 1-aktywana
+    u8 akt_komp2; ///< czy kompensacja 2 jest aktywana 1-aktywana
+
+    u8 bl; ///< wartosc nastawy aktywnosci blokady dzialania 1- blokada aktywna
+};
+
+struct Wejscie_rnt
+{
+    float orta_U1_; ///< ortogonalna a napięcia  wejsciowego U1
+    float ortb_U1_; ///< ortogonalna b napięcia  wejsciowego U1
+    float kwampl_U1_; ///< kwadrat amplitudy prądu
+	float orta_I1_;///< ortogonalna a prądu wejsciowego I1
+	float ortb_I1_;///< ortogonalna b prądu wejsciowego I1
+	float kwampl_I1_;///< kwadrat amplitudy prądu
+    float orta_U2_; ///< ortogonalna a napięcia  wejsciowego U2
+    float ortb_U2_; ///< ortogonalna b napięcia  wejsciowego U2
+    float kwampl_U2_; ///< kwadrat amplitudy napięcia 
+	float orta_I2_;///< ortogonalna a prądu wejsciowego I1
+	float ortb_I2_;///< ortogonalna b prądu wejsciowego I1
+	float kwampl_I2_;///< kwadrat amplitudy prądu
+
+	float nr_zacz_;///nr zaczepu z przełącznika trafo
+	float nr_zacz_zad;///nr zaczepu z przełącznika trafo
+
+};
+
+struct dane_wewnetrzne_rnt
+{
+
+	u8 zacz_w_gore;
+	u8 zacz_w_dol;
+	u8 blokada_trw;
+	u8 blokada_ster_gora;
+	u8 blokada_ster_dol;
+	u8 pob_G; //pobudzenie automatyki G
+	u8 pob_D; //pobudzenie automatyki D
+	short lp_G; //licznik pobudzenia G
+	short lp_D; //licznik pobudzenia D
+	u8 byl_bieg;
+	int timer_blokad_pod_nap1;
+	int timer_blokad_pod_nap2;
+};
+
+struct rnt_logic
+{
+	struct binary_io stan_bl_;
+	struct binary_io man_;
+	struct binary_io auto_;
+
+	float *orta_U1_;
+	float *ortb_U1_;
+	float *kwampl_U1_;
+	struct binary_io kon_U1_;
+
+	float *orta_I1_;
+	float *ortb_I1_;
+	float *kwampl_I1_;
+
+
+	float *orta_U2_;
+	float *ortb_U2_;
+	float *kwampl_U2_;
+	struct binary_io kon_U2_;
+
+	float *orta_I2_;
+	float *ortb_I2_;
+	float *kwampl_I2_;
+
+	float *nr_zacz_;
+	struct binary_io kon_u_nr_zacz_;
+	struct binary_io zo_zacz_;
+
+	struct binary_io gora_;
+	struct binary_io dol_;
+	struct binary_io bieg_;
+	struct binary_io aktU1z_;
+	struct binary_io aktU2z_;
+	struct binary_io aktU3z_;
+	struct binary_io aktU4z_;
+
+	struct binary_io bl_gora_;
+	struct binary_io bl_dol_;
+
+	struct binary_io test_;
+	struct binary_io kas_;
+	
+	struct binary_io blok_trw_;
+	
+	
+
+	struct binary_io gora_out_;
+	struct binary_io dol_out_;
+
+	struct binary_io e_bieg_out_;
+	struct binary_io e_poz_out_;
+	struct binary_io zaczep_min;
+	struct binary_io zaczep_max;
+
+	struct binary_io pob_G;
+	struct binary_io pob_D;
+
+	struct binary_io blok_out_;
+	struct binary_io blok_trw_out_;
+	struct binary_io blad_trybu_out_;
+
+	struct binary_io ster_poz_;
+
+	float *nr_zacz_zad;
+
+	float *U_odn;//napięcie odniesienia
+	float *tg_out;//czas do przełączenia w górę
+	float *td_out;//czas do przełączenia w dół
+
+	struct Nastawy_przeliczone_rnt nast_;
+	struct dane_wewnetrzne_rnt dw;
+	struct Wejscie_rnt w;
+
+    enum _stan_man_rnt _stan_man;
+	u32 licznik_ster_gora;
+	u32 licznik_ster_dol;
+	u32 licznik_poz_gora;
+	u32 licznik_poz_dol;
+	u32 licznik_ster_biegu;
+	
+	u8 nr_zaczepu_przed_ster; //nr zaczepu przed sterowaniem
+	float licz_t1G;
+	int licz_t2G;
+	float licz_t1D;
+	int licz_t2D;
+
+	struct analog_in_params *I_params[2];
+	struct analog_in_params *U_params[2];
+
+	float mul[2];
+	
+	
+};
+
+struct rnt_io
+{
+	u32 stan_bl_in;
+	u32 man_in;
+	u32 auto_in;
+	
+	u32 orta_U1_float_in;
+	u32 ortb_U1_float_in;
+	u32 kwampl_U1_float_in;
+	u32 U1_params_ptr_in;
+	u32 kon_U1_in;
+	u32 orta_I1_float_in;
+	u32 ortb_I1_float_in;
+	u32 kwampl_I1_float_in;
+	u32 I1_params_ptr_in;
+	
+	u32 orta_U2_float_in;
+	u32 ortb_U2_float_in;
+	u32 kwampl_U2_float_in;
+	u32 U2_params_ptr_in;
+	u32 kon_U2_in;
+	u32 orta_I2_float_in;
+	u32 ortb_I2_float_in;
+	u32 kwampl_I2_float_in;
+	u32 I2_params_ptr_in;
+	
+	u32 nr_zacz_in;
+	u32 zo_zacz_in;
+	u32 kon_u_nr_zacz_in;
+
+	u32 bieg_in;
+
+	u32 gora_in;
+	u32 dol_in;
+
+	u32 aktU1z_in;
+	u32 aktU2z_in;
+	u32 aktU3z_in;
+	u32 aktU4z_in;
+
+	u32 bl_gora_in;
+	u32 bl_dol_in;
+
+	u32 test_in;
+	u32 kas_in;
+
+	u32 ster_poz_in;
+	u32 zad_zacz_in;
+	u32 blok_trw_in;
+
+	u32 gora_out;
+	u32 dol_out;
+	u32 e_bieg_out;
+	u32 e_poz_out;
+
+	u32 pob_G_out;
+	u32 pob_D_out;
+	u32 Uodn_float_out;
+	u32 tg_out;
+	u32 td_out;
+	u32 blok_out;
+	u32 blok_trw_out;
+	u32 blad_trybu_out;
+	
+}__attribute__((__packed__));
+
+struct rnt_params
+{
+	u32 akt; ///< nastawy bitowe;
+    u32 tryb; ///< wybór trybu regulacji (0=U1/1=U2/2=średnia U1 z U2/3=maksymalna U1 lub U2)
+	u32 akt_komp1; ///< nastawy bitowe;
+    double R1; ///< rezystancja linii 1 w wart. pier 
+    double X1; ///< reaktanacja linii 1 w wart. pier
+	u32 akt_komp2; ///< nastawy bitowe;
+    double R2; ///< rezystancja linii 2 w wart. pier
+    double X2; ///< reaktanacja linii 2 w wart. pier
+	
+    double t1; ///< wartosc nastawy czasu dzialania ch-ki zależnej w sekundach stopień 1
+    double t2; ///< wartosc nastawy czasu dzialania ch-ki niezależnej w sekundach stopień 2
+    double dUz; ///< dopuszczalne napięcie nieczułości
+    double kp; ///< współczynnik powrotu dla dUz
+
+    double Uz1; ///< zadane napięcie nr 1
+    double Uz2; ///< zadane napięcie nr 2
+    double Uz3; ///< zadane napięcie nr 3
+    double Uz4; ///< zadane napięcie nr 4
+
+    double t_imp_ster; ///< wartosc nastawy impulsu sterującego
+    double t_ster_zacz; ///< wartosc nastawy max. czasu sterowania zaczepu 
+    double t_poz_zacz; ///< wartosc nastawy max. czasu rekacji nr zaczepu 
+
+
+}__attribute__((__packed__));
+
+struct rnt_args
+{
+	struct rnt_io io;
+	struct rnt_params params;
+//	u16 crc;
+}__attribute__((__packed__));
+
+extern void rnt(void *args, void *logic);
+extern void rnt_100hz(void *args, void *logic);
+extern void rnt_20hz(void *args, void *logic);
+extern int rnt_initlog(void *arguments, void *logic);
+
+
+
+enum _tryb_pracy_rnt
+{
+  	U1 = 0,
+   	U2 = 1,
+   	sredniaU1U2 = 2,
+   	maxU1U2 = 3
+};
+
+
+#endif /* RNT_H_ */

src/R_67N_LWN.c

@@ -0,0 +1,507 @@
+/*
+ * R_67N_LWN.c
+ *
+ *  Created on: 20-07-2016
+ *      Author: Krzysztof Jakubczyk
+ */
+
+#include "tdefs.h"
+#include "misc.h"
+
+#include "r_67n_lwn.h"
+#include "analog_in.h"
+#include "helper.h"
+#include "ZDistL.h"
+
+#include <math.h>
+
+int r_67n_lwn_initlog(void *arguments, void *logic)
+{
+	struct r_67n_lwn_args *args = (struct r_67n_lwn_args *)arguments;
+	struct r_67n_lwn_logic *log = (struct r_67n_lwn_logic *)logic;
+
+	if(set_bit_ptr_struct(args->io.stan_bl_in,&log->stan_bl_))
+		return -1;
+
+	if(set_float_ptr(args->io.orta_I_float_in,&log->orta_I_))
+		return -1;
+
+	if(set_float_ptr(args->io.ortb_I_float_in,&log->ortb_I_))
+		return -1;
+
+	if(set_float_ptr(args->io.kwampl_I_float_in,&log->kwampl_I_))
+		return -1;
+
+	if(set_float_ptr(args->io.orta_U_float_in,&log->orta_U_))
+		return -1;
+
+	if(set_float_ptr(args->io.ortb_U_float_in,&log->ortb_U_))
+		return -1;
+
+	if(set_float_ptr(args->io.kwampl_U_float_in,&log->kwampl_U_))
+		return -1;
+
+	if(set_float_ptr(args->io.IL1_float_in,&log->IL1))
+		return -1;
+
+	if(set_float_ptr(args->io.IL2_float_in,&log->IL2))
+		return -1;
+
+	if(set_float_ptr(args->io.IL3_float_in,&log->IL3))
+		return -1;
+
+	if(set_float_ptr(args->io.Io2h_float_in,&log->Io2h))
+		return -1;
+
+	if(set_bit_ptr_struct(args->io.test_in,&log->test))
+		return -1;
+
+	if(set_bit_ptr_struct(args->io.l_odb_in,&log->l_odb))
+		return -1;
+
+	if(set_bit_ptr_struct(args->io.l_ok_in,&log->l_ok))
+		return -1;
+
+	if(set_bit_ptr_struct(args->io.w_out,&log->W))
+		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.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.kier_out,&log->kier))
+		return -1;
+
+	if(set_bit_ptr_struct(args->io.NRL_out,&log->NRL))
+		return -1;
+
+
+	////
+	//status_rej = oczekiwanie;
+
+	log->nast_.on_ = args->params.bity & 0x0001;
+	log->nast_.w1 = args->params.bity & 0x0002;
+	log->nast_.w2 = args->params.bity & 0x0004;
+	log->nast_.Bl_2h1_ON = (args->params.bity & 0x0008)?1:0;
+	log->nast_.Bl_2h2_ON = (args->params.bity & 0x0010)?1:0;
+	log->nast_.bl_ = args->params.bity & 0x0020;
+
+
+	log->nast_.dir = args->params.dir;
+
+    log->nast_.Ir1 = args->params.I1 *  args->params.I1; // wyliczenie wartosci rozruchowej pradu
+    log->nast_.Ir2 = args->params.I2 *  args->params.I2; // wyliczenie wartosci rozruchowej pradu
+
+	log->nast_.Ip1 = log->nast_.Ir1 * args->params.kp * args->params.kp; // wyliczenie wartoci powrotu algorytmu
+    log->nast_.Ip2 = log->nast_.Ir2 * args->params.kp * args->params.kp; // wyliczenie wartoci powrotu algorytmu
+
+	log->nast_.kh1 = args->params.kh1 * args->params.kh1;
+	log->nast_.khp1 = log->nast_.kh1 * args->params.kp * args->params.kp;
+	log->nast_.kh2 = args->params.kh2 * args->params.kh2;
+	log->nast_.khp2 = log->nast_.kh2 * args->params.kp * args->params.kp;
+
+    log->nast_.U_echo = args->params.L_U_echo *  args->params.L_U_echo; // wyliczenie wartosci rozruchowej blokady napieciowej
+    log->nast_.Ur = args->params.U *  args->params.U; // wyliczenie wartosci rozruchowej blokady napieciowej
+    log->nast_.Up = log->nast_.Ur * args->params.kp * args->params.kp; // wyliczenie wartosci powrotu blokady napieciowej
+    log->nast_.orta = cos(args->params.kat * (3.14159f / 180)); // wartosc ortogonalnej a wektora przesuniecia dla kata charakterystycznego
+    log->nast_.ortb = sin(args->params.kat * (3.14159f / 180)); // wartosc ortogonalnej b wektora przesuniecia dla kata charakterystycznego
+
+	log->nast_.I1_2hr = args->params.Io2h1 * args->params.Io2h1;
+	log->nast_.I1_2hr_powr = (0.95 * args->params.Io2h1) * (0.95 * args->params.Io2h1);
+
+
+	log->nast_.t1 = ((args->params.t1 - 0.005f) * 100); //czas dzialania
+	if (log->nast_.t1) log->nast_.t0_1 = 0; else  log->nast_.t0_1 = 1;
+	log->nast_.t2 = ((args->params.t2 - 0.005f) * 100); //czas dzialania
+	if (log->nast_.t2) log->nast_.t0_2 = 0; else  log->nast_.t0_2 = 1;
+
+	log->nast_.l_nad_time=(u32)(args->params.L_t_nad * 1000);
+	log->nast_.l_t_blok=(u32)(args->params.L_T_odwr * 1000);
+	log->nast_.t1_min=(u32)((args->params.t1_min - 0.005f) * 100);
+	log->nast_.t2_min=(u32)((args->params.t2_min - 0.005f) * 100);
+//	*((uint8_t *)REG_FUNCTION_ON_OFF + id - 0x2400) = log->nast_.on_;
+
+	return 0;
+}
+
+
+void r_67n_lwn(void *arguments, void *logic)
+{
+	struct r_67n_lwn_args *args = (struct r_67n_lwn_args *)arguments;
+	struct r_67n_lwn_logic *log = (struct r_67n_lwn_logic *)logic;
+	float local_orta_U_ ,local_ortb_U_, ILmax;
+	u8 wk,l_nrl;
+
+    if(log->nast_.on_)   // jesli zabezpieczenie aktywne
+    {
+		log->w.kwampl_U_ = *log->kwampl_U_;
+		log->w.kwampl_I_ = *log->kwampl_I_;
+		log->w.orta_I_ = *log->orta_I_;
+		log->w.orta_U_ = *log->orta_U_;
+		log->w.ortb_I_ = *log->ortb_I_;
+		log->w.ortb_U_ = *log->ortb_U_;
+		log->w.IL1 = *log->IL1;
+		log->w.IL2 = *log->IL2;
+		log->w.IL3 = *log->IL3;
+		log->w.Io2h = *log->Io2h;
+
+     // przesuniecie napiecia o wektor kata nastawy
+        local_orta_U_ = log->w.orta_U_ * log->nast_.orta - log->w.ortb_U_ * log->nast_.ortb;
+        local_ortb_U_ = log->w.orta_U_ * log->nast_.ortb + log->w.ortb_U_ * log->nast_.orta;
+
+     // okreslenie kierunku
+        log->dw.kierunek = (log->w.orta_I_ * local_orta_U_ + log->w.ortb_I_ * local_ortb_U_) > 0;
+        if(!czy_test_R()) // w tescie nie uzywaj kierunku
+        	check_and_set_struct(log->dw.kierunek,&log->kier);
+
+        switch(log->nast_.dir) //okeslenie kierunku stopnia 1
+		{
+			case 0:
+				wk = log->dw.kierunek;
+				break;
+			case 1:
+				wk = !log->dw.kierunek;
+				break;
+			case 2:
+				wk = 1;
+				break;
+		}
+
+		//sprawdzenie warunku napiciowego
+		log->dw.P_U |= log->w.kwampl_U_ > log->nast_.Ur;
+		log->dw.P_U &= log->w.kwampl_U_ > log->nast_.Up;
+
+		if(log->dw.Bl_2h1)
+			log->dw.Bl_2h1 = log->w.Io2h > log->nast_.I1_2hr_powr * log->w.kwampl_I_;
+		else
+			log->dw.Bl_2h1 = log->w.Io2h > log->nast_.I1_2hr * log->w.kwampl_I_;
+
+		if(log->dw.Bl_2h2)
+			log->dw.Bl_2h2 = log->w.Io2h > log->nast_.I1_2hr_powr * log->w.kwampl_I_;
+		else
+			log->dw.Bl_2h2 = log->w.Io2h > log->nast_.I1_2hr * log->w.kwampl_I_;
+
+        log->dw.Bl_2h1 &= log->nast_.Bl_2h1_ON;
+        log->dw.Bl_2h2 &= log->nast_.Bl_2h2_ON;
+
+		//Sprawdzenie przekaznikw pradowych
+		//szukanie maksymalnego pradu
+		ILmax = log->w.IL1;
+		if (ILmax < log->w.IL2) ILmax = log->w.IL2;
+		if (ILmax < log->w.IL3) ILmax = log->w.IL3;
+
+		//sprawdzenie pobudzenia stopnia 1
+		sprawdz_P(&log->dw.P1,
+				  wk && log->dw.P_U && !log->dw.Bl_2h1 && log->w.kwampl_I_ > log->nast_.Ir1 && log->w.kwampl_I_ > (log->nast_.kh1 * ILmax),
+				  !wk || !log->dw.P_U || log->dw.Bl_2h1 || log->w.kwampl_I_ < log->nast_.Ip1 || log->w.kwampl_I_ < (log->nast_.khp1 * ILmax),
+				  &log->dw.lp1,
+				  11,3
+				  );
+
+        //sprawdzenie pobudzenia stopnia 2
+        sprawdz_P(&log->dw.P2,
+        		  wk && log->dw.P_U && !log->dw.Bl_2h2 && log->w.kwampl_I_ > log->nast_.Ir2 && log->w.kwampl_I_ > log->nast_.kh2 * ILmax,
+                  !wk || !log->dw.P_U || log->dw.Bl_2h2 || log->w.kwampl_I_ < log->nast_.Ip2 || log->w.kwampl_I_ < log->nast_.khp2 * ILmax,
+                  &log->dw.lp2,
+                  11,3
+                  );
+
+		//obsluga wejscia testu przekaznika
+		if (czy_test_R())
+		{
+			log->dw.P1 = log->dw.P2 = check_struct(&log->test)?1:0;
+		}
+        //
+
+        // realizacja blokady dzialania przekaznika
+		if(log->nast_.bl_ && check_struct(&log->stan_bl_) /*| czy_start()*/)
+				log->dw.P1 = log->dw.P2 = 0;
+        //
+
+		log->dw.Z1 |= (log->dw.P1 && log->nast_.t0_1);  // jesli dziaanie bezzwoczne stopnia 1
+		log->dw.Z2 |= log->dw.P2 && log->nast_.t0_2; // jesli dziaanie bezzwoczne stopnia 2
+		log->dw.Z = log->dw.Z1 || log->dw.Z2;
+
+		if (log->dw.Z && !log->dw.Z_last) //zapisanie momentu zadziaania
+		{
+			log->dw.Z_last = 1;
+//			log->dw.czas_ = time;
+		}
+
+		check_and_set_struct(log->dw.P1,&log->P1);
+		check_and_set_struct(log->dw.P2,&log->P2);
+		check_and_set_struct(log->dw.Z1,&log->Z1);
+		check_and_set_struct(log->dw.Z2,&log->Z2);
+
+		check_and_set_struct(((log->dw.Z1 && log->nast_.w1) || (log->dw.Z2 && log->nast_.w2) || (log->l_echo && (args->params.bity & R67N_L_ECHO_WYL))) && !log->l_blok_wyl && !log->dw.Podwr,&log->W);
+
+		if(args->params.bity & R67N_L_AKT)
+		{
+			//nadawanie
+			l_nrl=0;
+
+			if(log->dw.P1 && args->params.bity & R67N_L_NADP1)
+			{
+				l_nrl=1;
+				log->l_nad_cnt=0;
+			}
+
+			if(log->dw.P2 && args->params.bity & R67N_L_NADP2)
+			{
+				l_nrl=1;
+				log->l_nad_cnt=0;
+			}
+			//odbior
+			if(!(args->params.bity & R67N_L_BLOK)) // gdy tryb zezwalajacy
+			{
+				if(check_struct(&log->l_odb) && check_struct(&log->l_ok) && !log->dw.Podwr)
+				{
+					if(log->dw.P1)
+						log->skr_t1=1;
+					else
+						log->skr_t1=0;
+
+					if(log->dw.P2)
+						log->skr_t2=1;
+					else
+						log->skr_t2=0;
+				}
+				else
+				{
+					log->skr_t1=0;
+					log->skr_t2=0;
+				}
+			}
+			else // tryb blokujacy
+			{
+				if(check_struct(&log->l_odb) && check_struct(&log->l_ok) && !log->dw.Podwr)
+					log->l_blok_wyl=1;
+				else
+					log->l_blok_wyl=0;
+			}
+			//
+
+			// echo
+			if(args->params.bity & R67N_L_ECHO)
+			{
+		        sprawdz_P(&log->dw.PI0,
+		        		  (log->w.kwampl_I_ > log->nast_.Ir1 && log->w.kwampl_I_ > log->nast_.kh1 * ILmax)||(log->w.kwampl_I_ > log->nast_.Ir2 && log->w.kwampl_I_ > log->nast_.kh2 * ILmax),
+		                  (log->w.kwampl_I_ < log->nast_.Ip1 || log->w.kwampl_I_ < log->nast_.khp1 * ILmax)&&(log->w.kwampl_I_ < log->nast_.Ip2 || log->w.kwampl_I_ < log->nast_.khp2 * ILmax),
+		                  &log->dw.lp3,
+		                  5,200
+		                  );
+
+		        if(check_struct(&log->l_odb) && check_struct(&log->l_ok) && !log->dw.PI0 && log->w.kwampl_U_ > log->nast_.U_echo && !log->dw.Podwr)
+		        {
+		        	l_nrl=1;
+					log->l_nad_cnt=0;
+		        	log->l_echo=1;
+		        }
+		        else
+		        	log->l_echo=0;
+			}
+
+
+			// LRC
+			if(args->params.bity & R67N_L_ODWR_PR)
+			{
+				sprawdz_P(&log->dw.Podwr,
+						  !wk && log->dw.P_U && ((!log->dw.Bl_2h1 && log->w.kwampl_I_ > log->nast_.Ir1 && log->w.kwampl_I_ > (log->nast_.kh1 * ILmax))||(!log->dw.Bl_2h2 && log->w.kwampl_I_ > log->nast_.Ir2 && log->w.kwampl_I_ > (log->nast_.kh2 * ILmax))),
+						  wk || !log->dw.P_U || ((log->dw.Bl_2h1 || log->w.kwampl_I_ < log->nast_.Ip1 || log->w.kwampl_I_ < (log->nast_.khp1 * ILmax))&&(log->dw.Bl_2h2 || log->w.kwampl_I_ < log->nast_.Ip2 || log->w.kwampl_I_ < (log->nast_.khp2 * ILmax))),
+						  &log->dw.lp4,
+						  40,log->nast_.l_t_blok
+						  );
+
+				if(log->dw.Podwr)
+				{
+					l_nrl=0;
+					clear_struct(&log->NRL);
+					log->l_nad_cnt=0;
+				}
+			}
+
+			// wyslanie impulsu nadawania
+			if(l_nrl && !log->l_nad_cnt)
+				set_struct(&log->NRL);
+
+			if(log->l_nad_cnt>=log->nast_.l_nad_time)
+			{
+				clear_struct(&log->NRL);
+				if(!l_nrl)
+					log->l_nad_cnt=0;
+			}
+			else if(check_struct(&log->NRL))
+				log->l_nad_cnt++;
+
+
+		}
+	}
+    else
+	{
+		clear_struct(&log->Z1);
+		clear_struct(&log->Z2);
+		clear_struct(&log->W);
+		clear_struct(&log->P1);
+		clear_struct(&log->P2);
+
+		clear_struct(&log->NRL);
+	}
+}
+
+void r_67n_lwn_100hz(void *arguments, void *logic)
+{
+	struct r_67n_lwn_logic *log = (struct r_67n_lwn_logic *)logic;
+	int t;
+
+    if(log->nast_.on_)   // jesli zabezpieczenie aktywne
+    {
+		// realizacja przekaznika czasowego
+		if (log->dw.P1) log->dw.lt1++; else log->dw.lt1 = 0;
+		if (log->dw.P2) log->dw.lt2++; else log->dw.lt2 = 0;
+
+		if(log->skr_t1 && log->nast_.t1_min<log->nast_.t1)
+			t=log->nast_.t1_min;
+		else
+			t=log->nast_.t1;
+
+		if (log->dw.lt1 > t)
+		{
+			log->dw.Z1 = 1;
+			log->dw.lt1--;
+		}
+
+		if(log->skr_t2 && log->nast_.t2_min<log->nast_.t2)
+			t=log->nast_.t2_min;
+		else
+			t=log->nast_.t2;
+
+		if (log->dw.lt2 > t)
+		{
+			log->dw.Z2 = 1;
+			log->dw.lt2--;
+		}
+
+		//
+		//kasowanie zadziaa po odpadniciu pobudze
+		log->dw.P = log->dw.P1 || log->dw.P2;
+
+		if(!log->dw.P1)
+			log->dw.Z1=0;
+		if(!log->dw.P2)
+			log->dw.Z2=0;
+		if(!log->dw.P)
+			log->dw.Z=0;
+
+		log->dw.Z_last = log->dw.Z;
+
+		// 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;
+						log->dw.max_orta_I = log->w.orta_I_;
+						log->dw.max_ortb_I = log->w.ortb_I_;
+						log->dw.max_orta_U = log->w.orta_U_;
+						log->dw.max_ortb_U = log->w.ortb_U_;
+						log->dw.max_I = log->w.kwampl_I_;
+						log->dw.max_U = log->w.kwampl_U_;
+						log->dw.I1 = log->w.IL1;
+						log->dw.I2 = log->w.IL2;
+						log->dw.I3 = log->w.IL3;
+					}
+					break;
+				case sledzenie:
+					if (log->dw.Z)
+					{
+						status_rej = sledzenie_zad;
+						//log->dw.czas_ = time; // zapisanie do bufora tymczasowego czasu wyslania impulsu wylacz dla rejestracji
+					}
+					if (log->dw.P)
+					{
+						if(log->w.kwampl_I_>log->dw.max_I)
+						{
+							log->dw.max_orta_I = log->w.orta_I_;
+							log->dw.max_ortb_I = log->w.ortb_I_;
+							log->dw.max_orta_U = log->w.orta_U_;
+							log->dw.max_ortb_U = log->w.ortb_U_;
+							log->dw.max_I = log->w.kwampl_I_;
+							log->dw.max_U = log->w.kwampl_U_;
+							log->dw.I1 = log->w.IL1;
+							log->dw.I2 = log->w.IL2;
+							log->dw.I3 = log->w.IL3;
+							log->dw.Io2h = log->w.Io2h;
+						}
+
+						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 {
+
+						if(log->w.kwampl_I_>log->dw.max_I)
+						{
+							log->dw.max_orta_I = log->w.orta_I_;
+							log->dw.max_ortb_I = log->w.ortb_I_;
+							log->dw.max_orta_U = log->w.orta_U_;
+							log->dw.max_ortb_U = log->w.ortb_U_;
+							log->dw.max_I = log->w.kwampl_I_;
+							log->dw.max_U = log->w.kwampl_U_;
+							log->dw.I1 = log->w.IL1;
+							log->dw.I2 = log->w.IL2;
+							log->dw.I3 = log->w.IL3;
+							log->dw.Io2h = log->w.Io2h;
+						}
+
+
+						log->dw.dl_++;
+					}
+					break;
+				case zapis:
+					if (!log->dw.wsk_rej)
+					{
+						status_rej = oczekiwanie;
+					}
+					break;
+			}
+
+	}
+}
+
+void r_67n_lwn_20hz(void *arguments, void *logic)
+{
+	struct r_67n_lwn_logic *log = (struct r_67n_lwn_logic *)logic;
+
+	// czesc ktora miala byc wykonywana max co 1s w wolnym czasie
+	if(log->dw.wsk_rej) // przypisanie parametrow zaklocenia jesli bylo zadzialanie i zabezpieczenie sie odwzbudzilo
+    {
+		log->dw.R.max_I_ = sqrt(log->dw.max_I); // wyliczenie maksymalnej wartosci pradu
+		log->dw.R.max_U_ = sqrt(log->dw.max_U); // wyliczenie wartosci napiecia
+		log->dw.R.I1 = sqrt(log->dw.I1);
+		log->dw.R.I2 = sqrt(log->dw.I2);
+		log->dw.R.I3 = sqrt(log->dw.I3);
+		log->dw.R.Io2h = sqrt(log->dw.Io2h);
+        log->dw.R.max_kat_ = (180 / 3.14159f) * (atan2(log->dw.max_ortb_I,log->dw.max_orta_I) - atan2(log->dw.max_ortb_U,log->dw.max_orta_U));// wyliczenie kata
+ //       log->dw.R.moment_wystapienia = log->dw.czas_; // wpisanie czasu chwili zadzialania zabezpieczenia
+ //       log->dw.R.dlugosc = (float)log->dw.dl_ * 0.01f; // / 100; // wpisanie czasu trwania zwarcia
+  //      log->dw.R.czy_nowa = true; // sygnalizacja powstania nowej rejestracji
+        log->dw.wsk_rej = 0; // zerowanie wskaznika powstania nowego zaklocenia
+    }
+
+}

src/R_67N_LWN.h

@@ -0,0 +1,220 @@
+/*
+ * R_67N_LWN.h
+ *
+ *  Created on: 19-07-2016
+ *      Author: Krzysztof Jakubczyk
+ */
+
+#ifndef R_67N_LWN_H_
+#define R_67N_LWN_H_
+
+#include "tdefs.h"
+#include "helper.h"
+
+#define R67N_L_AKT	 	0x0040
+#define R67N_L_NADP1 	0x0080
+#define R67N_L_NADP2 	0x0100
+#define R67N_L_ECHO  	0x0200
+#define R67N_L_ECHO_WYL 0x0400
+#define R67N_L_BLOK		0x0800
+#define R67N_L_ODWR_PR	0x1000
+
+struct Wyjscia_rejestratora_lwn
+{
+            float max_I_;///< maksymalna watosc pradu w czasie zaklocenia w krotnosciach warotosci znamionowej
+            float max_U_;///< watosc napiecia w czasie zaklocenia w krotnosciach warotosci znamionowej
+            float max_kat_; ///< watosc kata w czasie zaklocenia w stopniach
+			float I1; ///< prad fazy L1
+			float I2; ///< prad fazy L2
+			float I3; ///< prad fazy L3
+			float Io2h; ///< prąd drugiej harmonicznej
+};
+
+
+struct Nastawy_przeliczone_lwn
+{
+	float Ir1; ///< wartosc rozruchowa pradu stopień 1
+    float Ip1; ///< wartosc powrotu pradu rozruchowego stopień 1
+    float Ir2; ///< wartosc rozruchowa pradu stopień 2
+    float Ip2; ///< wartosc powrotu pradu rozruchowego stopień 2
+	float kh1; ///< wspólczynnik stabilizacji zadziałania stopień 1
+	float kh2; ///< wspólczynnik stabilizacji zadziałania stopień 2
+	float khp1; ///< wspolczynnik stabilizacji dla powrotu stopień 1
+	float khp2; ///< wspolczynnik stabilizacji dla powrotu stopień 2
+	float I1_2hr; ///< wartość rozruchowa blokady drugiej harmonicznej stopień 1
+	float I1_2hr_powr; ///< wartość rozruchowa blokady drugiej harmonicznej stopień 1
+    float U_echo; ///< wartosc rozruchowa echa
+    float Ur; ///< wartosc rozruchowa napiecia blokady
+    float Up; ///< wartosc powrotu napiecia blokady
+    float orta; ///< ortogonalna a dla wektora nasatwy kata charakterystycznego
+    float ortb; ///< ortogonalna b dla wektora nasatwy kata charakterystycznego
+    short dir; ///< nastawa kierunku 2 - do przodu; 1 - w obu kierunkach; 0 - do tylu
+    int t1; ///< opoznienie czasu zadzialania przekaznika
+    int t2; ///< opoznienie czasu zadzialania przekaznika
+    u8 on_; ///< wartosc nastawy aktywnosci przekaznika 1- aktywny
+    u8 w1; ///< wartosc nastawy dzialania na wylaczeniee 1 - wylaczenie 0 - tylko sygnalizacja
+    u8 w2; ///< wartosc nastawy dzialania na wylaczeniee 1 - wylaczenie 0 - tylko sygnalizacja
+    u8 bl_; ///< wartosc nastawy aktywnosci blokady dzialania 1- blokada aktywna
+	u8 t0_1; ///< przekaźnik bezzwłoczny stopień 1
+	u8 t0_2; ///< przekaźnik bezzwłoczny stopień 2
+	u8 Bl_2h1_ON; ///< Włączenie blokady od drugiej harmonicznej w stopniu 1
+	u8 Bl_2h2_ON; ///< Włączenie blokady od drugiej harmonicznej w stopniu 2
+	u32 l_nad_time;
+	u32 t1_min;
+	u32 t2_min;
+	u32 l_t_blok;
+};
+
+struct Wejscie_lwn
+{
+    float orta_I_; ///< ortogonalna a pradu wejsciowego Io
+    float ortb_I_; ///< ortogonalna b pradu wejsciowego Io
+    float kwampl_I_; ///< kwadrat amplitudy prądu
+    float orta_U_; ///< ortogonalna b napiecia wejsciowego Uo
+    float ortb_U_; ///< ortogonalna b napiecia wejsciowego Uo
+    float kwampl_U_; ///< kwadrat amplitudy napiecia
+	float IL1; ///< kwadrat amplitudy prądu faza L1
+	float IL2; ///< kwadrat amplitudy prądu faza L2
+	float IL3; ///< kwadrat amplitudy prądu faza L3
+	float Io2h;///< kwadrat amplitudy drugiej harmonicznej składowej zerowej prądu
+};
+
+struct dane_wewnetrzne_lwn
+{
+	struct Wyjscia_rejestratora_lwn R; ///< dane ostatniego zaklocenia
+	long long czas_; // moment wystapienia zaklocenia (rejestr tymczasowy - przed zapisem)
+	u32 dl_; // dlugosc czasu trwania zaklocenia (rejestr tymczasowy - przed zapisem)
+	u8 wsk_rej; // nowy zapis rejestracji parametrow zaklocenia (spelnienie kryterium identyfikacji)
+
+	float max_I;///< maksymalna watosc pradu w czasie zaklocenia w krotnosciach warotosci znamionowej
+    float max_U;///< watosc napiecia w czasie zaklocenia w krotnosciach warotosci znamionowej
+    float max_kat; ///< watosc kata w czasie zaklocenia w stopniach
+	float I1; ///< prad fazy L1
+	float I2; ///< prad fazy L2
+	float I3; ///< prad fazy L3
+	float Io2h;///< prad drugiej harmonicznej
+
+	float max_orta_I;
+	float max_ortb_I;
+	float max_orta_U;
+	float max_ortb_U;
+
+	short lp1;///< licznikpobudzen stopień 1
+	short lp2;///< licznikpobudzen stopień 2
+	short lp3;///< licznikpobudzen I0 do echa
+	short lp4;///< licznikpobudzen w LRC
+	int lt1;
+	int lt2;
+	u8 Podwr;
+	u8 PI0; // pobudzenie i0 do echa
+	u8 P; // pobudzenie i0 do echa
+	u8 P1;
+	u8 P2;
+	u8 Z;
+	u8 Z1;
+	u8 Z2;
+	u8 P_U;
+	u8 Bl_2h1;
+	u8 Bl_2h2;
+	u8 kierunek;
+	u8 Z_last;
+};
+
+struct r_67n_lwn_logic
+{
+	struct binary_io stan_bl_;
+
+	float *orta_I_;
+	float *ortb_I_;
+	float *kwampl_I_;
+
+	float *orta_U_;
+	float *ortb_U_;
+	float *kwampl_U_;
+
+	float *IL1;
+	float *IL2;
+	float *IL3;
+	float *Io2h;
+
+	struct binary_io test;
+	struct binary_io l_odb;
+	struct binary_io l_ok;
+	struct binary_io W;
+	struct binary_io Z1;
+	struct binary_io Z2;
+	struct binary_io P1;
+	struct binary_io P2;
+	struct binary_io kier;
+	struct binary_io NRL;
+
+	struct Nastawy_przeliczone_lwn nast_;
+	struct dane_wewnetrzne_lwn dw;
+	struct Wejscie_lwn w;
+
+	u8 l_echo;
+	u8 skr_t1;
+	u8 skr_t2;
+	u8 l_blok_wyl;
+	u32 l_nad_cnt;
+};
+
+struct r_67n_lwn_io
+{
+	u32 stan_bl_in;
+	u32 orta_I_float_in;
+	u32 ortb_I_float_in;
+	u32 kwampl_I_float_in;
+	u32 orta_U_float_in;
+	u32 ortb_U_float_in;
+	u32 kwampl_U_float_in;
+	u32 IL1_float_in;
+	u32 IL2_float_in;
+	u32 IL3_float_in;
+	u32 Io2h_float_in;
+	u32 test_in;
+	u32 l_odb_in;
+	u32 l_ok_in;
+	u32 w_out;
+	u32 z1_out;
+	u32 z2_out;
+	u32 p1_out;
+	u32 p2_out;
+	u32 kier_out;
+	u32 NRL_out;
+}__attribute__((__packed__));
+
+struct r_67n_lwn_params
+{
+	u32 bity; ///< nastawy bitowe;
+    u32 dir; ///< nastawa kierunku dzialania przekaznika
+    double U; ///< napiecie rozruchowe przekaznika w krotnosciach wartosci znamionowej
+    double kat; ///< wartosc nastawy kata charakterystycznego w stopniach
+    double I1; ///< prad rozruchowy przekaznika stopien 1
+    double I2; ///< prad rozruchowy przekaznika stopien 2
+	double kh1; ///< współczynnik stabilizacji stopień 1
+	double kh2; ///< współczynnik stabilizacji stopień 2
+    double t1; ///< wartosc nastawy czasu dzialania w sekundach stopiń 1
+    double t2; ///< wartosc nastawy czasu dzialania w sekundach stopiń 2
+    double t1_min; // czas t1 przy skróceniu
+    double t2_min; // czas t1 przy skróceniu
+	double Io2h1; ///<Prąd blokady drugiej harmonicznej
+    double kp; ///< wartosc nastawy wspolczynnika
+    double L_t_nad;
+    double L_U_echo;
+    double L_T_odwr;
+}__attribute__((__packed__));
+
+struct r_67n_lwn_args
+{
+	struct r_67n_lwn_io io;
+	struct r_67n_lwn_params params;
+//	u16 crc;
+}__attribute__((__packed__));
+
+extern void r_67n_lwn(void *args, void *logic);
+extern void r_67n_lwn_100hz(void *args, void *logic);
+extern void r_67n_lwn_20hz(void *args, void *logic);
+extern int r_67n_lwn_initlog(void *arguments, void *logic);
+
+#endif /* R_67N_LWN_H_ */

src/R_67N_LWN2.c

@@ -0,0 +1,691 @@
+/*
+ * R_67N_LWN2.c
+ *
+ *  Created on: 14-11-2018
+ *      Author: Krzysztof Jakubczyk
+ */
+
+#include "tdefs.h"
+#include "misc.h"
+
+#include "r_67n_lwn2.h"
+#include "analog_in.h"
+#include "helper.h"
+#include "ZDistL.h"
+
+#include <math.h>
+
+int r_67n_lwn2_initlog(void *arguments, void *logic)
+{
+	struct r_67n_lwn2_args *args = (struct r_67n_lwn2_args *)arguments;
+	struct r_67n_lwn2_logic *log = (struct r_67n_lwn2_logic *)logic;
+
+	if(set_bit_ptr_struct(args->io.stan_bl_in,&log->stan_bl_))
+		return -1;
+
+	if(set_float_ptr(args->io.orta_I_float_in,&log->orta_I_))
+		return -1;
+
+	if(set_float_ptr(args->io.ortb_I_float_in,&log->ortb_I_))
+		return -1;
+
+	if(set_float_ptr(args->io.kwampl_I_float_in,&log->kwampl_I_))
+		return -1;
+
+	if(set_float_ptr(args->io.orta_U_float_in,&log->orta_U_))
+		return -1;
+
+	if(set_float_ptr(args->io.ortb_U_float_in,&log->ortb_U_))
+		return -1;
+
+	if(set_float_ptr(args->io.kwampl_U_float_in,&log->kwampl_U_))
+		return -1;
+
+	if(set_float_ptr(args->io.IL1_float_in,&log->IL1))
+		return -1;
+
+	if(set_float_ptr(args->io.IL2_float_in,&log->IL2))
+		return -1;
+
+	if(set_float_ptr(args->io.IL3_float_in,&log->IL3))
+		return -1;
+
+	if(set_float_ptr(args->io.Io2h_float_in,&log->Io2h))
+		return -1;
+
+	if(set_bit_ptr_struct(args->io.test_in,&log->test))
+		return -1;
+
+	if(set_bit_ptr_struct(args->io.l_odb_in,&log->l_odb))
+		return -1;
+
+	if(set_bit_ptr_struct(args->io.l_ok_in,&log->l_ok))
+		return -1;
+
+	if(set_bit_ptr_struct(args->io.bl_st1_in,&log->bl_st1))
+		return -1;
+
+	if(set_bit_ptr_struct(args->io.bl_st2_in,&log->bl_st2))
+		return -1;
+
+	if(set_bit_ptr_struct(args->io.w_out,&log->W))
+		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.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.kier_out,&log->kier))
+		return -1;
+
+	if(set_bit_ptr_struct(args->io.NRL_out,&log->NRL))
+		return -1;
+
+	if(set_bit_ptr_struct(args->io.bl_st1_out,&log->bl_st1_wy))
+		return -1;
+
+	if(set_bit_ptr_struct(args->io.bl_st2_out,&log->bl_st2_wy))
+		return -1;
+
+	if(set_bit_ptr_struct(args->io.bl_2h_st1_out,&log->bl_2h_st1_wy))
+		return -1;
+
+	if(set_bit_ptr_struct(args->io.bl_2h_st2_out,&log->bl_2h_st2_wy))
+		return -1;
+
+	if(set_bit_ptr_struct(args->io.l_blok_out,&log->l_blok))
+		return -1;
+	if(set_bit_ptr_struct(args->io.l_zezw_out,&log->l_zezw))
+		return -1;
+	if(set_bit_ptr_struct(args->io.l_echo_out,&log->l_echo_wy))
+		return -1;
+	if(set_bit_ptr_struct(args->io.l_rc_out,&log->l_rc))
+		return -1;
+
+	////
+	//status_rej = oczekiwanie;
+
+	log->nast_.on_ = args->params.bity & 0x0001;
+	log->nast_.w1 = args->params.bity & 0x0002;
+	log->nast_.w2 = args->params.bity & 0x0004;
+	log->nast_.Bl_2h1_ON = (args->params.bity & 0x0008)?1:0;
+	log->nast_.Bl_2h2_ON = (args->params.bity & 0x0010)?1:0;
+	log->nast_.bl_ = args->params.bity & 0x0020;
+
+
+	log->nast_.dir = args->params.dir;
+	log->nast_.dir2 = args->params.dir2;
+
+    log->nast_.Ir1 = args->params.I1 *  args->params.I1; // wyliczenie wartosci rozruchowej pradu
+    log->nast_.Ir2 = args->params.I2 *  args->params.I2; // wyliczenie wartosci rozruchowej pradu
+
+	log->nast_.Ip1 = log->nast_.Ir1 * args->params.kp * args->params.kp; // wyliczenie wartoci powrotu algorytmu
+    log->nast_.Ip2 = log->nast_.Ir2 * args->params.kp * args->params.kp; // wyliczenie wartoci powrotu algorytmu
+
+	log->nast_.kh1 = args->params.kh1 * args->params.kh1;
+	log->nast_.khp1 = log->nast_.kh1 * args->params.kp * args->params.kp;
+	log->nast_.kh2 = args->params.kh2 * args->params.kh2;
+	log->nast_.khp2 = log->nast_.kh2 * args->params.kp * args->params.kp;
+
+    log->nast_.U_echo = args->params.L_U_echo *  args->params.L_U_echo; // wyliczenie wartosci rozruchowej blokady napieciowej
+    log->nast_.Ur = args->params.U *  args->params.U; // wyliczenie wartosci rozruchowej blokady napieciowej
+    log->nast_.Up = log->nast_.Ur * args->params.kp * args->params.kp; // wyliczenie wartosci powrotu blokady napieciowej
+    log->nast_.orta = cos(args->params.kat * (3.14159f / 180)); // wartosc ortogonalnej a wektora przesuniecia dla kata charakterystycznego
+    log->nast_.ortb = sin(args->params.kat * (3.14159f / 180)); // wartosc ortogonalnej b wektora przesuniecia dla kata charakterystycznego
+
+	log->nast_.I1_2hr = args->params.Io2h1 * args->params.Io2h1;
+	log->nast_.I1_2hr_powr = (0.95 * args->params.Io2h1) * (0.95 * args->params.Io2h1);
+
+	log->nast_.I2h_min1 = log->nast_.I1_2hr * log->nast_.Ir1;
+	log->nast_.I2h_min2 = log->nast_.I1_2hr * log->nast_.Ir2;
+
+	log->nast_.t1 = ((args->params.t1 - 0.005f) * 100); //czas dzialania
+	if (log->nast_.t1) log->nast_.t0_1 = 0; else  log->nast_.t0_1 = 1;
+	log->nast_.t2 = ((args->params.t2 - 0.005f) * 100); //czas dzialania
+	if (log->nast_.t2) log->nast_.t0_2 = 0; else  log->nast_.t0_2 = 1;
+
+	log->nast_.l_nad_time=(u32)(args->params.L_t_nad * 1000);
+	log->nast_.l_nad_time_max=(u32)(args->params.L_t_nad_max * 1000);
+	log->nast_.l_t_blok=(u32)(args->params.L_T_odwr * 1000);
+	log->nast_.t1_min=(u32)((args->params.t1_min - 0.005f) * 100);
+	log->nast_.t2_min=(u32)((args->params.t2_min - 0.005f) * 100);
+//	*((uint8_t *)REG_FUNCTION_ON_OFF + id - 0x2400) = log->nast_.on_;
+
+	return 0;
+}
+
+
+void r_67n_lwn2(void *arguments, void *logic)
+{
+	struct r_67n_lwn2_args *args = (struct r_67n_lwn2_args *)arguments;
+	struct r_67n_lwn2_logic *log = (struct r_67n_lwn2_logic *)logic;
+	float local_orta_U_ ,local_ortb_U_, ILmax;
+	u8 wk,wk2,l_nrl;
+
+    if(log->nast_.on_)   // jesli zabezpieczenie aktywne
+    {
+		log->w.kwampl_U_ = *log->kwampl_U_;
+		log->w.kwampl_I_ = *log->kwampl_I_;
+		log->w.orta_I_ = *log->orta_I_;
+		log->w.orta_U_ = *log->orta_U_;
+		log->w.ortb_I_ = *log->ortb_I_;
+		log->w.ortb_U_ = *log->ortb_U_;
+		log->w.IL1 = *log->IL1;
+		log->w.IL2 = *log->IL2;
+		log->w.IL3 = *log->IL3;
+		log->w.Io2h = *log->Io2h;
+
+     // przesuniecie napiecia o wektor kata nastawy
+        local_orta_U_ = log->w.orta_U_ * log->nast_.orta - log->w.ortb_U_ * log->nast_.ortb;
+        local_ortb_U_ = log->w.orta_U_ * log->nast_.ortb + log->w.ortb_U_ * log->nast_.orta;
+
+     // okreslenie kierunku
+        log->dw.kierunek = ((log->w.orta_I_ * local_orta_U_ + log->w.ortb_I_ * local_ortb_U_) > 0) ? 1 : 0;
+        if(!czy_test_R()) // w tescie nie uzywaj kierunku
+        	check_and_set_struct(log->dw.kierunek,&log->kier);
+
+        switch(log->nast_.dir) //okeslenie kierunku stopnia 1
+		{
+			case 0:
+				wk = log->dw.kierunek;
+				break;
+			case 1:
+				wk = !log->dw.kierunek;
+				break;
+			case 2:
+				wk = 1;
+			default:
+				break;
+		}
+
+        switch(log->nast_.dir2) //okeslenie kierunku stopnia 2
+		{
+			case 0:
+				wk2 = log->dw.kierunek;
+				break;
+			case 1:
+				wk2 = !log->dw.kierunek;
+				break;
+			case 2:
+				wk2 = 1;
+				break;
+			default:
+				break;
+		}
+
+        check_and_set_struct(check_struct(&log->bl_st1)||log->nast_.dir==3,&log->bl_st1_wy);
+        check_and_set_struct(check_struct(&log->bl_st2)||log->nast_.dir2==3,&log->bl_st2_wy);
+
+		//sprawdzenie warunku napiciowego
+		log->dw.P_U |= log->w.kwampl_U_ > log->nast_.Ur;
+		log->dw.P_U &= log->w.kwampl_U_ > log->nast_.Up;
+
+		u8 war1 = log->w.Io2h > log->nast_.I2h_min1;
+		u8 war2 = log->w.Io2h > log->nast_.I2h_min2;
+
+		sprawdz_P(&log->dw.P2h1,
+				(log->w.Io2h > log->nast_.I1_2hr * log->w.kwampl_I_) && war1,
+				(log->w.Io2h < log->nast_.I1_2hr_powr * log->w.kwampl_I_) || !war1,
+				&log->dw.lp2h1,2,10);
+
+		sprawdz_P(&log->dw.P2h2,
+				(log->w.Io2h > log->nast_.I1_2hr * log->w.kwampl_I_ && war2),
+				(log->w.Io2h < log->nast_.I1_2hr_powr * log->w.kwampl_I_) || !war2,
+				&log->dw.lp2h2,2,10);
+/*
+		if(log->dw.Bl_2h1)
+			log->dw.Bl_2h1 = log->w.Io2h > log->nast_.I1_2hr_powr * log->w.kwampl_I_;
+		else
+			log->dw.Bl_2h1 = log->w.Io2h > log->nast_.I1_2hr * log->w.kwampl_I_;
+
+
+		if(log->dw.Bl_2h2)
+			log->dw.Bl_2h2 = log->w.Io2h > log->nast_.I1_2hr_powr * log->w.kwampl_I_;
+		else
+			log->dw.Bl_2h2 = log->w.Io2h > log->nast_.I1_2hr * log->w.kwampl_I_;
+
+
+        log->dw.Bl_2h1 &= log->nast_.Bl_2h1_ON;
+        log->dw.Bl_2h2 &= log->nast_.Bl_2h2_ON;
+*/
+        log->dw.Bl_2h1 = log->dw.P2h1 && log->nast_.Bl_2h1_ON;
+        log->dw.Bl_2h2 = log->dw.P2h2 && log->nast_.Bl_2h2_ON;
+
+
+		//Sprawdzenie przekaznikw pradowych
+		//szukanie maksymalnego pradu
+		ILmax = log->w.IL1;
+		if (ILmax < log->w.IL2) ILmax = log->w.IL2;
+		if (ILmax < log->w.IL3) ILmax = log->w.IL3;
+
+		//sprawdzenie pobudzenia stopnia 1
+		sprawdz_P(&log->dw.P1_pre,
+				  !check_struct(&log->bl_st1) && wk && log->dw.P_U && /*!log->dw.Bl_2h1 &&*/ log->w.kwampl_I_ > log->nast_.Ir1 && log->w.kwampl_I_ > (log->nast_.kh1 * ILmax),
+				  check_struct(&log->bl_st1) || !wk || !log->dw.P_U ||/* log->dw.Bl_2h1 ||*/ log->w.kwampl_I_ < log->nast_.Ip1 || log->w.kwampl_I_ < (log->nast_.khp1 * ILmax),
+				  &log->dw.lp1_pre,
+				  20,3
+				  );
+
+        //sprawdzenie pobudzenia stopnia 2
+        sprawdz_P(&log->dw.P2_pre,
+        		!check_struct(&log->bl_st2) && wk2 && log->dw.P_U && /*!log->dw.Bl_2h2 &&*/ log->w.kwampl_I_ > log->nast_.Ir2 && log->w.kwampl_I_ > log->nast_.kh2 * ILmax,
+        		check_struct(&log->bl_st2) || !wk2 || !log->dw.P_U ||/* log->dw.Bl_2h2 ||*/ log->w.kwampl_I_ < log->nast_.Ip2 || log->w.kwampl_I_ < log->nast_.khp2 * ILmax,
+                  &log->dw.lp2_pre,
+                  20,3
+                  );
+
+		sprawdz_P(&log->dw.P1,
+				  log->dw.P1_pre && !log->dw.Bl_2h1,
+				  !log->dw.P1_pre || log->dw.Bl_2h1,
+				  &log->dw.lp1,
+				  1,1
+				  );
+
+		sprawdz_P(&log->dw.P2,
+				  log->dw.P2_pre && !log->dw.Bl_2h2,
+				  !log->dw.P2_pre || log->dw.Bl_2h2,
+				  &log->dw.lp2,
+				  1,1
+				  );
+
+        check_and_set_struct(log->dw.P1_pre && log->dw.Bl_2h1, &log->bl_2h_st1_wy);
+        check_and_set_struct(log->dw.P2_pre && log->dw.Bl_2h2, &log->bl_2h_st2_wy);
+
+        ////
+        // blokady 2h po pobudzeniach
+        ////
+		//obsluga wejscia testu przekaznika
+		if (czy_test_R())
+		{
+			log->dw.P1 = log->dw.P2 = check_struct(&log->test)?1:0;
+		}
+        //
+
+        // realizacja blokady dzialania przekaznika
+		if(log->nast_.bl_ && check_struct(&log->stan_bl_) /*| czy_start()*/)
+				log->dw.P1 = log->dw.P2 = 0;
+        //
+
+		sprawdz_P(&log->dw.Ptyl1,
+				  !wk && log->dw.P_U && ((!log->dw.Bl_2h1 && log->w.kwampl_I_ > log->nast_.Ir1 && log->w.kwampl_I_ > (log->nast_.kh1 * ILmax))),
+				  wk || !log->dw.P_U || ((log->dw.Bl_2h1 || log->w.kwampl_I_ < log->nast_.Ip1 || log->w.kwampl_I_ < (log->nast_.khp1 * ILmax))),
+				  &log->dw.lp5,
+				  20,3
+				  );
+		sprawdz_P(&log->dw.Ptyl2,
+				  !wk2 && log->dw.P_U && ((!log->dw.Bl_2h2 && log->w.kwampl_I_ > log->nast_.Ir2 && log->w.kwampl_I_ > (log->nast_.kh2 * ILmax))),
+				  wk2 || !log->dw.P_U || ((log->dw.Bl_2h2 || log->w.kwampl_I_ < log->nast_.Ip2 || log->w.kwampl_I_ < (log->nast_.khp2 * ILmax))),
+				  &log->dw.lp6,
+				  20,3
+				  );
+
+		if(log->nast_.dir == 3 || check_struct(&log->bl_st1))
+		{
+			log->dw.P1=0;
+			log->dw.Ptyl1=0;
+			log->dw.P1_pre=0;
+		}
+
+		if(log->nast_.dir2 == 3 || check_struct(&log->bl_st2))
+		{
+			log->dw.P2=0;
+			log->dw.Ptyl2=0;
+			log->dw.P2_pre=0;
+		}
+
+		log->dw.Z1 |= (log->dw.P1 && log->nast_.t0_1);  // jesli dziaanie bezzwoczne stopnia 1
+		log->dw.Z2 |= log->dw.P2 && log->nast_.t0_2; // jesli dziaanie bezzwoczne stopnia 2
+		log->dw.Z = log->dw.Z1 || log->dw.Z2;
+
+		if (log->dw.Z && !log->dw.Z_last) //zapisanie momentu zadziaania
+		{
+			log->dw.Z_last = 1;
+//			log->dw.czas_ = time;
+		}
+
+		check_and_set_struct(log->dw.P1,&log->P1);
+		check_and_set_struct(log->dw.P2,&log->P2);
+		check_and_set_struct(log->dw.Z1,&log->Z1);
+		check_and_set_struct(log->dw.Z2,&log->Z2);
+
+		check_and_set_struct(((log->dw.Z1 && log->nast_.w1) || (log->dw.Z2 && log->nast_.w2) || (log->l_echo && (args->params.bity & R67N_L_ECHO_WYL))) && !log->l_blok_wyl && !log->dw.Podwr,&log->W);
+
+		if(args->params.bity & R67N_L_AKT)
+		{
+			//nadawanie
+			l_nrl=0;
+
+			//odbior
+			if(!(args->params.bity & R67N_L_BLOK)) // gdy tryb zezwalajacy
+			{
+				if(log->dw.P1 && args->params.bity & R67N_L_NADP1)
+				{
+					l_nrl=1;
+					//log->l_nad_cnt=0;
+				}
+
+				if(log->dw.P2 && args->params.bity & R67N_L_NADP2)
+				{
+					l_nrl=1;
+					//log->l_nad_cnt=0;
+				}
+
+				if(check_struct(&log->l_odb) && check_struct(&log->l_ok) && !log->dw.Podwr)
+				{
+					if(log->dw.P1)
+						log->skr_t1=1;
+					else
+						log->skr_t1=0;
+
+					if(log->dw.P2)
+						log->skr_t2=1;
+					else
+						log->skr_t2=0;
+
+					set_struct(&log->l_zezw);
+				}
+				else
+				{
+					clear_struct(&log->l_zezw);
+					if(!log->dw.P1 && !log->dw.P2)
+					{
+						log->skr_t1=0;
+						log->skr_t2=0;
+					}
+				}
+			}
+			else // tryb blokujacy
+			{
+				if(log->dw.P1 && !log->dw.P1_prev)
+					log->skr_t1=1;
+
+				if(log->dw.P2 && !log->dw.P2_prev)
+					log->skr_t2=1;
+
+				log->dw.P1_prev=log->dw.P1;
+				log->dw.P2_prev=log->dw.P2;
+
+				if(log->dw.Ptyl1 && args->params.bity & R67N_L_NADP1)
+				{
+					l_nrl=1;
+					//log->l_nad_cnt=0;
+				}
+
+				if(log->dw.Ptyl2 && args->params.bity & R67N_L_NADP2)
+				{
+					l_nrl=1;
+					//log->l_nad_cnt=0;
+				}
+
+				if(check_struct(&log->l_odb) && check_struct(&log->l_ok) && !log->dw.Podwr)
+				{
+					set_struct(&log->l_blok);
+					//log->l_blok_wyl=1;
+
+					//dodane ponizej
+					log->skr_t1=0;
+					log->skr_t2=0;
+				}
+				else
+				{
+					if(!check_struct(&log->l_ok))
+					{
+						log->skr_t1=0;
+						log->skr_t2=0;
+					}
+					clear_struct(&log->l_blok);
+					//log->l_blok_wyl=0;
+				}
+			}
+			//
+
+			// echo
+			if(args->params.bity & R67N_L_ECHO)
+			{
+				if(!check_struct(&log->stan_bl_))
+				{
+					sprawdz_P(&log->dw.PI0,
+							  (log->w.kwampl_I_ > log->nast_.Ir1 && log->w.kwampl_I_ > log->nast_.kh1 * ILmax)||(log->w.kwampl_I_ > log->nast_.Ir2 && log->w.kwampl_I_ > log->nast_.kh2 * ILmax),
+							  (log->w.kwampl_I_ < log->nast_.Ip1 || log->w.kwampl_I_ < log->nast_.khp1 * ILmax)&&(log->w.kwampl_I_ < log->nast_.Ip2 || log->w.kwampl_I_ < log->nast_.khp2 * ILmax),
+							  &log->dw.lp3,
+							  5,200
+							  );
+
+					sprawdz_P(&log->dw.PU0,
+                    (log->w.kwampl_U_ > log->nast_.U_echo),
+                    (log->w.kwampl_U_ < (0.99 * log->nast_.U_echo)),
+                     &log->dw.lp7,
+                     25,3
+                     );
+                    
+          
+          if(check_struct(&log->l_odb) && check_struct(&log->l_ok) && !log->dw.PI0 && log->dw.PU0 && !log->dw.Podwr)
+					{
+						l_nrl=1;
+						//log->l_nad_cnt=0;
+						log->l_echo=1;
+						set_struct(&log->l_echo_wy);
+					}
+					else
+					{
+						clear_struct(&log->l_echo_wy);
+						log->l_echo=0;
+					}
+				}
+				else
+				{
+					log->l_echo=0;
+					clear_struct(&log->l_echo_wy);
+				}
+			}
+
+			// LRC
+			if(args->params.bity & R67N_L_ODWR_PR)
+			{
+				sprawdz_P(&log->dw.Podwr,
+						  !wk && log->dw.P_U && ((!log->dw.Bl_2h1 && log->w.kwampl_I_ > log->nast_.Ir1 && log->w.kwampl_I_ > (log->nast_.kh1 * ILmax))||(!log->dw.Bl_2h2 && log->w.kwampl_I_ > log->nast_.Ir2 && log->w.kwampl_I_ > (log->nast_.kh2 * ILmax))),
+						  wk || !log->dw.P_U || ((log->dw.Bl_2h1 || log->w.kwampl_I_ < log->nast_.Ip1 || log->w.kwampl_I_ < (log->nast_.khp1 * ILmax))&&(log->dw.Bl_2h2 || log->w.kwampl_I_ < log->nast_.Ip2 || log->w.kwampl_I_ < (log->nast_.khp2 * ILmax))),
+						  &log->dw.lp4,
+						  40,log->nast_.l_t_blok
+						  );
+
+				if(log->dw.Podwr)
+				{
+					set_struct(&log->l_rc);
+					l_nrl=0;
+					clear_struct(&log->NRL);
+					//log->l_nad_cnt=0;
+				}
+				else
+					clear_struct(&log->l_rc);
+			}
+
+			// wyslanie impulsu nadawania
+			if(l_nrl && !log->l_nad_cnt)
+				set_struct(&log->NRL);
+
+			if((log->l_nad_cnt>=log->nast_.l_nad_time && !l_nrl)|| log->l_nad_cnt>=log->nast_.l_nad_time_max)
+			{
+				clear_struct(&log->NRL);
+
+				if(!l_nrl)
+					log->l_nad_cnt=0;
+			}
+			else if(check_struct(&log->NRL))
+				log->l_nad_cnt+=LOOP_CYCLE_MS;
+			//
+
+
+		}
+	}
+    else
+	{
+		clear_struct(&log->Z1);
+		clear_struct(&log->Z2);
+		clear_struct(&log->W);
+		clear_struct(&log->P1);
+		clear_struct(&log->P2);
+
+		clear_struct(&log->NRL);
+		clear_struct(&log->bl_2h_st1_wy);
+		clear_struct(&log->bl_2h_st2_wy);
+	}
+}
+
+void r_67n_lwn2_100hz(void *arguments, void *logic)
+{
+	struct r_67n_lwn2_logic *log = (struct r_67n_lwn2_logic *)logic;
+	int t;
+
+    if(log->nast_.on_)   // jesli zabezpieczenie aktywne
+    {
+		// realizacja przekaznika czasowego
+		if (log->dw.P1) log->dw.lt1++; else log->dw.lt1 = 0;
+		if (log->dw.P2) log->dw.lt2++; else log->dw.lt2 = 0;
+
+		if(log->skr_t1 && log->nast_.t1_min<log->nast_.t1)
+			t=log->nast_.t1_min;
+		else
+			t=log->nast_.t1;
+
+		if (log->dw.lt1 > t)
+		{
+			log->dw.Z1 = 1;
+			log->dw.lt1--;
+		}
+
+		if(log->skr_t2 && log->nast_.t2_min<log->nast_.t2)
+			t=log->nast_.t2_min;
+		else
+			t=log->nast_.t2;
+
+		if (log->dw.lt2 > t)
+		{
+			log->dw.Z2 = 1;
+			log->dw.lt2--;
+		}
+
+		//
+		//kasowanie zadziaa po odpadniciu pobudze
+		log->dw.P = log->dw.P1 || log->dw.P2;
+
+		if(!log->dw.P1)
+			log->dw.Z1=0;
+		if(!log->dw.P2)
+			log->dw.Z2=0;
+		if(!log->dw.P)
+			log->dw.Z=0;
+
+		log->dw.Z_last = log->dw.Z;
+
+		// 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;
+						log->dw.max_orta_I = log->w.orta_I_;
+						log->dw.max_ortb_I = log->w.ortb_I_;
+						log->dw.max_orta_U = log->w.orta_U_;
+						log->dw.max_ortb_U = log->w.ortb_U_;
+						log->dw.max_I = log->w.kwampl_I_;
+						log->dw.max_U = log->w.kwampl_U_;
+						log->dw.I1 = log->w.IL1;
+						log->dw.I2 = log->w.IL2;
+						log->dw.I3 = log->w.IL3;
+					}
+					break;
+				case sledzenie:
+					if (log->dw.Z)
+					{
+						status_rej = sledzenie_zad;
+						//log->dw.czas_ = time; // zapisanie do bufora tymczasowego czasu wyslania impulsu wylacz dla rejestracji
+					}
+					if (log->dw.P)
+					{
+						if(log->w.kwampl_I_>log->dw.max_I)
+						{
+							log->dw.max_orta_I = log->w.orta_I_;
+							log->dw.max_ortb_I = log->w.ortb_I_;
+							log->dw.max_orta_U = log->w.orta_U_;
+							log->dw.max_ortb_U = log->w.ortb_U_;
+							log->dw.max_I = log->w.kwampl_I_;
+							log->dw.max_U = log->w.kwampl_U_;
+							log->dw.I1 = log->w.IL1;
+							log->dw.I2 = log->w.IL2;
+							log->dw.I3 = log->w.IL3;
+							log->dw.Io2h = log->w.Io2h;
+						}
+
+						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 {
+
+						if(log->w.kwampl_I_>log->dw.max_I)
+						{
+							log->dw.max_orta_I = log->w.orta_I_;
+							log->dw.max_ortb_I = log->w.ortb_I_;
+							log->dw.max_orta_U = log->w.orta_U_;
+							log->dw.max_ortb_U = log->w.ortb_U_;
+							log->dw.max_I = log->w.kwampl_I_;
+							log->dw.max_U = log->w.kwampl_U_;
+							log->dw.I1 = log->w.IL1;
+							log->dw.I2 = log->w.IL2;
+							log->dw.I3 = log->w.IL3;
+							log->dw.Io2h = log->w.Io2h;
+						}
+
+
+						log->dw.dl_++;
+					}
+					break;
+				case zapis:
+					if (!log->dw.wsk_rej)
+					{
+						status_rej = oczekiwanie;
+					}
+					break;
+			}
+
+	}
+}
+
+void r_67n_lwn2_20hz(void *arguments, void *logic)
+{
+	struct r_67n_lwn2_logic *log = (struct r_67n_lwn2_logic *)logic;
+
+	// czesc ktora miala byc wykonywana max co 1s w wolnym czasie
+	if(log->dw.wsk_rej) // przypisanie parametrow zaklocenia jesli bylo zadzialanie i zabezpieczenie sie odwzbudzilo
+    {
+		log->dw.R.max_I_ = sqrt(log->dw.max_I); // wyliczenie maksymalnej wartosci pradu
+		log->dw.R.max_U_ = sqrt(log->dw.max_U); // wyliczenie wartosci napiecia
+		log->dw.R.I1 = sqrt(log->dw.I1);
+		log->dw.R.I2 = sqrt(log->dw.I2);
+		log->dw.R.I3 = sqrt(log->dw.I3);
+		log->dw.R.Io2h = sqrt(log->dw.Io2h);
+        log->dw.R.max_kat_ = (180 / 3.14159f) * (atan2(log->dw.max_ortb_I,log->dw.max_orta_I) - atan2(log->dw.max_ortb_U,log->dw.max_orta_U));// wyliczenie kata
+ //       log->dw.R.moment_wystapienia = log->dw.czas_; // wpisanie czasu chwili zadzialania zabezpieczenia
+ //       log->dw.R.dlugosc = (float)log->dw.dl_ * 0.01f; // / 100; // wpisanie czasu trwania zwarcia
+  //      log->dw.R.czy_nowa = true; // sygnalizacja powstania nowej rejestracji
+        log->dw.wsk_rej = 0; // zerowanie wskaznika powstania nowego zaklocenia
+    }
+
+}

src/R_67N_LWN2.h

@@ -0,0 +1,262 @@
+/*
+ * R_67N_LWN2.h
+ *
+ *  Created on: 14-11-2018
+ *      Author: Krzysztof Jakubczyk
+ */
+
+#ifndef R_67N_LWN2_H_
+#define R_67N_LWN2_H_
+
+#include "tdefs.h"
+#include "helper.h"
+
+#define R67N_L_AKT	 	0x0040
+#define R67N_L_NADP1 	0x0080
+#define R67N_L_NADP2 	0x0100
+#define R67N_L_ECHO  	0x0200
+#define R67N_L_ECHO_WYL 0x0400
+#define R67N_L_BLOK		0x0800
+#define R67N_L_ODWR_PR	0x1000
+
+struct Wyjscia_rejestratora_lwn2
+{
+            float max_I_;///< maksymalna watosc pradu w czasie zaklocenia w krotnosciach warotosci znamionowej
+            float max_U_;///< watosc napiecia w czasie zaklocenia w krotnosciach warotosci znamionowej
+            float max_kat_; ///< watosc kata w czasie zaklocenia w stopniach
+			float I1; ///< prad fazy L1
+			float I2; ///< prad fazy L2
+			float I3; ///< prad fazy L3
+			float Io2h; ///< prąd drugiej harmonicznej
+};
+
+
+struct Nastawy_przeliczone_lwn2
+{
+	float Ir1; ///< wartosc rozruchowa pradu stopień 1
+    float Ip1; ///< wartosc powrotu pradu rozruchowego stopień 1
+    float Ir2; ///< wartosc rozruchowa pradu stopień 2
+    float Ip2; ///< wartosc powrotu pradu rozruchowego stopień 2
+	float kh1; ///< wspólczynnik stabilizacji zadziałania stopień 1
+	float kh2; ///< wspólczynnik stabilizacji zadziałania stopień 2
+	float khp1; ///< wspolczynnik stabilizacji dla powrotu stopień 1
+	float khp2; ///< wspolczynnik stabilizacji dla powrotu stopień 2
+	float I1_2hr; ///< wartość rozruchowa blokady drugiej harmonicznej stopień 1
+	float I1_2hr_powr; ///< wartość rozruchowa blokady drugiej harmonicznej stopień 1
+    float U_echo; ///< wartosc rozruchowa echa
+    float Ur; ///< wartosc rozruchowa napiecia blokady
+    float Up; ///< wartosc powrotu napiecia blokady
+    float orta; ///< ortogonalna a dla wektora nasatwy kata charakterystycznego
+    float ortb; ///< ortogonalna b dla wektora nasatwy kata charakterystycznego
+    short dir; ///< nastawa kierunku 2 - do przodu; 1 - w obu kierunkach; 0 - do tylu
+    int t1; ///< opoznienie czasu zadzialania przekaznika
+    int t2; ///< opoznienie czasu zadzialania przekaznika
+    u8 on_; ///< wartosc nastawy aktywnosci przekaznika 1- aktywny
+    u8 w1; ///< wartosc nastawy dzialania na wylaczeniee 1 - wylaczenie 0 - tylko sygnalizacja
+    u8 w2; ///< wartosc nastawy dzialania na wylaczeniee 1 - wylaczenie 0 - tylko sygnalizacja
+    u8 bl_; ///< wartosc nastawy aktywnosci blokady dzialania 1- blokada aktywna
+	u8 t0_1; ///< przekaźnik bezzwłoczny stopień 1
+	u8 t0_2; ///< przekaźnik bezzwłoczny stopień 2
+	u8 Bl_2h1_ON; ///< Włączenie blokady od drugiej harmonicznej w stopniu 1
+	u8 Bl_2h2_ON; ///< Włączenie blokady od drugiej harmonicznej w stopniu 2
+	u32 l_nad_time;
+	u32 l_nad_time_max;
+	u32 t1_min;
+	u32 t2_min;
+	u32 l_t_blok;
+    short dir2; ///< nastawa kierunku stop. 2, 2 - do przodu; 1 - w obu kierunkach; 0 - do tylu
+    float I2h_min1;
+    float I2h_min2;
+};
+
+struct Wejscie_lwn2
+{
+    float orta_I_; ///< ortogonalna a pradu wejsciowego Io
+    float ortb_I_; ///< ortogonalna b pradu wejsciowego Io
+    float kwampl_I_; ///< kwadrat amplitudy prądu
+    float orta_U_; ///< ortogonalna b napiecia wejsciowego Uo
+    float ortb_U_; ///< ortogonalna b napiecia wejsciowego Uo
+    float kwampl_U_; ///< kwadrat amplitudy napiecia
+	float IL1; ///< kwadrat amplitudy prądu faza L1
+	float IL2; ///< kwadrat amplitudy prądu faza L2
+	float IL3; ///< kwadrat amplitudy prądu faza L3
+	float Io2h;///< kwadrat amplitudy drugiej harmonicznej składowej zerowej prądu
+};
+
+struct dane_wewnetrzne_lwn2
+{
+	struct Wyjscia_rejestratora_lwn2 R; ///< dane ostatniego zaklocenia
+	long long czas_; // moment wystapienia zaklocenia (rejestr tymczasowy - przed zapisem)
+	u32 dl_; // dlugosc czasu trwania zaklocenia (rejestr tymczasowy - przed zapisem)
+	u8 wsk_rej; // nowy zapis rejestracji parametrow zaklocenia (spelnienie kryterium identyfikacji)
+
+	float max_I;///< maksymalna watosc pradu w czasie zaklocenia w krotnosciach warotosci znamionowej
+    float max_U;///< watosc napiecia w czasie zaklocenia w krotnosciach warotosci znamionowej
+    float max_kat; ///< watosc kata w czasie zaklocenia w stopniach
+	float I1; ///< prad fazy L1
+	float I2; ///< prad fazy L2
+	float I3; ///< prad fazy L3
+	float Io2h;///< prad drugiej harmonicznej
+
+	float max_orta_I;
+	float max_ortb_I;
+	float max_orta_U;
+	float max_ortb_U;
+
+	short lp1;///< licznikpobudzen stopień 1
+	short lp2;///< licznikpobudzen stopień 2
+	short lp1_pre;///< licznikpobudzen stopień 1
+	short lp2_pre;///< licznikpobudzen stopień 2
+	short lp3;///< licznikpobudzen I0 do echa
+	short lp4;///< licznikpobudzen w LRC
+	short lp5;///
+	short lp6;///
+	short lp7;
+	int lt1;
+	int lt2;
+	u8 Podwr;
+	u8 Ptyl1;
+	u8 P1_prev;
+	u8 Ptyl2;
+	u8 P2_prev;
+	u8 PI0; // pobudzenie i0 do echa
+	u8 P; // pobudzenie i0 do echa
+	u8 P1;
+	u8 P2;
+	u8 P1_pre;
+	u8 P2_pre;
+	u8 Z;
+	u8 Z1;
+	u8 Z2;
+	u8 P_U;
+	u8 Bl_2h1;
+	u8 Bl_2h2;
+	u8 kierunek;
+	u8 Z_last;
+	u8 P2h1;
+	u8 P2h2;
+	u8 PU0; //pobudzenie dla echa
+	short lp2h1;
+	short lp2h2;
+};
+
+struct r_67n_lwn2_logic
+{
+	struct binary_io stan_bl_;
+
+	float *orta_I_;
+	float *ortb_I_;
+	float *kwampl_I_;
+
+	float *orta_U_;
+	float *ortb_U_;
+	float *kwampl_U_;
+
+	float *IL1;
+	float *IL2;
+	float *IL3;
+	float *Io2h;
+
+	struct binary_io test;
+	struct binary_io l_odb;
+	struct binary_io l_ok;
+	struct binary_io W;
+	struct binary_io Z1;
+	struct binary_io Z2;
+	struct binary_io P1;
+	struct binary_io P2;
+	struct binary_io kier;
+	struct binary_io NRL;
+	struct binary_io bl_st1;
+	struct binary_io bl_st2;
+	struct binary_io bl_st1_wy;
+	struct binary_io bl_st2_wy;
+	struct binary_io bl_2h_st1_wy;
+	struct binary_io bl_2h_st2_wy;
+	struct binary_io l_blok;
+	struct binary_io l_zezw;
+	struct binary_io l_echo_wy;
+	struct binary_io l_rc;
+
+	struct Nastawy_przeliczone_lwn2 nast_;
+	struct dane_wewnetrzne_lwn2 dw;
+	struct Wejscie_lwn2 w;
+
+	u8 l_echo;
+	u8 skr_t1;
+	u8 skr_t2;
+	u8 l_blok_wyl;
+	u32 l_nad_cnt;
+};
+
+struct r_67n_lwn2_io
+{
+	u32 stan_bl_in;
+	u32 orta_I_float_in;
+	u32 ortb_I_float_in;
+	u32 kwampl_I_float_in;
+	u32 orta_U_float_in;
+	u32 ortb_U_float_in;
+	u32 kwampl_U_float_in;
+	u32 IL1_float_in;
+	u32 IL2_float_in;
+	u32 IL3_float_in;
+	u32 Io2h_float_in;
+	u32 test_in;
+	u32 l_odb_in;
+	u32 l_ok_in;
+	u32 bl_st1_in;
+	u32 bl_st2_in;
+	u32 w_out;
+	u32 z1_out;
+	u32 z2_out;
+	u32 p1_out;
+	u32 p2_out;
+	u32 kier_out;
+	u32 NRL_out;
+	u32 bl_st1_out;
+	u32 bl_st2_out;
+	u32 bl_2h_st1_out;
+	u32 bl_2h_st2_out;
+	u32 l_blok_out;
+	u32 l_zezw_out;
+	u32 l_echo_out;
+	u32 l_rc_out;
+}__attribute__((__packed__));
+
+struct r_67n_lwn2_params
+{
+	u32 bity; ///< nastawy bitowe;
+    u32 dir; ///< nastawa kierunku dzialania przekaznika
+    double U; ///< napiecie rozruchowe przekaznika w krotnosciach wartosci znamionowej
+    double kat; ///< wartosc nastawy kata charakterystycznego w stopniach
+    double I1; ///< prad rozruchowy przekaznika stopien 1
+    double I2; ///< prad rozruchowy przekaznika stopien 2
+	double kh1; ///< współczynnik stabilizacji stopień 1
+	double kh2; ///< współczynnik stabilizacji stopień 2
+    double t1; ///< wartosc nastawy czasu dzialania w sekundach stopiń 1
+    double t2; ///< wartosc nastawy czasu dzialania w sekundach stopiń 2
+    double t1_min; // czas t1 przy skróceniu
+    double t2_min; // czas t1 przy skróceniu
+	double Io2h1; ///<Prąd blokady drugiej harmonicznej
+    double kp; ///< wartosc nastawy wspolczynnika
+    double L_t_nad;
+    double L_U_echo;
+    double L_T_odwr;
+    u32 dir2; ///< nastawa kierunku dzialania przekaznika stop. 2
+    double L_t_nad_max;
+}__attribute__((__packed__));
+
+struct r_67n_lwn2_args
+{
+	struct r_67n_lwn2_io io;
+	struct r_67n_lwn2_params params;
+//	u16 crc;
+}__attribute__((__packed__));
+
+extern void r_67n_lwn2(void *args, void *logic);
+extern void r_67n_lwn2_100hz(void *args, void *logic);
+extern void r_67n_lwn2_20hz(void *args, void *logic);
+extern int r_67n_lwn2_initlog(void *arguments, void *logic);
+
+#endif /* R_67N_LWN2_H_ */

src/ZDistA.h

@@ -0,0 +1,444 @@
+/*
+ * ZDistA.h
+ *
+ *
+ *  Created on: 09-03-2017
+ *      Author: KJ
+ */
+
+#ifndef ZDISTA_H_
+#define ZDISTA_H_
+
+/*
+#include <stdint.h>
+#define u8 uint8_t
+#define u16 uint16_t
+#define u32 uint32_t
+
+struct  binary_io
+{
+	int yyyy;
+};
+*/
+
+#include "tdefs.h"
+#include "helper.h"
+
+	struct impedancja_ZDistA
+	{
+		float R[9];	// czesc rzeczywista impedancji
+		float X[9]; // czesc urojona impedancji
+		float Z[9]; //kwadrat impedancji
+		float absR[9]; // wartosc bezwzgledna impedancji czesc rzeczywista
+		float absX[9]; // wartosc bezwzgledna impedancji czesc urojona
+		float XRtanfi2[9]; // abs(X+R*tan(fi2))
+	//	float XRtanfi1[9]; // abs(X-R*tan(fi1))
+						//[0] petla L1-E strefa 1
+						//[1] petla L2-E strefa 1
+						//[2] petla L3-E strefa 1
+						//[3] petla L1-E strefa 2,3,4,5
+						//[4] petla L2-E strefa 2,3,4,5
+						//[5] petla L3-E strefa 2,3,4,5
+						//[6] petla L1-L2
+						//[7] petla L2-L3
+						//[8] petla L3-L1
+		float XRtanfi1_noabs[9];
+	};
+
+	struct dane_wewnetrzne_ZDistA
+	{
+		struct impedancja_ZDistA Z;
+		u8 Km;
+		u8 Kp;
+		u8 Igr[6]; // przekroczenie wartosci granicznej pradu
+		u8 Iogr; // zwarcie z udzialem ziemi
+		u8 P_s[6][6];//pobudzenie kryterium impedacyjnego (obszar) [numer strefy][L1E,L2E,L3E,L1L2,L2L3,L3L1]
+		u8 P_sss[6][6];
+		u8 Pbk[6][6];//pobudzenie w strefie [numer strefy][L1E,L2E,L3E,L1L2,L2L3,L3L1] bezkierunkowe
+		u8 P[6][6];//pobudzenie w strefie [numer strefy][L1E,L2E,L3E,L1L2,L2L3,L3L1]
+		u8 BL_Load[9]; ///< impedancja w obszrze pradow roboczych
+		u8 XKp[6][9]; ///< impedancyjne kryterium kierunku "do przodu"
+		u8 XKm[6][9]; ///< impedancyjne kryterium kierunku "do tylu"
+		u8 Zm[9];///< impedancyjne kryterium bardzo bliskiego zwarcia
+		short liczp10[9]; /// licznik pobudzen
+		short liczp11[6][9]; /// licznik pobudzen
+		short liczp12[6][9]; /// licznik pobudzen
+						//[0] petla L1-E strefa 1
+						//[1] petla L2-E strefa 1
+						//[2] petla L3-E strefa 1
+						//[3] petla L1-E strefa 2,3,4,5
+						//[4] petla L2-E strefa 2,3,4,5
+						//[5] petla L3-E strefa 2,3,4,5
+						//[6] petla L1-L2
+						//[7] petla L2-L3
+						//[8] petla L3-L1
+		short liczps[6][6]; //liczniki pobudzen dla pobudzen stref [numer strefy][L1E,L2E,L3E,L1L2,L2L3,L3L1]
+		short liczpIo; //licznik pobudzen dla identyfikacji zwarc z udzialem ziemi
+		short liczKdod;
+		float U1;
+		float U2;
+		float U3;
+		float I1;
+		float I2;
+		float I3;
+		struct ZDistA_logic *log_ptr;
+	};
+
+	struct nast_w_poligon
+	{
+		float Xr; // zasieg dla poligonu i srodek okregu dla kolowej wspolrzedna X
+		float Rr; // zasieg dla dla poligonu i srodek okregu dla kolowej wspolrzedna R
+		float Z; // srednica kola charakterystyki kolowej
+		float Xp; // zasieg dla poligonu i srodek okregu dla kolowej wspolrzedna X dla powrotu
+		float Rp; // zasieg dla dla poligonu i srodek okregu dla kolowej wspolrzedna R dla powrotu
+		float Zp; // srednica kola charakterystyki kolowej dla powrotu
+		float Rrtanfi1;// wartość rozruchowa prostej nachylonej kątem linii
+		float Rptanfi1;// wartość powrotowa prostej nachylonej kątem linii
+	};
+
+	struct Wyjscia_ZDistA // struktura wyjsc przekaznika
+	{
+		struct dane_wewnetrzne_ZDistA *Zdist_dw;
+		float przekladnia;
+		u8 *on;
+		u8 SOTF_zwrotnie;
+	};
+
+
+    struct Nastawy_przeliczone_ZDistA
+    {
+		struct Wyjscia_ZDistA wyjscie;
+		u8 on_;
+		u8 bl_;
+		u8 Bl_L[6];
+		u8 typ[6];// typ charakterystyki 0 - poligonalna, 1- kolowa
+		float ReK1; // skladowa rzeczywista wspolczynnika kompensacji ziemnozwarciowej dla strefy 1
+		float ImK1;// skladowa urojona wspolczynnika kompensacji ziemnozwarciowej dla strefy 1
+		float ReKr;// skladowa rzeczywista wspolczynnika kompensacji ziemnozwarciowej dla stref 2,3,4,5
+		float ImKr;// skladowa urojona wspolczynnika kompensacji ziemnozwarciowej dla stref 2,3,4,5
+
+		struct nast_w_poligon n_pol[6][2]; // nastawy stref dla charakterystyki poligonalnej [numer strefy][LE/LL]
+		float tanfi1; // tangens kata linii
+		float tanfi2; //tangens kata dodatkowej prostej dla charakterystyki poligonalnej strefa 1
+		float Xr1f; // wartosc rozruchowa dodatkowej prostej dla charakterystyki poligonalnej
+		float Xr1fp; // wartosc powrotowa dodatkowej prostej dla charakterystyki poligonalnej
+		float Xr1Wf; // wartosc rozruchowa dodatkowej prostej dla charakterystyki poligonalnej
+		float Xr1Wfp; // wartosc powrotowa dodatkowej prostej dla charakterystyki poligonalnej
+		float Igr; // wartosc kwadratu pradu granicznego warunku dzialania przekaznika
+		float Igrp; // wartosc kwadratu pradu granicznego warunku dzialania przekaznika (powrot)
+
+		float Zgr;// minimalna wartosc impedancji kryteriunkierunkowego w kwadracie
+		float kp;//współczynnik powrotu dla niedomiarówek
+		float kpp;//współczynnik powrotu dla nadmiarówek
+		float kpk; //kwadrat współczynnika powrotu
+		short kierunek[6];
+
+		//A2
+		float XKR; // wspolczynnik prostej R kierunku kryterium impedancyjnego
+		float XKX; // wspolczynnik prostej R kierunku kryterium impedancyjnego
+		float KL;//wspolczynnik prostej dla blokady od obszaru obciażenia
+		float RLf; // wartosc rozruchowa blokady Load do przodu
+		float RLr; // wartosc rozruchowa blokady Load do tylu
+		float Iogr; // wartosc graniczna skladowej zerowej identyfikacji zwarc z udzialem ziemi
+		float khio; // wspolczynnik stabilizacji dla przekaznika identyfikacji zwarc z udzialem ziemi
+		float Uomin; ///< minimalna wartość napięcia składowej zerowej
+
+    };
+
+struct ZDistA_logic
+{
+        struct binary_io stan_bl;
+		struct binary_io Bl_K;
+		float *I1_orta; ///< Skladowa ortogonalna a pradu faza L1
+		float *I1_ortb; ///< Skladowa ortogonalna b pradu faza L1
+		float *I1; ///< Prad mierzony faza 1
+		float *I2_orta; ///< Skladowa ortogonalna a pradu faza L2
+		float *I2_ortb; ///< Skladowa ortogonalna b pradu faza L2
+		float *I2; ///< Prad mierzony faza 2
+		float *I3_orta; ///< Skladowa ortogonalna a pradu faza L3
+		float *I3_ortb; ///< Skladowa ortogonalna b pradu faza L3
+		float *I3; ///< Prad mierzony faza 3
+		float *U1_orta; ///< Skladowa ortogonalna a napiecia faza L1
+		float *U1_ortb; ///< Skladowa ortogonalna b napiecia faza L1
+		float *U1; ///< Napiecie mierzone faza 1
+		float *U2_orta; ///< Skladowa ortogonalna a napiecia faza L2
+		float *U2_ortb; ///< Skladowa ortogonalna b napiecia faza L2
+		float *U2; ///< Napiecie mierzone faza 2
+		float *U3_orta; ///< Skladowa ortogonalna a napiecia faza L3
+		float *U3_ortb; ///< Skladowa ortogonalna b napiecia faza L3
+		float *U3; ///< Napiecie mierzone faza 3
+		float *U12_orta; ///< Skladowa ortogonalna a napiecia L1-L2
+		float *U12_ortb; ///< Skladowa ortogonalna b napiecia L1-L2
+		float *U12; ///< Napiecie mierzone L1-L2
+		float *U23_orta; ///< Skladowa ortogonalna a napiecia L2-L3
+		float *U23_ortb; ///< Skladowa ortogonalna b napiecia L2-L3
+		float *U23; ///< Napiecie mierzone L2-L3
+		float *U31_orta; ///< Skladowa ortogonalna a napiecia L3-L1
+		float *U31_ortb; ///< Skladowa ortogonalna b napiecia L3-L1
+		float *U31; ///< Napiecie mierzone L3-L1
+		float *sI1_orta; ///< Skladowa ortogonalna a skladowej zgodnej pradu
+		float *sI1_ortb; ///< Skladowa ortogonalna b skladowej zgodnej pradu
+		float *sI1; ///< Skladowa zgodna pradu
+		float *sI2_orta; ///< Skladowa ortogonalna a skladowej przeciwnej pradu
+		float *sI2_ortb; ///< Skladowa ortogonalna b skladowej przeciwnej pradu
+		float *sI2; ///< Skladowa przeciwna pradu
+		float *sI0_orta; ///< Skladowa ortogonalna a skladowej zerowej pradu
+		float *sI0_ortb; ///< Skladowa ortogonalna b skladowej zerowej pradu
+		float *sI0; ///< Skladowa zerowa pradu
+		float *sU1_orta; ///< Skladowa ortogonalna a skladowej zgodnej napiecia
+		float *sU1_ortb; ///< Skladowa ortogonalna b skladowej zgodnej napiecia
+		float *sU1; ///< Skladowa zgodna napiecia
+		float *sU2_orta; ///< Skladowa ortogonalna a skladowej przeciwnej napiecia
+		float *sU2_ortb; ///< Skladowa ortogonalna b skladowej przeciwnej napiecia
+		float *sU2; ///< Skladowa przeciwna napiecia
+		float *sU0_orta; ///< Skladowa ortogonalna a skladowej zerowej napiecia
+		float *sU0_ortb; ///< Skladowa ortogonalna b skladowej zerowej napiecia
+		float *sU0; ///< Skladowa zerowa napiecia
+		struct analog_in_params *param_I; ///< Parametry wejscia pradowego
+		struct analog_in_params *param_U; /// < Parametry kanalu napieciowego
+		struct binary_io test;
+		struct binary_io P1W_L1E; ///< Pobudzenie strefy 1W zwarcie L1-E
+		struct binary_io P1W_L2E; ///< Pobudzenie strefy 1W zwarcie L2-E
+		struct binary_io P1W_L3E; ///< Pobudzenie strefy 1W zwarcie L3-E
+		struct binary_io P1W_L1L2; ///< Pobudzenie strefy 1W zwarcie L1-L2
+		struct binary_io P1W_L2L3; ///< Pobudzenie strefy 1W zwarcie L2-L3
+		struct binary_io P1W_L3L1; ///< Pobudzenie strefy 1W zwarcie L3-L1
+		struct binary_io P1_L1E; ///< Pobudzenie strefy 1 zwarcie L1-E
+		struct binary_io P1_L2E; ///< Pobudzenie strefy 1 zwarcie L2-E
+		struct binary_io P1_L3E; ///< Pobudzenie strefy 1 zwarcie L3-E
+		struct binary_io P1_L1L2; ///< Pobudzenie strefy 1 zwarcie L1-L2
+		struct binary_io P1_L2L3; ///< Pobudzenie strefy 1 zwarcie L2-L3
+		struct binary_io P1_L3L1; ///< Pobudzenie strefy 1 zwarcie L3-L1
+		struct binary_io P2_L1E; ///< Pobudzenie strefy 2 zwarcie L1-E
+		struct binary_io P2_L2E; ///< Pobudzenie strefy 2 zwarcie L2-E
+		struct binary_io P2_L3E; ///< Pobudzenie strefy 2 zwarcie L3-E
+		struct binary_io P2_L1L2; ///< Pobudzenie strefy 2 zwarcie L1-L2
+		struct binary_io P2_L2L3; ///< Pobudzenie strefy 2 zwarcie L2-L3
+		struct binary_io P2_L3L1; ///< Pobudzenie strefy 2 zwarcie L3-L1
+		struct binary_io P3_L1E; ///< Pobudzenie strefy 3 zwarcie L1-E
+		struct binary_io P3_L2E; ///< Pobudzenie strefy 3 zwarcie L2-E
+		struct binary_io P3_L3E; ///< Pobudzenie strefy 3 zwarcie L3-E
+		struct binary_io P3_L1L2; ///< Pobudzenie strefy 3 zwarcie L1-L2
+		struct binary_io P3_L2L3; ///< Pobudzenie strefy 3 zwarcie L2-L3
+		struct binary_io P3_L3L1; ///< Pobudzenie strefy 3 zwarcie L3-L1
+		struct binary_io P4_L1E; ///< Pobudzenie strefy 4 zwarcie L1-E
+		struct binary_io P4_L2E; ///< Pobudzenie strefy 4 zwarcie L2-E
+		struct binary_io P4_L3E; ///< Pobudzenie strefy 4 zwarcie L3-E
+		struct binary_io P4_L1L2; ///< Pobudzenie strefy 4 zwarcie L1-L2
+		struct binary_io P4_L2L3; ///< Pobudzenie strefy 4 zwarcie L2-L3
+		struct binary_io P4_L3L1; ///< Pobudzenie strefy 4 zwarcie L3-L1
+		struct binary_io P5_L1E; ///< Pobudzenie strefy 5 zwarcie L1-E
+		struct binary_io P5_L2E; ///< Pobudzenie strefy 5 zwarcie L2-E
+		struct binary_io P5_L3E; ///< Pobudzenie strefy 5 zwarcie L3-E
+		struct binary_io P5_L1L2; ///< Pobudzenie strefy 5 zwarcie L1-L2
+		struct binary_io P5_L2L3; ///< Pobudzenie strefy 5 zwarcie L2-L3
+		struct binary_io P5_L3L1; ///< Pobudzenie strefy 5 zwarcie L3-L1
+		struct binary_io deakt; /// deaktywacja
+
+    	struct dane_wewnetrzne_ZDistA dw;
+    	struct Nastawy_przeliczone_ZDistA nast_;// struktura z parametrami
+
+		u8 l_nieustalony;
+
+    	float *z[6]; /// debug
+};
+
+struct ZDistA_io
+{
+	u32 bl_in;
+	u32 bl_k_in;
+	u32 i1_orta_float_in;
+	u32 i1_ortb_float_in;
+	u32 i1_float_in;
+	u32 i2_orta_float_in;
+	u32 i2_ortb_float_in;
+	u32 i2_float_in;
+	u32 i3_orta_float_in;
+	u32 i3_ortb_float_in;
+	u32 i3_float_in;
+	u32 u1_orta_float_in;
+	u32 u1_ortb_float_in;
+	u32 u1_float_in;
+	u32 u2_orta_float_in;
+	u32 u2_ortb_float_in;
+	u32 u2_float_in;
+	u32 u3_orta_float_in;
+	u32 u3_ortb_float_in;
+	u32 u3_float_in;
+	u32 u12_orta_float_in;
+	u32 u12_ortb_float_in;
+	u32 u12_float_in;
+	u32 u23_orta_float_in;
+	u32 u23_ortb_float_in;
+	u32 u23_float_in;
+	u32 u31_orta_float_in;
+	u32 u31_ortb_float_in;
+	u32 u31_float_in;
+	u32 i1_zg_orta_float_in;
+	u32 i1_zg_ortb_float_in;
+	u32 i1_zg_float_in;
+	u32 i2_pr_orta_float_in;
+	u32 i2_pr_ortb_float_in;
+	u32 i2_pr_float_in;
+	u32 io_orta_float_in;
+	u32 io_ortb_float_in;
+	u32 io_float_in;
+	u32 u1_zg_orta_float_in;
+	u32 u1_zg_ortb_float_in;
+	u32 u1_zg_float_in;
+	u32 u2_pr_orta_float_in;
+	u32 u2_pr_ortb_float_in;
+	u32 u2_pr_float_in;
+	u32 uo_orta_float_in;
+	u32 uo_ortb_float_in;
+	u32 uo_float_in;
+	u32 i_param_an_ptr_in;
+	u32 u_param_an_ptr_in;
+	u32 test_in;
+	u32 deakt_in;
+	u32 wy_ptr_out;	//zainicjowac
+	u32 P1W_L1E_out;
+	u32 P1W_L2E_out;
+	u32 P1W_L3E_out;
+	u32 P1W_L1L2_out;
+	u32 P1W_L2L3_out;
+	u32 P1W_L3L1_out;
+	u32 P1_L1E_out;
+	u32 P1_L2E_out;
+	u32 P1_L3E_out;
+	u32 P1_L1L2_out;
+	u32 P1_L2L3_out;
+	u32 P1_L3L1_out;
+	u32 P2_L1E_out;
+	u32 P2_L2E_out;
+	u32 P2_L3E_out;
+	u32 P2_L1L2_out;
+	u32 P2_L2L3_out;
+	u32 P2_L3L1_out;
+	u32 P3_L1E_out;
+	u32 P3_L2E_out;
+	u32 P3_L3E_out;
+	u32 P3_L1L2_out;
+	u32 P3_L2L3_out;
+	u32 P3_L3L1_out;
+	u32 P4_L1E_out;
+	u32 P4_L2E_out;
+	u32 P4_L3E_out;
+	u32 P4_L1L2_out;
+	u32 P4_L2L3_out;
+	u32 P4_L3L1_out;
+	u32 P5_L1E_out;
+	u32 P5_L2E_out;
+	u32 P5_L3E_out;
+	u32 P5_L1L2_out;
+	u32 P5_L2L3_out;
+	u32 P5_L3L1_out;
+
+	//debug
+	u32 z1_float_out;
+	u32 z2_float_out;
+	u32 z3_float_out;
+	u32 z4_float_out;
+	u32 z5_float_out;
+	u32 z6_float_out;
+
+}__attribute__((__packed__));
+
+struct ZDistA_params
+{
+	u32 bity; ///< nastawy bitowe;
+
+	long Typ1; ///< Typ charakterystyki strefa 1
+	long Typ2; ///< Typ charakterystyki strefa 2
+	long Typ3; ///< Typ charakterystyki strefa 3
+	long Typ4; ///< Typ charakterystyki strefa 4
+	long Typ5; ///< Typ charakterystyki strefa 5
+	long K1; ///< Kierunek dzialania strefa 1
+	long K2; ///< Kierunek dzialania strefa 2
+	long K3; ///< Kierunek dzialania strefa 3
+	long K4; ///< Kierunek dzialania strefa 4
+	long K5; ///< Kierunek dzialania strefa 5
+
+	double I_min; ///< Graniczna wartosc pradu
+	double Kk1;	///< Wspolczynnik kompensacji ziemnozwarciowej strefa 1
+	double Kk1_kat; ///< Kat wektora kompensacji ziemnozwarciowej strefa 1
+	double KkC; ///< Wspolczynnik kompensacji ziemnozwarciowej stref 2,3,4,5
+	double KkC_kat; ///< Kat wektora kompensacji ziemnozwarciowej stref 2,3,4,5
+	double fi1; ///< Kat linii
+	double fi2; ///< Kat nachylenia prostej korekcji strefy pierwszej dla zwarc jednofazowych z ziemia
+	double R1W_Zf1W_LE; ///< Zasieg rezystancyjny strefy 1 dla charakterystyki poligonalnej zwarcie jednofazowe z ziemia
+						///<	Zasieg „do przodu” wydluzenie strefy 1 charakterystyki kolowej zwarcie jednofazowe z ziemia
+	double R1W_Zf1W_LL; ///< Zasieg rezystancyjny strefy 1 dla charakterystyki poligonalnej zwarcie miedzyfazowe
+						///< Zasieg „do przodu” wyduzenie strefy 1 charakterystyki kolowej zwarcie miedzyfazowe
+	double R1_Zf1_LE; ///< Zasieg rezystancyjny strefy 1 dla charakterystyki poligonalnej zwarcie jednofazowe z ziemia
+						///<	Zasieg „do przodu” strefy 1 charakterystyki kolowej zwarcie jednofazowe z ziemia
+	double R1_Zf1_LL; ///< Zasieg rezystancyjny strefy 1 dla charakterystyki poligonalnej zwarcie miedzyfazowe
+						///< Zasieg „do przodu” strefy 1 charakterystyki kolowej zwarcie miedzyfazowe
+	double R2_Zf2_LE; ///< Zasieg rezystancyjny strefy 2 dla charakterystyki poligonalnej zwarcie jednofazowe z ziemia
+						///<	Zasieg „do przodu” strefy 2 charakterystyki kolowej zwarcie jednofazowe z ziemia
+	double R2_Zf2_LL; ///< Zasieg rezystancyjny strefy 2 dla charakterystyki poligonalnej zwarcie miedzyfazowe
+						///< Zasieg „do przodu” strefy 2 charakterystyki kolowej zwarcie miedzyfazowe
+	double R3_Zf3_LE; ///< Zasieg rezystancyjny strefy 3 dla charakterystyki poligonalnej zwarcie jednofazowe z ziemia
+						///<	Zasieg „do przodu” strefy 3 charakterystyki kolowej zwarcie jednofazowe z ziemia
+	double R3_Zf3_LL; ///< Zasieg rezystancyjny strefy 3 dla charakterystyki poligonalnej zwarcie miedzyfazowe
+						///< Zasieg „do przodu” strefy 3 charakterystyki kolowej zwarcie miedzyfazowe
+	double R4_Zf4_LE; ///< Zasieg rezystancyjny strefy 4 dla charakterystyki poligonalnej zwarcie jednofazowe z ziemia
+						///<	Zasieg „do przodu” strefy 4 charakterystyki kolowej zwarcie jednofazowe z ziemia
+	double R4_Zf4_LL; ///< Zasieg rezystancyjny strefy 4 dla charakterystyki poligonalnej zwarcie miedzyfazowe
+						///< Zasieg „do przodu” strefy 4 charakterystyki kolowej zwarcie miedzyfazowe
+	double R5_Zf5_LE; ///< Zasieg rezystancyjny strefy 5 dla charakterystyki poligonalnej zwarcie jednofazowe z ziemia
+						///<	Zasieg „do przodu” strefy 5 charakterystyki kolowej zwarcie jednofazowe z ziemia
+	double R5_Zf5_LL; ///< Zasieg rezystancyjny strefy 5 dla charakterystyki poligonalnej zwarcie miedzyfazowe
+						///< Zasieg „do przodu” strefy 5 charakterystyki kolowej zwarcie miedzyfazowe
+	double X1W_Zr1W_LE; ///< Zasieg reaktancyjny wydluzenie strefy 1 dla charakterystyki poligonalnej zwarcie jednofazowe z ziemia
+						///< Zasieg „do tylu” wydluzenie strefy 1 charakterystyki kolowej zwarcie jednofazowe z ziemia
+	double X1W_Zr1W_LL; ///<  Zasieg reaktancyjny wydluzenie strefy 1 dla charakterystyki poligonalnej zwarcie miedzyfazowe
+						///< Zasieg „do tylu” wydluzenie strefy 1 charakterystyki kolowej zwarcie miedzyfazowe
+	double X1_Zr1_LE; ///< Zasieg reaktancyjny strefy 1 dla charakterystyki poligonalnej zwarcie jednofazowe z ziemia
+						///< Zasieg „do tylu” strefy 1 charakterystyki kolowej zwarcie jednofazowe z ziemia
+	double X1_Zr1_LL; ///<  Zasieg reaktancyjny strefy 1 dla charakterystyki poligonalnej zwarcie miedzyfazowe
+						///< Zasieg „do tylu” strefy 1 charakterystyki kolowej zwarcie miedzyfazowe
+	double X2_Zr2_LE; ///< Zasieg reaktancyjny strefy 2 dla charakterystyki poligonalnej zwarcie jednofazowe z ziemia
+						///< Zasieg „do tylu” strefy 2 charakterystyki kolowej zwarcie jednofazowe z ziemia
+	double X2_Zr2_LL; ///<  Zasieg reaktancyjny strefy 2 dla charakterystyki poligonalnej zwarcie miedzyfazowe
+						///< Zasieg „do tylu” strefy 2 charakterystyki kolowej zwarcie miedzyfazowe
+	double X3_Zr3_LE; ///< Zasieg reaktancyjny strefy 3 dla charakterystyki poligonalnej zwarcie jednofazowe z ziemia
+						///< Zasieg „do tylu” strefy 3 charakterystyki kolowej zwarcie jednofazowe z ziemia
+	double X3_Zr3_LL; ///<  Zasieg reaktancyjny strefy 3 dla charakterystyki poligonalnej zwarcie miedzyfazowe
+						///< Zasieg „do tylu” strefy 3 charakterystyki kolowej zwarcie miedzyfazowe
+	double X4_Zr4_LE; ///< Zasieg reaktancyjny strefy 4 dla charakterystyki poligonalnej zwarcie jednofazowe z ziemia
+						///< Zasieg „do tylu” strefy 4 charakterystyki kolowej zwarcie jednofazowe z ziemia
+	double X4_Zr4_LL; ///<  Zasieg reaktancyjny strefy 4 dla charakterystyki poligonalnej zwarcie miedzyfazowe
+						///< Zasieg „do tylu” strefy 4 charakterystyki kolowej zwarcie miedzyfazowe
+	double X5_Zr5_LE; ///< Zasieg reaktancyjny strefy 5 dla charakterystyki poligonalnej zwarcie jednofazowe z ziemia
+						///< Zasieg „do tylu” strefy 5 charakterystyki kolowej zwarcie jednofazowe z ziemia
+	double X5_Zr5_LL; ///<  Zasieg reaktancyjny strefy 5 dla charakterystyki poligonalnej zwarcie miedzyfazowe
+						///< Zasieg „do tylu” strefy 5 charakterystyki kolowej zwarcie miedzyfazowe
+	double kp; ///< wspolczynnik powrotu
+//A2
+//	double U_min; ///< Minimalna wartosc napiecia
+	double fi3; ///< Kat kierunkowy od osi X impedancyjnego kryterium kierunku
+	double fi4; ///< Kat kierunkowy od osi R  impedancyjnego kryterium kierunku
+	double RLf; ///< Zasieg „ do przodu” kryterium blokady dzialania w zakresie pradow obciażenia
+	double RLr; ///< Zasieg „ do tylu” kryterium blokady dzialania w zakresie pradow obciażenia
+	double fi5; ///< Kat kierunkowy blokady dzialania w zakresie pradow obciażenia
+	double Iomin; ///< Minimalna wartosc rozruchowa pradu zerowego przekaznika identyfikacji zwarc z udzialem ziemi
+	double Iokh; ///< Wspolczynnik stabilizacji charakterystyki przekaznika identyfikacji zwarc z udzialem ziemi
+	double Uomin; ///< minimalna wartość napięcia składowej zerowej
+
+	long Typ0; ///< Typ charakterystyki strefa 1W
+	long K0; ///< Kierunek dzialania strefa 1W
+
+}__attribute__((__packed__));
+
+struct ZDistA_args
+{
+	struct ZDistA_io io;
+	struct ZDistA_params params;
+//	u16 crc;
+}__attribute__((__packed__));
+
+extern void ZDistA(void *args, void *logic);
+extern int ZDistA_initlog(void *arguments, void *logic);
+
+#endif /* ZDISTA_H_ */

src/ZDistA_kopia.h_

@@ -0,0 +1,425 @@
+/*
+ * ZDistA.h
+ *
+ *
+ *  Created on: 09-03-2017
+ *      Author: KJ
+ */
+
+#ifndef ZDISTA_H_
+#define ZDISTA_H_
+
+#include "../tdefs.h"
+#include "helper.h"
+
+	struct impedancja_ZDistA
+	{
+		float R[9];	// czesc rzeczywista impedancji
+		float X[9]; // czesc urojona impedancji
+		float Z[9]; //kwadrat impedancji
+		float absR[9]; // wartosc bezwzgledna impedancji czesc rzeczywista
+		float absX[9]; // wartosc bezwzgledna impedancji czesc urojona
+		float XRtanfi2[9]; // abs(X+R*tan(fi2))
+		float XRtanfi1[9]; // abs(X-R*tan(fi1))
+						//[0] petla L1-E strefa 1
+						//[1] petla L2-E strefa 1
+						//[2] petla L3-E strefa 1
+						//[3] petla L1-E strefa 2,3,4,5
+						//[4] petla L2-E strefa 2,3,4,5
+						//[5] petla L3-E strefa 2,3,4,5
+						//[6] petla L1-L2
+						//[7] petla L2-L3
+						//[8] petla L3-L1
+	};
+
+	struct dane_wewnetrzne_ZDistA
+	{
+		struct impedancja_ZDistA Z;
+		u8 Km;
+		u8 Kp;
+		u8 Igr[6]; // przekroczenie wartosci granicznej pradu
+		u8 Iogr; // zwarcie z udzialem ziemi
+		u8 P_s[6][6];//pobudzenie kryterium impedacyjnego (obszar) [numer strefy][L1E,L2E,L3E,L1L2,L2L3,L3L1]
+		u8 Pbk[6][6];//pobudzenie w strefie [numer strefy][L1E,L2E,L3E,L1L2,L2L3,L3L1] bezkierunkowe
+		u8 P[6][6];//pobudzenie w strefie [numer strefy][L1E,L2E,L3E,L1L2,L2L3,L3L1]
+		u8 BL_Load[9]; ///< impedancja w obszrze pradow roboczych
+		u8 XKp[9]; ///< impedancyjne kryterium kierunku "do przodu"
+		u8 XKm[9]; ///< impedancyjne kryterium kierunku "do tylu"
+		u8 Zm[9];///< impedancyjne kryterium bardzo bliskiego zwarcia
+		short liczp10[9]; /// licznik pobudzen
+		short liczp11[9]; /// licznik pobudzen
+		short liczp12[9]; /// licznik pobudzen
+						//[0] petla L1-E strefa 1
+						//[1] petla L2-E strefa 1
+						//[2] petla L3-E strefa 1
+						//[3] petla L1-E strefa 2,3,4,5
+						//[4] petla L2-E strefa 2,3,4,5
+						//[5] petla L3-E strefa 2,3,4,5
+						//[6] petla L1-L2
+						//[7] petla L2-L3
+						//[8] petla L3-L1
+		short liczps[6][6]; //liczniki pobudzen dla pobudzen stref [numer strefy][L1E,L2E,L3E,L1L2,L2L3,L3L1]
+		short liczpIo; //licznik pobudzen dla identyfikacji zwarc z udzialem ziemi
+		short liczKdod;
+		float U1;
+		float U2;
+		float U3;
+		float I1;
+		float I2;
+		float I3;
+		struct ZDistA_logic *log_ptr;
+	};
+
+	struct nast_w_poligon
+	{
+		float Xr; // zasieg dla poligonu i srodek okregu dla kolowej wspolrzedna X
+		float Rr; // zasieg dla dla poligonu i srodek okregu dla kolowej wspolrzedna R
+		float Z; // srednica kola charakterystyki kolowej
+		float Xp; // zasieg dla poligonu i srodek okregu dla kolowej wspolrzedna X dla powrotu
+		float Rp; // zasieg dla dla poligonu i srodek okregu dla kolowej wspolrzedna R dla powrotu
+		float Zp; // srednica kola charakterystyki kolowej dla powrotu
+		float Rrtanfi1;// wartość rozruchowa prostej nachylonej kątem linii
+		float Rptanfi1;// wartość powrotowa prostej nachylonej kątem linii
+	};
+
+	struct Wyjscia_ZDistA // struktura wyjsc przekaznika
+	{
+		struct dane_wewnetrzne_ZDistA *Zdist_dw;
+		float przekladnia;
+		u8 *on;
+	};
+
+
+    struct Nastawy_przeliczone_ZDistA
+    {
+		struct Wyjscia_ZDistA wyjscie;
+		u8 on_;
+		u8 bl_;
+		u8 Bl_L[6];
+		u8 typ[6];// typ charakterystyki 0 - poligonalna, 1- kolowa
+		float ReK1; // skladowa rzeczywista wspolczynnika kompensacji ziemnozwarciowej dla strefy 1
+		float ImK1;// skladowa urojona wspolczynnika kompensacji ziemnozwarciowej dla strefy 1
+		float ReKr;// skladowa rzeczywista wspolczynnika kompensacji ziemnozwarciowej dla stref 2,3,4,5
+		float ImKr;// skladowa urojona wspolczynnika kompensacji ziemnozwarciowej dla stref 2,3,4,5
+
+		struct nast_w_poligon n_pol[6][2]; // nastawy stref dla charakterystyki poligonalnej [numer strefy][LE/LL]
+		float tanfi1; // tangens kata linii
+		float tanfi2; //tangens kata dodatkowej prostej dla charakterystyki poligonalnej strefa 1
+		float Xr1f; // wartosc rozruchowa dodatkowej prostej dla charakterystyki poligonalnej
+		float Xr1fp; // wartosc powrotowa dodatkowej prostej dla charakterystyki poligonalnej
+		float Xr1Wf; // wartosc rozruchowa dodatkowej prostej dla charakterystyki poligonalnej
+		float Xr1Wfp; // wartosc powrotowa dodatkowej prostej dla charakterystyki poligonalnej
+		float Igr; // wartosc kwadratu pradu granicznego warunku dzialania przekaznika
+		float Igrp; // wartosc kwadratu pradu granicznego warunku dzialania przekaznika (powrot)
+
+		float Zgr;// minimalna wartosc impedancji kryteriunkierunkowego w kwadracie
+		float kp;//współczynnik powrotu dla niedomiarówek
+		float kpp;//współczynnik powrotu dla nadmiarówek
+		float kpk; //kwadrat współczynnika powrotu
+		short kierunek[6];
+
+		//A2
+		float XKR; // wspolczynnik prostej R kierunku kryterium impedancyjnego
+		float XKX; // wspolczynnik prostej R kierunku kryterium impedancyjnego
+		float KL;//wspolczynnik prostej dla blokady od obszaru obciażenia
+		float RLf; // wartosc rozruchowa blokady Load do przodu
+		float RLr; // wartosc rozruchowa blokady Load do tylu
+		float Iogr; // wartosc graniczna skladowej zerowej identyfikacji zwarc z udzialem ziemi
+		float khio; // wspolczynnik stabilizacji dla przekaznika identyfikacji zwarc z udzialem ziemi
+		float Uomin; ///< minimalna wartość napięcia składowej zerowej
+
+    };
+
+struct ZDistA_logic
+{
+        struct binary_io stan_bl;
+		struct binary_io Bl_K;
+		float *I1_orta; ///< Skladowa ortogonalna a pradu faza L1
+		float *I1_ortb; ///< Skladowa ortogonalna b pradu faza L1
+		float *I1; ///< Prad mierzony faza 1
+		float *I2_orta; ///< Skladowa ortogonalna a pradu faza L2
+		float *I2_ortb; ///< Skladowa ortogonalna b pradu faza L2
+		float *I2; ///< Prad mierzony faza 2
+		float *I3_orta; ///< Skladowa ortogonalna a pradu faza L3
+		float *I3_ortb; ///< Skladowa ortogonalna b pradu faza L3
+		float *I3; ///< Prad mierzony faza 3
+		float *U1_orta; ///< Skladowa ortogonalna a napiecia faza L1
+		float *U1_ortb; ///< Skladowa ortogonalna b napiecia faza L1
+		float *U1; ///< Napiecie mierzone faza 1
+		float *U2_orta; ///< Skladowa ortogonalna a napiecia faza L2
+		float *U2_ortb; ///< Skladowa ortogonalna b napiecia faza L2
+		float *U2; ///< Napiecie mierzone faza 2
+		float *U3_orta; ///< Skladowa ortogonalna a napiecia faza L3
+		float *U3_ortb; ///< Skladowa ortogonalna b napiecia faza L3
+		float *U3; ///< Napiecie mierzone faza 3
+		float *U12_orta; ///< Skladowa ortogonalna a napiecia L1-L2
+		float *U12_ortb; ///< Skladowa ortogonalna b napiecia L1-L2
+		float *U12; ///< Napiecie mierzone L1-L2
+		float *U23_orta; ///< Skladowa ortogonalna a napiecia L2-L3
+		float *U23_ortb; ///< Skladowa ortogonalna b napiecia L2-L3
+		float *U23; ///< Napiecie mierzone L2-L3
+		float *U31_orta; ///< Skladowa ortogonalna a napiecia L3-L1
+		float *U31_ortb; ///< Skladowa ortogonalna b napiecia L3-L1
+		float *U31; ///< Napiecie mierzone L3-L1
+		float *sI1_orta; ///< Skladowa ortogonalna a skladowej zgodnej pradu
+		float *sI1_ortb; ///< Skladowa ortogonalna b skladowej zgodnej pradu
+		float *sI1; ///< Skladowa zgodna pradu
+		float *sI2_orta; ///< Skladowa ortogonalna a skladowej przeciwnej pradu
+		float *sI2_ortb; ///< Skladowa ortogonalna b skladowej przeciwnej pradu
+		float *sI2; ///< Skladowa przeciwna pradu
+		float *sI0_orta; ///< Skladowa ortogonalna a skladowej zerowej pradu
+		float *sI0_ortb; ///< Skladowa ortogonalna b skladowej zerowej pradu
+		float *sI0; ///< Skladowa zerowa pradu
+		float *sU1_orta; ///< Skladowa ortogonalna a skladowej zgodnej napiecia
+		float *sU1_ortb; ///< Skladowa ortogonalna b skladowej zgodnej napiecia
+		float *sU1; ///< Skladowa zgodna napiecia
+		float *sU2_orta; ///< Skladowa ortogonalna a skladowej przeciwnej napiecia
+		float *sU2_ortb; ///< Skladowa ortogonalna b skladowej przeciwnej napiecia
+		float *sU2; ///< Skladowa przeciwna napiecia
+		float *sU0_orta; ///< Skladowa ortogonalna a skladowej zerowej napiecia
+		float *sU0_ortb; ///< Skladowa ortogonalna b skladowej zerowej napiecia
+		float *sU0; ///< Skladowa zerowa napiecia
+		struct analog_in_params *param_I; ///< Parametry wejscia pradowego
+		struct analog_in_params *param_U; /// < Parametry kanalu napieciowego
+		struct binary_io test;
+		struct binary_io P1W_L1E; ///< Pobudzenie strefy 1W zwarcie L1-E
+		struct binary_io P1W_L2E; ///< Pobudzenie strefy 1W zwarcie L2-E
+		struct binary_io P1W_L3E; ///< Pobudzenie strefy 1W zwarcie L3-E
+		struct binary_io P1W_L1L2; ///< Pobudzenie strefy 1W zwarcie L1-L2
+		struct binary_io P1W_L2L3; ///< Pobudzenie strefy 1W zwarcie L2-L3
+		struct binary_io P1W_L3L1; ///< Pobudzenie strefy 1W zwarcie L3-L1
+		struct binary_io P1_L1E; ///< Pobudzenie strefy 1 zwarcie L1-E
+		struct binary_io P1_L2E; ///< Pobudzenie strefy 1 zwarcie L2-E
+		struct binary_io P1_L3E; ///< Pobudzenie strefy 1 zwarcie L3-E
+		struct binary_io P1_L1L2; ///< Pobudzenie strefy 1 zwarcie L1-L2
+		struct binary_io P1_L2L3; ///< Pobudzenie strefy 1 zwarcie L2-L3
+		struct binary_io P1_L3L1; ///< Pobudzenie strefy 1 zwarcie L3-L1
+		struct binary_io P2_L1E; ///< Pobudzenie strefy 2 zwarcie L1-E
+		struct binary_io P2_L2E; ///< Pobudzenie strefy 2 zwarcie L2-E
+		struct binary_io P2_L3E; ///< Pobudzenie strefy 2 zwarcie L3-E
+		struct binary_io P2_L1L2; ///< Pobudzenie strefy 2 zwarcie L1-L2
+		struct binary_io P2_L2L3; ///< Pobudzenie strefy 2 zwarcie L2-L3
+		struct binary_io P2_L3L1; ///< Pobudzenie strefy 2 zwarcie L3-L1
+		struct binary_io P3_L1E; ///< Pobudzenie strefy 3 zwarcie L1-E
+		struct binary_io P3_L2E; ///< Pobudzenie strefy 3 zwarcie L2-E
+		struct binary_io P3_L3E; ///< Pobudzenie strefy 3 zwarcie L3-E
+		struct binary_io P3_L1L2; ///< Pobudzenie strefy 3 zwarcie L1-L2
+		struct binary_io P3_L2L3; ///< Pobudzenie strefy 3 zwarcie L2-L3
+		struct binary_io P3_L3L1; ///< Pobudzenie strefy 3 zwarcie L3-L1
+		struct binary_io P4_L1E; ///< Pobudzenie strefy 4 zwarcie L1-E
+		struct binary_io P4_L2E; ///< Pobudzenie strefy 4 zwarcie L2-E
+		struct binary_io P4_L3E; ///< Pobudzenie strefy 4 zwarcie L3-E
+		struct binary_io P4_L1L2; ///< Pobudzenie strefy 4 zwarcie L1-L2
+		struct binary_io P4_L2L3; ///< Pobudzenie strefy 4 zwarcie L2-L3
+		struct binary_io P4_L3L1; ///< Pobudzenie strefy 4 zwarcie L3-L1
+		struct binary_io P5_L1E; ///< Pobudzenie strefy 5 zwarcie L1-E
+		struct binary_io P5_L2E; ///< Pobudzenie strefy 5 zwarcie L2-E
+		struct binary_io P5_L3E; ///< Pobudzenie strefy 5 zwarcie L3-E
+		struct binary_io P5_L1L2; ///< Pobudzenie strefy 5 zwarcie L1-L2
+		struct binary_io P5_L2L3; ///< Pobudzenie strefy 5 zwarcie L2-L3
+		struct binary_io P5_L3L1; ///< Pobudzenie strefy 5 zwarcie L3-L1
+
+    	struct dane_wewnetrzne_ZDistA dw;
+    	struct Nastawy_przeliczone_ZDistA nast_;// struktura z parametrami
+
+    	float *z[6]; /// debug
+};
+
+struct ZDistA_io
+{
+	u32 bl_in;
+	u32 bl_k_in;
+	u32 i1_orta_float_in;
+	u32 i1_ortb_float_in;
+	u32 i1_float_in;
+	u32 i2_orta_float_in;
+	u32 i2_ortb_float_in;
+	u32 i2_float_in;
+	u32 i3_orta_float_in;
+	u32 i3_ortb_float_in;
+	u32 i3_float_in;
+	u32 u1_orta_float_in;
+	u32 u1_ortb_float_in;
+	u32 u1_float_in;
+	u32 u2_orta_float_in;
+	u32 u2_ortb_float_in;
+	u32 u2_float_in;
+	u32 u3_orta_float_in;
+	u32 u3_ortb_float_in;
+	u32 u3_float_in;
+	u32 u12_orta_float_in;
+	u32 u12_ortb_float_in;
+	u32 u12_float_in;
+	u32 u23_orta_float_in;
+	u32 u23_ortb_float_in;
+	u32 u23_float_in;
+	u32 u31_orta_float_in;
+	u32 u31_ortb_float_in;
+	u32 u31_float_in;
+	u32 i1_zg_orta_float_in;
+	u32 i1_zg_ortb_float_in;
+	u32 i1_zg_float_in;
+	u32 i2_pr_orta_float_in;
+	u32 i2_pr_ortb_float_in;
+	u32 i2_pr_float_in;
+	u32 io_orta_float_in;
+	u32 io_ortb_float_in;
+	u32 io_float_in;
+	u32 u1_zg_orta_float_in;
+	u32 u1_zg_ortb_float_in;
+	u32 u1_zg_float_in;
+	u32 u2_pr_orta_float_in;
+	u32 u2_pr_ortb_float_in;
+	u32 u2_pr_float_in;
+	u32 uo_orta_float_in;
+	u32 uo_ortb_float_in;
+	u32 uo_float_in;
+	u32 i_param_an_ptr_in;
+	u32 u_param_an_ptr_in;
+	u32 test_in;
+	u32 wy_ptr_out;	//zainicjowac
+	u32 P1W_L1E_out;
+	u32 P1W_L2E_out;
+	u32 P1W_L3E_out;
+	u32 P1W_L1L2_out;
+	u32 P1W_L2L3_out;
+	u32 P1W_L3L1_out;
+	u32 P1_L1E_out;
+	u32 P1_L2E_out;
+	u32 P1_L3E_out;
+	u32 P1_L1L2_out;
+	u32 P1_L2L3_out;
+	u32 P1_L3L1_out;
+	u32 P2_L1E_out;
+	u32 P2_L2E_out;
+	u32 P2_L3E_out;
+	u32 P2_L1L2_out;
+	u32 P2_L2L3_out;
+	u32 P2_L3L1_out;
+	u32 P3_L1E_out;
+	u32 P3_L2E_out;
+	u32 P3_L3E_out;
+	u32 P3_L1L2_out;
+	u32 P3_L2L3_out;
+	u32 P3_L3L1_out;
+	u32 P4_L1E_out;
+	u32 P4_L2E_out;
+	u32 P4_L3E_out;
+	u32 P4_L1L2_out;
+	u32 P4_L2L3_out;
+	u32 P4_L3L1_out;
+	u32 P5_L1E_out;
+	u32 P5_L2E_out;
+	u32 P5_L3E_out;
+	u32 P5_L1L2_out;
+	u32 P5_L2L3_out;
+	u32 P5_L3L1_out;
+
+	//debug
+	u32 z1_float_out;
+	u32 z2_float_out;
+	u32 z3_float_out;
+	u32 z4_float_out;
+	u32 z5_float_out;
+	u32 z6_float_out;
+
+}__attribute__((__packed__));
+
+struct ZDistA_params
+{
+	u32 bity; ///< nastawy bitowe;
+
+	long Typ1; ///< Typ charakterystyki strefa 1
+	long Typ2; ///< Typ charakterystyki strefa 2
+	long Typ3; ///< Typ charakterystyki strefa 3
+	long Typ4; ///< Typ charakterystyki strefa 4
+	long Typ5; ///< Typ charakterystyki strefa 5
+	long K1; ///< Kierunek dzialania strefa 1
+	long K2; ///< Kierunek dzialania strefa 2
+	long K3; ///< Kierunek dzialania strefa 3
+	long K4; ///< Kierunek dzialania strefa 4
+	long K5; ///< Kierunek dzialania strefa 5
+
+	double I_min; ///< Graniczna wartosc pradu
+	double Kk1;	///< Wspolczynnik kompensacji ziemnozwarciowej strefa 1
+	double Kk1_kat; ///< Kat wektora kompensacji ziemnozwarciowej strefa 1
+	double KkC; ///< Wspolczynnik kompensacji ziemnozwarciowej stref 2,3,4,5
+	double KkC_kat; ///< Kat wektora kompensacji ziemnozwarciowej stref 2,3,4,5
+	double fi1; ///< Kat linii
+	double fi2; ///< Kat nachylenia prostej korekcji strefy pierwszej dla zwarc jednofazowych z ziemia
+	double R1W_Zf1W_LE; ///< Zasieg rezystancyjny strefy 1 dla charakterystyki poligonalnej zwarcie jednofazowe z ziemia
+						///<	Zasieg „do przodu” wydluzenie strefy 1 charakterystyki kolowej zwarcie jednofazowe z ziemia
+	double R1W_Zf1W_LL; ///< Zasieg rezystancyjny strefy 1 dla charakterystyki poligonalnej zwarcie miedzyfazowe
+						///< Zasieg „do przodu” wyduzenie strefy 1 charakterystyki kolowej zwarcie miedzyfazowe
+	double R1_Zf1_LE; ///< Zasieg rezystancyjny strefy 1 dla charakterystyki poligonalnej zwarcie jednofazowe z ziemia
+						///<	Zasieg „do przodu” strefy 1 charakterystyki kolowej zwarcie jednofazowe z ziemia
+	double R1_Zf1_LL; ///< Zasieg rezystancyjny strefy 1 dla charakterystyki poligonalnej zwarcie miedzyfazowe
+						///< Zasieg „do przodu” strefy 1 charakterystyki kolowej zwarcie miedzyfazowe
+	double R2_Zf2_LE; ///< Zasieg rezystancyjny strefy 2 dla charakterystyki poligonalnej zwarcie jednofazowe z ziemia
+						///<	Zasieg „do przodu” strefy 2 charakterystyki kolowej zwarcie jednofazowe z ziemia
+	double R2_Zf2_LL; ///< Zasieg rezystancyjny strefy 2 dla charakterystyki poligonalnej zwarcie miedzyfazowe
+						///< Zasieg „do przodu” strefy 2 charakterystyki kolowej zwarcie miedzyfazowe
+	double R3_Zf3_LE; ///< Zasieg rezystancyjny strefy 3 dla charakterystyki poligonalnej zwarcie jednofazowe z ziemia
+						///<	Zasieg „do przodu” strefy 3 charakterystyki kolowej zwarcie jednofazowe z ziemia
+	double R3_Zf3_LL; ///< Zasieg rezystancyjny strefy 3 dla charakterystyki poligonalnej zwarcie miedzyfazowe
+						///< Zasieg „do przodu” strefy 3 charakterystyki kolowej zwarcie miedzyfazowe
+	double R4_Zf4_LE; ///< Zasieg rezystancyjny strefy 4 dla charakterystyki poligonalnej zwarcie jednofazowe z ziemia
+						///<	Zasieg „do przodu” strefy 4 charakterystyki kolowej zwarcie jednofazowe z ziemia
+	double R4_Zf4_LL; ///< Zasieg rezystancyjny strefy 4 dla charakterystyki poligonalnej zwarcie miedzyfazowe
+						///< Zasieg „do przodu” strefy 4 charakterystyki kolowej zwarcie miedzyfazowe
+	double R5_Zf5_LE; ///< Zasieg rezystancyjny strefy 5 dla charakterystyki poligonalnej zwarcie jednofazowe z ziemia
+						///<	Zasieg „do przodu” strefy 5 charakterystyki kolowej zwarcie jednofazowe z ziemia
+	double R5_Zf5_LL; ///< Zasieg rezystancyjny strefy 5 dla charakterystyki poligonalnej zwarcie miedzyfazowe
+						///< Zasieg „do przodu” strefy 5 charakterystyki kolowej zwarcie miedzyfazowe
+	double X1W_Zr1W_LE; ///< Zasieg reaktancyjny wydluzenie strefy 1 dla charakterystyki poligonalnej zwarcie jednofazowe z ziemia
+						///< Zasieg „do tylu” wydluzenie strefy 1 charakterystyki kolowej zwarcie jednofazowe z ziemia
+	double X1W_Zr1W_LL; ///<  Zasieg reaktancyjny wydluzenie strefy 1 dla charakterystyki poligonalnej zwarcie miedzyfazowe
+						///< Zasieg „do tylu” wydluzenie strefy 1 charakterystyki kolowej zwarcie miedzyfazowe
+	double X1_Zr1_LE; ///< Zasieg reaktancyjny strefy 1 dla charakterystyki poligonalnej zwarcie jednofazowe z ziemia
+						///< Zasieg „do tylu” strefy 1 charakterystyki kolowej zwarcie jednofazowe z ziemia
+	double X1_Zr1_LL; ///<  Zasieg reaktancyjny strefy 1 dla charakterystyki poligonalnej zwarcie miedzyfazowe
+						///< Zasieg „do tylu” strefy 1 charakterystyki kolowej zwarcie miedzyfazowe
+	double X2_Zr2_LE; ///< Zasieg reaktancyjny strefy 2 dla charakterystyki poligonalnej zwarcie jednofazowe z ziemia
+						///< Zasieg „do tylu” strefy 2 charakterystyki kolowej zwarcie jednofazowe z ziemia
+	double X2_Zr2_LL; ///<  Zasieg reaktancyjny strefy 2 dla charakterystyki poligonalnej zwarcie miedzyfazowe
+						///< Zasieg „do tylu” strefy 2 charakterystyki kolowej zwarcie miedzyfazowe
+	double X3_Zr3_LE; ///< Zasieg reaktancyjny strefy 3 dla charakterystyki poligonalnej zwarcie jednofazowe z ziemia
+						///< Zasieg „do tylu” strefy 3 charakterystyki kolowej zwarcie jednofazowe z ziemia
+	double X3_Zr3_LL; ///<  Zasieg reaktancyjny strefy 3 dla charakterystyki poligonalnej zwarcie miedzyfazowe
+						///< Zasieg „do tylu” strefy 3 charakterystyki kolowej zwarcie miedzyfazowe
+	double X4_Zr4_LE; ///< Zasieg reaktancyjny strefy 4 dla charakterystyki poligonalnej zwarcie jednofazowe z ziemia
+						///< Zasieg „do tylu” strefy 4 charakterystyki kolowej zwarcie jednofazowe z ziemia
+	double X4_Zr4_LL; ///<  Zasieg reaktancyjny strefy 4 dla charakterystyki poligonalnej zwarcie miedzyfazowe
+						///< Zasieg „do tylu” strefy 4 charakterystyki kolowej zwarcie miedzyfazowe
+	double X5_Zr5_LE; ///< Zasieg reaktancyjny strefy 5 dla charakterystyki poligonalnej zwarcie jednofazowe z ziemia
+						///< Zasieg „do tylu” strefy 5 charakterystyki kolowej zwarcie jednofazowe z ziemia
+	double X5_Zr5_LL; ///<  Zasieg reaktancyjny strefy 5 dla charakterystyki poligonalnej zwarcie miedzyfazowe
+						///< Zasieg „do tylu” strefy 5 charakterystyki kolowej zwarcie miedzyfazowe
+	double kp; ///< wspolczynnik powrotu
+//A2
+//	double U_min; ///< Minimalna wartosc napiecia
+	double fi3; ///< Kat kierunkowy od osi X impedancyjnego kryterium kierunku
+	double fi4; ///< Kat kierunkowy od osi R  impedancyjnego kryterium kierunku
+	double RLf; ///< Zasieg „ do przodu” kryterium blokady dzialania w zakresie pradow obciażenia
+	double RLr; ///< Zasieg „ do tylu” kryterium blokady dzialania w zakresie pradow obciażenia
+	double fi5; ///< Kat kierunkowy blokady dzialania w zakresie pradow obciażenia
+	double Iomin; ///< Minimalna wartosc rozruchowa pradu zerowego przekaznika identyfikacji zwarc z udzialem ziemi
+	double Iokh; ///< Wspolczynnik stabilizacji charakterystyki przekaznika identyfikacji zwarc z udzialem ziemi
+	double Uomin; ///< minimalna wartość napięcia składowej zerowej
+
+	long Typ0; ///< Typ charakterystyki strefa 1W
+	long K0; ///< Kierunek dzialania strefa 1W
+
+}__attribute__((__packed__));
+
+struct ZDistA_args
+{
+	struct ZDistA_io io;
+	struct ZDistA_params params;
+//	u16 crc;
+}__attribute__((__packed__));
+
+extern void ZDistA(void *args, void *logic);
+extern int ZDistA_initlog(void *arguments, void *logic);
+
+#endif /* ZDISTA_H_ */

src/ZDistL.h

@@ -0,0 +1,409 @@
+/*
+ * ZDistL.h
+ *
+ *
+ *  Created on: 29-11-2016
+ *      Author: KJ
+ */
+
+#ifndef ZDISTL_H_
+#define ZDISTL_H_
+/*
+#include <stdint.h>
+#define u8 uint8_t
+#define u16 uint16_t
+#define u32 uint32_t
+
+struct  binary_io
+{
+	int yyyy;
+};
+
+*/
+
+#include "tdefs.h"
+#include "helper.h"
+
+struct Wyjscie1_zdistl
+{
+	u8 dbl_Com[7]; ///deblokowanie dzia<69>ania stref w zale<6C>no<6E>ci od stanu <20><>cza
+	u8 PSPZ;//pobudzenie SPZ
+};
+
+enum Wylaczenie
+{
+	start_jednofazowy,
+	start_trojfazowy,
+	start_kombinowany,
+	wyl_definitywny
+
+};
+
+
+	enum _tryb_lacza
+	{
+		WYL = 0,
+		ZEZWALAJACY = 1,
+		BLOKUJACY = 2
+	};	
+	
+	enum _tryb_zezwalajacy
+	{
+		ZGODA = 0,
+		SKROC_CZAS = 1,	
+		WYLACZ = 2
+	};
+	
+	enum _tryb_blokujacy
+	{
+		BLOKUJ = 0,
+		WYDLUZ_CZAS = 1,
+		BLOKUJ_PRZEKAZNIK = 2,
+		SKROC_ZASIEG = 3	
+	};	
+
+
+
+struct dane_wewnetrzne_ZDistL
+{
+       u8 blok_lacza[6];
+        u8 wydl_czas;       
+        u8 wylacz_od_lacza;
+        u8 wylacz_od_echa;
+        u8 wylacz_od_lacza_suma;
+        //lacze nad       
+        u16 t_lacze_nad;
+        u8 lacze_nad;
+        
+        u16 trwanie_nad;
+        u8 skrocil_strefa;
+        u8 skrocil_echo;
+        
+        
+        //logika pradu wstecznego       
+        u8 blokada_pradu_wstecznego;
+        u16 t_pod_blok_wst;
+        u8 kopia_lacze_ok;
+        u8 lacze_odb_old;
+        
+        
+        //logika odblokowania
+        u8 logika_dblokowania;
+        u16 t_log_odblokowania;
+             
+        u8 blok_LRC[6];
+
+        u16 t_wyl_od_echa;
+               
+        float RL1Em; ///< Rezystancja pętli zwarciowej fazy L1 z ziemia (rejestracja)
+        float XL1Em; ///< Rezaktancja pętli zwarciowej fazy L1 z ziemia (rejestracja)
+        float RL2Em; ///< Rezystancja pętli zwarciowej fazy L2 z ziemia (rejestracja)
+        float XL2Em; ///< Rezaktancja pętli zwarciowej fazy L2 z ziemia (rejestracja)
+        float RL3Em; ///< Rezystancja pętli zwarciowej fazy L3 z ziemia (rejestracja)
+        float XL3Em; ///< Rezaktancja pętli zwarciowej fazy L3 z ziemia (rejestracja)
+        float RL1L2m; ///< Rezystancja pętli zwarciowej fazy L1 z L2 (rejestracja)
+        float XL1L2m; ///< Rezaktancja pętli zwarciowej fazy L1 z L2 (rejestracja)
+        float RL2L3m; ///< Rezystancja pętli zwarciowej fazy L2 z L3 (rejestracja)
+        float XL2L3m; ///< Rezaktancja pętli zwarciowej fazy L2 z L3 (rejestracja)
+        float RL3L1m; ///< Rezystancja pętli zwarciowej fazy L3 z L1 (rejestracja)
+        float XL3L1m; ///< Rezaktancja pętli zwarciowej fazy L3 z L1 (rejestracja)
+		short liczts[6][2]; ///<licznik czasu czas opoznienia dzialania strefy
+    
+    	short liczt_eldz[6][2]; ///<licznik czasu czas opoznienia dzialania strefy
+
+		short licznik_ZZwa;///< licznik do automatyki załączenia na zwarcie
+		short licznik_PIU;///< licznik pobudzeń sprawdzania obecności napiecia i prądu
+		
+		short licznik_Uecho;
+		
+		//Wyjscia_rejestratora Rej; ///< dane ostatniego zaklocenia
+		//Time czas_; // moment wystapienia zaklocenia (rejestr tymczasowy - przed zapisem)
+		u32 dl_; // dlugosc czasu trwania zaklocenia (rejestr tymczasowy - przed zapisem)
+		u8 wsk_rej; // nowy zapis rejestracji parametrow zaklocenia (spelnienie kryterium identyfikacji)
+		u8 Pf[6][2]; // pobudzenia stref P[nr strefy][fazowe,miedzyfazowe]
+		u8 Pzf[6]; //pobudzenie stref
+		u8 P;// pobudzenie zbiorcze
+		u8 Zf[6][2]; // zadzialanie strefy
+		u8 Z[6]; // zadzialanie strefy
+		u8 Ws[6]; // wyłaczenie od strefy 
+		u8 Zz; // Zadzialanie sygnal zbiorczy
+		u8 W; // wylaczenie sygnal zbiorczy
+		u8 W1; // wylaczenie faza L1
+		u8 W2; // wylaczenie faza L2
+		u8 W3; // wylaczenie faza L3
+		u8 R;//zwarcie z udziałem fazy L1
+		u8 S;//zwarcie z udziałem fazy L2
+		u8 T;//zwarcie z udziałem fazy L3
+		u8 Rbk;//zwarcie z udziałem fazy L1(bezkierunkowo)
+		u8 Sbk;//zwarcie z udziałem fazy L2(bezkierunkowo)
+		u8 Tbk;//zwarcie z udziałem fazy L3(bezkierunkowo)
+		u8 E;//zwarcie z udziałem ziemi
+		u8 jedfaz;//zwarcie jednofazowe
+		u8 W_ON;//wyłącznik zamkniety
+		u8 W1_ON;//wyłącznik zamkniety faza L1
+		u8 W2_ON;//wyłącznik zamkniety faza L2
+		u8 W3_ON;//wyłącznik zamkniety faza L3
+		u8 W_OFF;//wyłącznik otwarty
+		u8 W1_OFF;//wyłącznik otwarty faza L1
+		u8 W2_OFF;//wyłącznik otwarty faza L2
+		u8 W3_OFF;//wyłącznik otwarty faza L3
+		u8 ZZw; //aktywna automatyka załączenia na zwarcie
+		u8 ZZw_start; //spełnienie warunków uruchomienia automatyki załączenia na zwarcie
+		u8 ZZw_PIU; //pobudzenie kryterium napięcie/prąd zamknięcia wyłącznika
+		u8 pob_echo;
+		u8 bl_WSPZ;//zezwolenie na wyłącz od SPZ
+		u8 R1;
+		u8 S1;
+		u8 T1;
+		u8 ZZwP;//wyłączenie od automatyki załączenia na zwarcie
+		u8 wy_blk_lacz;
+		
+		u8 wy_bl_LRC;
+		u8 wy_log_odbl;
+        u8 wy_lacze_nad;
+        
+        u8 wy_zadz_echa;
+		u8 wy_zezw_lacz; 
+		u8 wy_skr_czas_lacz; 
+		u8 wy_wyl_lacz; 
+		u8 wy_blok_lacz; 
+		u8 wy_wydl_czas_lacz; 
+		
+		u8 Zf_rozwij[6];
+		short liczts_rozwij[6];
+		short liczt_eldz_rozwij[6];
+		short dodaj_rozw[6];
+		
+};
+
+struct Nastawy_przeliczone_ZDistL
+{
+	struct Wyjscie1_zdistl wy;
+
+	struct Wyjscia_ZDistA *ZdistA;
+		
+	u16 ZZw_st; ///< strefa współpracy z automatyką załączenia na zwarcie
+	u16 adr_PZZw;///< adres zmiennej pobudzenia strefy współpracujacej z automatyką ZZw
+	u16 adr_ZZZw;///< adres zmiennej zadziałania strefy współpracujacej z automatyką ZZw
+
+	u8 echo_on;
+	u8 wyl_od_echa;
+	u8 log_odbl_on;
+	u8 LCR_on;
+	u8 lacze_on;	
+	u8 LRC_s[6];
+	u8 zgoda_1faz_s[6];
+
+	u8 Bl_PS[6];
+	u8 ZZw_ON; ///< włączenie automatyki załączenia na zwarcie
+	u8 bl_; ///< wartosc nastawy aktywnosci blokady dzialania 1- blokada aktywna
+	
+	u8 rozwij;
+	
+	enum _tryb_zezwalajacy tryb_zezw;
+    enum _tryb_blokujacy tryb_blok;
+    enum _tryb_lacza tryb_lacza;
+		
+	u8 ktora_strefa;
+	u8 ktora_strefa_nad;
+    u8 strefa_pradu_wstecznego;
+				
+	short t_stf[6][2]; ///< czas dzialania strefy
+	float ZZw_ta;///< Czas działania funkcji po zamknięciu wyłącznika
+	float ZZw_Ir;///< Prąd identyfikacji otwarcia wyłącznika
+	float ZZw_Ur;///< Napięcie identyfikacji otwarcia wyłacznika
+	short ZZw_to;///< Czas identyfikacji otwarcia wyłącznika
+
+	short t_LRC;///< Czas podtrzymania w logice odwroconego pradu
+	short t_pod_odbl;///< Czas podtrzymania odblokowania w logice odblokowania
+	short t_lacze_nad;///< Czas przerwy beznapięciowej dla wyłączenia jednofazowego
+	short ts_plus;
+
+	short max_t_nadawania;
+	short czas_wyl_echa;
+
+	float Uecho_pob;
+	float Uecho_odp;
+		
+	u8 Zbz[6][2]; ///< zadziałanie bezzwloczne strefy
+	u8 Stf_ON[6]; ///< wlaczenie/odstawienie strefy
+	u8 Stf_W[6]; ///< działanie na wylaczenie/sygnalizacje strefy
+
+
+
+
+
+};
+
+struct ZDistL_logic
+{
+ 
+    struct binary_io stan_bl;
+    struct Wyjscia_ZDistA *WE_Zdist;
+	struct binary_io Bl_PS;
+	struct binary_io lacze_OK;
+	struct binary_io lacze_odb;
+	struct binary_io W_ON;
+	struct binary_io zgoda_1f;
+	struct binary_io Z;
+	struct binary_io test;
+	struct binary_io blok_1W;
+		
+    struct binary_io P;
+	struct binary_io P1W;
+	struct binary_io P1;
+	struct binary_io P2;
+	struct binary_io P3;
+	struct binary_io P4;
+	struct binary_io P5;
+	struct binary_io R;
+	struct binary_io S;
+	struct binary_io T;
+	struct binary_io E;
+	struct binary_io Z1W;
+	struct binary_io Z1;
+	struct binary_io Z2;
+	struct binary_io Z3;
+	struct binary_io Z4;
+	struct binary_io Z5;	
+	struct binary_io W;
+	struct binary_io W1;
+	struct binary_io W2;
+	struct binary_io W3;
+	struct binary_io bl_LRC;
+	struct binary_io log_odbl;
+	struct binary_io lacze_nad;
+	struct binary_io zzw_akt;
+	struct binary_io blk_lacz;
+	
+	struct binary_io deakt;
+
+	//nowe
+	struct binary_io zadz_echa;
+	struct binary_io zezw_lacz;
+	struct binary_io skr_czas_lacz;
+	struct binary_io wyl_lacz;
+	struct binary_io blok_lacz;
+	struct binary_io wydl_czas_lacz;
+	struct binary_io z_zwarcie;
+	
+	struct binary_io PZZw;
+	struct binary_io ZZZw;
+	
+	struct Nastawy_przeliczone_ZDistL nast_;
+	struct dane_wewnetrzne_ZDistL dw;
+
+	u8 pobudzenia[6][6];
+	u8 P_L1_lub_L2[6];
+	u8 P_L2_lub_L3[6];
+	u8 P_L3_lub_L1[6];
+};
+
+struct ZDistL_io
+{
+	u32	stan_bl_in;
+	u32	 we_zdist_ptr_in;
+	u32	Bl_PS_in;
+	u32	lacze_OK_in;
+	u32	lacze_odb_in;
+	u32	W_ON_in;
+	u32	zgoda_1f_in;
+	u32	Z_in;
+	u32	test_in;
+	u32 blok_1W_in;
+	u32 deakt_in;
+
+	u32	P_out;
+	u32	P1W_out;
+	u32	P1_out;
+	u32	P2_out;
+	u32	P3_out;
+	u32	P4_out;
+	u32	P5_out;
+	u32	R_out;
+	u32	S_out;
+	u32	T_out;
+	u32	E_out;
+	u32	Z1W_out;
+	u32	Z1_out;
+	u32	Z2_out;
+	u32	Z3_out;
+	u32	Z4_out;
+	u32	Z5_out;
+	u32	W_out;
+	u32	W1_out;
+	u32	W2_out;
+	u32	W3_out;
+	u32	bl_LRC_out;
+	u32	log_odbl_out;
+	u32	lacze_nad_out;
+	u32	zzw_akt_out;
+	u32 blk_lacz_out;
+	
+	//nowe
+	u32 zadz_echa_out;
+	u32 zezw_lacz_out;
+	u32 skr_czas_lacz_out;
+	u32 wyl_lacz_out;
+	u32 blok_lacz_out;
+	u32 wydl_czas_lacz_out;
+	u32 z_zwarcie_out;	
+	
+}__attribute__((__packed__));
+
+struct ZDistL_params
+{
+	long bity; ///< nastawy bitowe;
+	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
+	long tryb_lacza; ///< tryb lacza
+	long ZZw_st; ///< strefa współpracy z automatyką załączenia na zwarcie
+	long tryb_zezw; ///<tryb zezwalajacy
+	long tryb_blokujacy; ///<tryb blokujacy
+	long strefa_nad;///<wybor strefy do nadawania
+	long strefa_dzial; //<dzia<69>anie na stref<65>
+	long lrc_strefa; //<strefa logiku pr<70>du wstecznego
+
+	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
+	double t_LRC;///< Czas podtrzymania w logice odwroconego pradu
+	double t_pod_odbl;///< Czas podtrzymania odblokowania w logice odblokowania
+	double t_lacze_nad;///< Czas przerwy beznapięciowej dla wyłączenia jednofazowego
+	double ZZw_ta;///< Czas działania funkcji po zamknięciu wyłącznika
+	double ZZw_Ir;///< Prąd identyfikacji otwarcia wyłącznika
+	double ZZw_Ur;///< Napięcie identyfikacji otwarcia wyłacznika
+	double ZZw_to;///< Czas identyfikacji otwarcia wyłącznika
+	double U_echa;
+	double ts_plus;
+	double max_t_nadawania;
+	double czas_wyl_echa;
+	
+	long Stf0; ///< Sposób działania strefy 1
+	double ts0LE;///< Czas wyłączenia strefy 1 zwarcia jednofazowe z ziemią
+	double ts0LL;///< Czas wyłączenia strefy 1 zwarcia miedzyfazowe
+	
+}__attribute__((__packed__));
+
+struct ZDistL_args
+{
+	struct ZDistL_io io;
+	struct ZDistL_params params;
+//	u16 crc;
+}__attribute__((__packed__));
+
+extern void ZDistL(void *args, void *logic);
+extern void ZDistL_100hz(void *args, void *logic);
+extern int ZDistL_initlog(void *arguments, void *logic);
+
+#endif /* ZDISTL_H_ */

src/ZDistL_marian.h_

@@ -0,0 +1,336 @@
+/*
+ * ZDistL.h
+ *
+ *
+ *  Created on: 29-11-2016
+ *      Author: KJ
+ */
+
+#ifndef ZDISTL_H_
+#define ZDISTL_H_
+
+#include "../tdefs.h"
+#include "helper.h"
+
+struct Wyjscie1_zdistl
+{
+	u8 dbl_Com[7]; ///deblokowanie działania stref w zależności od stanu łącza
+	u8 PSPZ;//pobudzenie SPZ
+};
+
+enum Wylaczenie
+{
+	start_jednofazowy,
+	start_trojfazowy,
+	start_kombinowany,
+	wyl_definitywny
+
+};
+
+
+struct dane_wewnetrzne_ZDistL
+{
+    float RL1Em; ///< Rezystancja pętli zwarciowej fazy L1 z ziemia (rejestracja)
+    float XL1Em; ///< Rezaktancja pętli zwarciowej fazy L1 z ziemia (rejestracja)
+    float RL2Em; ///< Rezystancja pętli zwarciowej fazy L2 z ziemia (rejestracja)
+    float XL2Em; ///< Rezaktancja pętli zwarciowej fazy L2 z ziemia (rejestracja)
+    float RL3Em; ///< Rezystancja pętli zwarciowej fazy L3 z ziemia (rejestracja)
+    float XL3Em; ///< Rezaktancja pętli zwarciowej fazy L3 z ziemia (rejestracja)
+    float RL1L2m; ///< Rezystancja pętli zwarciowej fazy L1 z L2 (rejestracja)
+    float XL1L2m; ///< Rezaktancja pętli zwarciowej fazy L1 z L2 (rejestracja)
+    float RL2L3m; ///< Rezystancja pętli zwarciowej fazy L2 z L3 (rejestracja)
+    float XL2L3m; ///< Rezaktancja pętli zwarciowej fazy L2 z L3 (rejestracja)
+    float RL3L1m; ///< Rezystancja pętli zwarciowej fazy L3 z L1 (rejestracja)
+    float XL3L1m; ///< Rezaktancja pętli zwarciowej fazy L3 z L1 (rejestracja)
+	short liczts[6][2]; ///<licznik czasu czas opoznienia dzialania strefy
+	short licz_WSPZ;
+	unsigned short stan_SPZ;
+	short licznik_SPZ; ///< licznik czasu do SPZ
+	short licznik1; ///< licznik czasu w SPZ
+	short licznik2; ///< licznik czasu w SPZ
+	short licznik_bl_SCH; ///< licznik do odliczania czasu oczekiwania na synchronizm
+	short licznik_ZZwa;///< licznik do automatyki załączenia na zwarcie
+	short licznik_PIU;///< licznik pobudzeń sprawdzania obecności napiecia i prądu
+//	Wyjscia_rejestratora Rej; ///< dane ostatniego zaklocenia
+//	Time czas_; // moment wystapienia zaklocenia (rejestr tymczasowy - przed zapisem)
+	unsigned int dl_; // dlugosc czasu trwania zaklocenia (rejestr tymczasowy - przed zapisem)
+	unsigned short bl_SPZ1;//blokowanie jednofazowego SPZ
+	u8 wsk_rej; // nowy zapis rejestracji parametrow zaklocenia (spelnienie kryterium identyfikacji)
+	u8 Pf[6][2]; // pobudzenia stref P[nr strefy][fazowe,miedzyfazowe]
+	u8 Pzf[6]; //pobudzenie stref
+	u8 P;// pobudzenie zbiorcze
+	u8 Zf[6][2]; // zadzialanie strefy
+	u8 Z[6]; // zadzialanie strefy
+	u8 Ws[6]; // wyłaczenie od strefy
+	u8 Zz; // Zadzialanie sygnal zbiorczy
+	u8 W; // wylaczenie sygnal zbiorczy
+	u8 W1; // wylaczenie faza L1
+	u8 W2; // wylaczenie faza L2
+	u8 W3; // wylaczenie faza L3
+	u8 R;//zwarcie z udziałem fazy L1
+	u8 S;//zwarcie z udziałem fazy L2
+	u8 T;//zwarcie z udziałem fazy L3
+	u8 Rbk;//zwarcie z udziałem fazy L1(bezkierunkowo)
+	u8 Sbk;//zwarcie z udziałem fazy L2(bezkierunkowo)
+	u8 Tbk;//zwarcie z udziałem fazy L3(bezkierunkowo)
+	u8 E;//zwarcie z udziałem ziemi
+	u8 jedfaz;//zwarcie jednofazowe
+	u8 blIo;//blokada zabezpieczenia ziemnozwarciowego od SPZ jednofazowego
+	u8 W_ON;//wyłącznik zamkniety
+	u8 W1_ON;//wyłącznik zamkniety faza L1
+	u8 W2_ON;//wyłącznik zamkniety faza L2
+	u8 W3_ON;//wyłącznik zamkniety faza L3
+	u8 W_OFF;//wyłącznik otwarty
+	u8 W1_OFF;//wyłącznik otwarty faza L1
+	u8 W2_OFF;//wyłącznik otwarty faza L2
+	u8 W3_OFF;//wyłącznik otwarty faza L3
+	u8 P_SPZD;//pobudzenie SPZ od odległościówki
+	u8 P_SPZ;//pobudzenie SPZ
+	u8 dBl_SPZ;//dopuszczenie działania automatyki SPZ
+	u8 WZ; //sygnalizacja udanego cyklu SPZ
+	u8 WZW; // sygnalizacja nieudanego cyklu SPZ
+	u8 WD; //wyłączenie definitywne
+	u8 tps_SPZ; // odliczanie czau potwierdzenia skuteczności SPZ
+	u8 t_bzn; // odliczanie czasu przerwy beznapięciowej
+	u8 bl_SPZ_SCH;//blokada załącz SPZ od automatyki kontroli synchronizmu lub braku gotowosci napędu
+	u8 ZZw; //aktywna automatyka załączenia na zwarcie
+	u8 ZZw_start; //spełnienie warunków uruchomienia automatyki załączenia na zwarcie
+	u8 ZZw_PIU; //pobudzenie kryterium napięcie/prąd zamknięcia wyłącznika
+	u8 bl_WSPZ;//zezwolenie na wyłącz od SPZ
+	u8 R1;
+	u8 S1;
+	u8 T1;
+	u8 W_1faz; // wyłaczenie jednofazowe
+	u8 ZZwP;//wyłączenie od automatyki załączenia na zwarcie
+};
+
+struct Nastawy_przeliczone_ZDistL
+{
+//	Adresy adr;
+
+	struct Wyjscie1_zdistl *COM1;
+	struct Wyjscie1_zdistl *COM2;
+	struct Wyjscie1_zdistl wy;
+
+	struct Wyjscia_ZDistA *ZdistA;
+
+	short ZZw_st; ///< strefa współpracy z automatyką załączenia na zwarcie
+	//short adr_PZZw;///< adres zmiennej pobudzenia strefy współpracujacej z automatyką ZZw
+	//short adr_ZZZw;///< adres zmiennej zadziałania strefy współpracujacej z automatyką ZZw
+	enum Wylaczenie SPZst1; ///< tryb pracy stopnia 1 w SPZ
+
+	short t_stf[6][2]; ///< czas dzialania strefy
+
+	short SPZilst;///< Ilość stopni automatyki SPZ
+
+	short tWSPZ;///< Czas wyłączenia niedefinitywnego
+	short tSPZ_1f;///< Czas przerwy beznapięciowej dla wyłączenia jednofazowego
+	short tSPZ_zr;///< Czas przerwy beznapięciowej dla zwarcia rozwojowego
+	short tSPZ_3f;///< Czas przerwy beznapięciowej dla wyłączenia trójfazowego
+	short tSPZ_st2;///< Czas przerwy beznapięciowej stopnia 2
+	short tSPZ_st3;///< Czas przerwy beznapięciowej stopnia 3
+	short tSPZ_st4;///< Czas przerwy beznapięciowej stopnia 4
+	short tSPZ_st5;///< Czas przerwy beznapięciowej stopnia 5
+	short tSPZow;///< Czas oczekiwania na otwarcie wyłacznika
+	short tSPZSCH;///< Czas oczekiwanie na zdjęcie blokady kontroli synchronizmu
+	short tSPZ_zal;///< Czas trwania impulsu załączającego
+	short tSPZ_bl;///< czas identyfikacji skuteczności SPZ
+
+	float ZZw_ta;///< Czas działania funkcji po zamknięciu wyłącznika
+	float ZZw_Ir;///< Prąd identyfikacji otwarcia wyłącznika
+	float ZZw_Ur;///< Napięcie identyfikacji otwarcia wyłacznika
+	short ZZw_to;///< Czas identyfikacji otwarcia wyłącznika
+
+	u8 SPZ_L1; ///< pobudzenie SPZ przez łącze kanał1
+	u8 SPZ_L2; ///< pobudzenie SPZ przez łącze kanał2
+	u8 SPZ_ON;
+	u8 SPZ_s[5];
+	u8 SPZ_zew;
+	u8 Bl_SCH;
+	u8 Bl_PS[6];
+	u8 Zbz[6][2]; ///< zadziałanie bezzwloczne strefy
+	u8 Stf_ON[6]; ///< wlaczenie/odstawienie strefy
+	u8 Stf_W[6]; ///< działanie na wylaczenie/sygnalizacje strefy
+	u8 Stf_WD[6]; ///< działanie na wylaczenie bez SPZ
+	u8 Stf_W_SPZ[6]; ///< działanie na wylaczenie z automatyką SPZ
+    u8 bl_; ///< wartosc nastawy aktywnosci blokady dzialania 1- blokada aktywna
+	u8 ZZw_ON; ///< włączenie automatyki załączenia na zwarcie
+};
+
+struct ZDistL_logic
+{
+    struct binary_io stan_bl;
+    struct Wyjscia_ZDistA *WE_Zdist;
+    struct Wyjscie1_zdistl *WE_L1;
+    struct Wyjscie1_zdistl *WE_L2;
+	struct binary_io Bl_PS;
+	struct binary_io Bl_Ufail;
+	struct binary_io Bl_SCH;
+	struct binary_io WM_OK;
+	struct binary_io W_ON_L1;
+	struct binary_io W_OFF_L1;
+	struct binary_io W_ON_L2;
+	struct binary_io W_OFF_L2;
+	struct binary_io W_ON_L3;
+	struct binary_io W_OFF_L3;
+	struct binary_io Start_SPZ;
+	struct binary_io BL_SPZ;
+	struct binary_io Z; ///< załączenie wyłącznika - uruchomienie automatyki załączenia na zwarcie
+	struct binary_io Kas_Syg;
+	struct binary_io test;
+
+    struct binary_io P;
+    struct binary_io P1W;
+    struct binary_io P1;
+    struct binary_io P2;
+    struct binary_io P3;
+    struct binary_io P4;
+    struct binary_io P5;
+	struct binary_io R;
+	struct binary_io S;
+	struct binary_io T;
+	struct binary_io E;
+    struct binary_io Z1W;
+    struct binary_io Z1;
+    struct binary_io Z2;
+    struct binary_io Z3;
+    struct binary_io Z4;
+    struct binary_io Z5;
+    struct binary_io W;
+    struct binary_io W1;
+    struct binary_io W2;
+    struct binary_io W3;
+    struct binary_io zal;
+	struct binary_io P_SPZ;
+    struct binary_io SPZ_P1;
+    struct binary_io SPZ_P2;
+    struct binary_io SPZ_P3;
+    struct binary_io SPZ_P4;
+    struct binary_io SPZ_P5;
+    struct binary_io WZ;
+    struct binary_io WZW;
+	struct binary_io WD;
+	struct binary_io err_SPZ;
+    struct binary_io SPZ_BlIo;
+	struct binary_io tps_SPZ;
+	struct binary_io t_bzn;
+
+	struct binary_io PZZw;
+	struct binary_io ZZZw;
+
+	struct Nastawy_przeliczone_ZDistL nast_;
+	struct dane_wewnetrzne_ZDistL dw;
+};
+
+struct ZDistL_io
+{
+	u32 stan_bl_in;
+	u32 we_zdist_ptr_in;
+	u32 we_l1_ptr_in;
+	u32 we_l2_ptr_in;
+	u32 bl_ps_in;
+	u32 bl_ufail_in;
+	u32 bl_sck_in;
+	u32 wm_ok_in;
+	u32 w_on_l1_in;
+	u32 w_off_l1_in;
+	u32 w_on_l2_in;
+	u32 w_off_l2_in;
+	u32 w_on_l3_in;
+	u32 w_off_l3_in;
+	u32 start_spz_in;
+	u32 bl_spz_in;
+	u32 z_in;
+	u32 kas_syg_in;
+	u32 test_in;
+
+	u32 p_out;
+	u32 p1w_out;
+	u32 p1_out;
+	u32 p2_out;
+	u32 p3_out;
+	u32 p4_out;
+	u32 p5_out;
+	u32 r_out;
+	u32 s_out;
+	u32 t_out;
+	u32 e_out;
+	u32 z1w_out;
+	u32 z1_out;
+	u32 z2_out;
+	u32 z3_out;
+	u32 z4_out;
+	u32 z5_out;
+	u32 w_out;
+	u32 w1_out;
+	u32 w2_out;
+	u32 w3_out;
+	u32 zal_out;
+	u32 p_spz_out;
+	u32 spz_p1_out;
+	u32 spz_p2_out;
+	u32 spz_p3_out;
+	u32 spz_p4_out;
+	u32 spz_p5_out;
+	u32 spz_wz_out;
+	u32 spz_wzw_out;
+	u32 wd_out;
+	u32 err_spz_out;
+	u32 spz1f_bli0_out;
+	u32 tps_SPZ_out;
+	u32 t_bzn_out;
+	u32 wyj_ptr_out;
+}__attribute__((__packed__));
+
+struct ZDistL_params
+{
+	long bity; ///< nastawy bitowe;
+	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
+	long SPZst1; ///< tryb pracy stopnia 1 w SPZ
+	long ZZw_st; ///< strefa współpracy z automatyką załączenia na zwarcie
+
+	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
+	double SPZilst;///< Ilość stopni automatyki SPZ
+	double tWSPZ;///< Czas wyłączenia niedefinitywnego
+	double tSPZ_1f;///< Czas przerwy beznapięciowej dla wyłączenia jednofazowego
+	double tSPZ_3f;///< Czas przerwy beznapięciowej dla wyłączenia trójfazowego
+	double tSPZ_zr;///< Czas przerwy beznapięciowej dla zwarcia rozwojowego
+	double tSPZ_st2;///< Czas przerwy beznapięciowej stopnia 2
+	double tSPZ_st3;///< Czas przerwy beznapięciowej stopnia 3
+	double tSPZ_st4;///< Czas przerwy beznapięciowej stopnia 4
+	double tSPZ_st5;///< Czas przerwy beznapięciowej stopnia 5
+	double tSPZow;///< Czas oczekiwania na otwarcie wyłacznika
+	double tSPZSCH;///< Czas oczekiwanie na zdjęcie blokady kontroli synchronizmu
+	double tSPZ_zal;///< Czas trwania impulsu załączającego
+	double tSPZCON;///< Czas oczekiwania na kontynuację cyklu
+	double ZZw_ta;///< Czas działania funkcji po zamknięciu wyłącznika
+	double ZZw_Ir;///< Prąd identyfikacji otwarcia wyłącznika
+	double ZZw_Ur;///< Napięcie identyfikacji otwarcia wyłacznika
+	double ZZw_to;///< Czas identyfikacji otwarcia wyłącznika
+}__attribute__((__packed__));
+
+struct ZDistL_args
+{
+	struct ZDistL_io io;
+	struct ZDistL_params params;
+//	u16 crc;
+}__attribute__((__packed__));
+
+extern void ZDistL(void *args, void *logic);
+extern void ZDistL_100hz(void *args, void *logic);
+extern int ZDistL_initlog(void *arguments, void *logic);
+
+#endif /* ZDISTL_H_ */

src/ZDistS.c

@@ -0,0 +1,599 @@
+/*
+ * ZDistS.c
+ *
+ *  Created on: 16-03-2017
+ *      Author: Krzysztof Jakubczyk
+ */
+
+#include <math.h>
+
+#include "tdefs.h"
+#include "misc.h"
+
+#include "helper.h"
+#include "ZDistS.h"
+#include "ZDistA.h"
+
+struct ZDistS_nast
+{
+	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 ZDistS_initlog(void *arguments, void *logic)
+{
+	struct ZDistS_args *args = (struct ZDistS_args *)arguments;
+	struct ZDistS_logic *log = (struct ZDistS_logic *)logic;
+	struct ZDistS_nast snast;
+
+	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_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.z_in,&log->Z))
+		return -1;
+	if(set_bit_ptr_struct(args->io.w_on_in,&log->W_ON))
+		return -1;
+	if(set_bit_ptr_struct(args->io.w_off_in,&log->W_OFF))
+		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.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.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;
+
+	log->nast_.Bl_PS[0] = (args->params.bity & 0x0001)?1:0;
+	log->nast_.Bl_PS[1] = (args->params.bity & 0x0002)?1:0;
+	log->nast_.Bl_PS[2] = (args->params.bity & 0x0004)?1:0;
+	log->nast_.Bl_PS[3] = (args->params.bity & 0x0008)?1:0;
+	log->nast_.Bl_PS[4] = (args->params.bity & 0x0010)?1:0;
+	log->nast_.ZZw_ON = (args->params.bity & 0x0020)?1:0;
+	log->nast_.bl_ = (args->params.bity & 0x0040)?1:0;
+
+	log->nast_.ZdistA = log->WE_Zdist;
+
+	uint16_t i;
+	int16_t temp_ti;
+	float temp_tf;
+
+	for (i=0;i<10;i++)
+	{
+		switch(i)
+		{
+		case 0:
+			 temp_tf = args->params.ts1LE;
+			 break;
+		case 1:
+			 temp_tf = args->params.ts1LL;
+			 break;
+		case 2:
+			 temp_tf = args->params.ts2LE;
+			 break;
+		case 3:
+			 temp_tf = args->params.ts2LL;
+			 break;
+		case 4:
+			 temp_tf = args->params.ts3LE;
+			 break;
+		case 5:
+			 temp_tf = args->params.ts3LL;
+			 break;
+		case 6:
+			 temp_tf = args->params.ts4LE;
+			 break;
+		case 7:
+			 temp_tf = args->params.ts4LL;
+			 break;
+		case 8:
+			 temp_tf = args->params.ts5LE;
+			 break;
+		case 9:
+			 temp_tf = args->params.ts6LL;
+			 break;
+		default:
+			 temp_tf = args->params.ts1LE;
+			 break;
+
+		}
+
+		//przeliczenie czasow stref
+		temp_ti = (100 * (temp_tf - 0.005f));
+
+		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_.ZZw_st = args->params.ZZw_st + 1;
+
+	switch(log->nast_.ZZw_st)
+	{
+		case 0:
+			log->PZZw=log->P1;
+			log->ZZZw=log->Z1;
+			break;
+		case 1:
+			log->PZZw=log->P2;
+			log->ZZZw=log->Z2;
+			break;
+		case 2:
+			log->PZZw=log->P3;
+			log->ZZZw=log->Z3;
+			break;
+		case 3:
+			log->PZZw=log->P4;
+			log->ZZZw=log->Z4;
+			break;
+		case 4:
+			log->PZZw=log->P5;
+			log->ZZZw=log->Z5;
+			break;
+		default:
+			log->PZZw=log->P1;
+			log->ZZZw=log->Z1;
+			break;
+	}
+
+
+
+	snast.Stf1=args->params.Stf1;
+	snast.Stf2=args->params.Stf2;
+	snast.Stf3=args->params.Stf3;
+	snast.Stf4=args->params.Stf4;
+	snast.Stf5=args->params.Stf5;
+
+	long *temp_e = &snast.Stf1;
+
+	for (i=0;i<5;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_.ZZw_ta = (int16_t)(100 * (args->params.ZZw_ta + 0.005f));
+	log->nast_.ZZw_to = (int16_t)(100 * (args->params.ZZw_to + 0.005f));
+
+	log->nast_.ZZw_Ir = args->params.ZZw_Ir * args->params.ZZw_Ir;
+	log->nast_.ZZw_Ur = args->params.ZZw_Ur * args->params.ZZw_Ur;
+
+	return 0;
+}
+
+/**
+Funkcja okraœlania petli zwarciwej przy wy³aczeniu
+\param nr_strefy - numer strefy wy³aczaj¹cej
+*/
+void wybiornik_f_ZDistS(struct ZDistS_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;
+
+}
+
+/**
+Funkcja okraœlania petli zwarciwej przy wy³aczeniu - dzia³anie bezkierunkowe
+\param nr_strefy - numer strefy wy³aczaj¹cej
+*/
+void wybiornik_fbk_ZDistS(struct ZDistS_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 ZDistS(void *arguments, void *logic)
+{
+	struct ZDistS_logic *log = (struct ZDistS_logic *)logic;
+
+	uint16_t i;
+	log->dw.P = 0;
+	log->dw.Zz = 0;
+
+	u8 temp_Bl,temp_Zezwolenie;
+
+	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<5;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] = check_struct(&log->test) && temp_Zezwolenie;
+					}
+					else
+					{
+
+						//ustawienie pobudzen
+						log->dw.Pf[i][0] = (log->nast_.ZdistA->Zdist_dw->P[i+1][0] ||
+													log->nast_.ZdistA->Zdist_dw->P[i+1][1] ||
+																	log->nast_.ZdistA->Zdist_dw->P[i+1][2])
+																		&& temp_Zezwolenie;
+						log->dw.Pf[i][1] = (log->nast_.ZdistA->Zdist_dw->P[i+1][3] ||
+													log->nast_.ZdistA->Zdist_dw->P[i+1][4] ||
+																	log->nast_.ZdistA->Zdist_dw->P[i+1][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_W[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
+				if(!log->dw.W)
+				{
+					log->dw.W |= log->dw.Ws[i];
+					if(log->dw.W)
+					{
+						wybiornik_f_ZDistS(log,i+1);
+					}
+				}
+			}
+
+			//-------------------------------------------------------------------------------------------------------
+			//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_ZDistS(log,log->nast_.ZZw_st);
+
+				if (log->dw.Rbk || log->dw.Sbk || log->dw.Tbk)
+				{
+					log->dw.W |= 1;
+					log->dw.ZZwP = 1;
+				} else log->dw.ZZwP = 0;
+
+
+			} else {
+				log->dw.Rbk = log->dw.Sbk = log->dw.Tbk = 0;
+				log->dw.ZZwP = 0;
+			}
+
+
+			//-------------------------------------------------------------------------------------------------------
+
+
+
+
+			//-------------------------------------------------------------------------------------------------------
+
+			//wyprowadzenie wyjϾ
+			check_and_set_struct(log->dw.P,&log->P);
+			check_and_set_struct(log->dw.Pzf[0],&log->P1);
+			check_and_set_struct(log->dw.Pzf[1],&log->P2);
+			check_and_set_struct(log->dw.Pzf[2],&log->P3);
+			check_and_set_struct(log->dw.Pzf[3],&log->P4);
+			check_and_set_struct(log->dw.Pzf[4],&log->P5);
+
+			check_and_set_struct(log->dw.Z[0],&log->Z1);
+			check_and_set_struct(log->dw.Z[1],&log->Z2);
+			check_and_set_struct(log->dw.Z[2],&log->Z3);
+			check_and_set_struct(log->dw.Z[3],&log->Z4);
+			check_and_set_struct(log->dw.Z[4],&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);
+
+			if(log->dw.ZZwP)
+			{
+				set_struct(&log->PZZw);
+				set_struct(&log->ZZZw);
+			}
+		} else {
+			clear_struct(&log->P);
+			clear_struct(&log->P1);
+			clear_struct(&log->P2);
+			clear_struct(&log->P3);
+			clear_struct(&log->P4);
+			clear_struct(&log->P5);
+
+			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);
+		}
+}
+
+void ZDistS_100hz(void *arguments, void *logic)
+{
+	struct ZDistS_logic *log = (struct ZDistS_logic *)logic;
+	unsigned short i;
+	u8 tempbool = 0;
+
+
+		if (*log->nast_.ZdistA->on)
+		{
+
+			//wczytanie danych o stanie wy³¹cznika
+			log->dw.W_ON = check_struct(&log->W_ON) && !check_struct(&log->W_OFF);
+			log->dw.W_OFF = !check_struct(&log->W_ON) && check_struct(&log->W_OFF);
+
+
+			for (i=0;i<5;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;
+					}
+
+				}
+				//-----------------------------------------------------------
+			}
+
+			//odpad wy³aczeñ
+
+
+
+			for(i=0;i<5;i++)
+			{
+				tempbool |= log->dw.Ws[i];
+			}
+			if (!tempbool) log->dw.W = log->dw.R = log->dw.S = log->dw.T = log->dw.E = 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); //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.W)
+							{
+								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 {
+
+		}
+
+}

src/ZDistS.h

@@ -0,0 +1,185 @@
+/*
+ * ZDistL.h
+ *
+ *
+ *  Created on: 16-03-2017
+ *      Author: KJ
+ */
+
+#ifndef ZDISTS_H_
+#define ZDISTS_H_
+
+#include "tdefs.h"
+#include "helper.h"
+
+	struct Nastawy_przeliczone_ZDistS
+    {
+		struct Wyjscia_ZDistA *ZdistA;
+
+		unsigned short ZZw_st; ///< strefa współpracy z automatyką załączenia na zwarcie
+		unsigned short adr_PZZw;///< adres zmiennej pobudzenia strefy współpracujacej z automatyką ZZw
+		unsigned short adr_ZZZw;///< adres zmiennej zadziałania strefy współpracujacej z automatyką ZZw
+
+		short t_stf[5][2]; ///< czas dzialania strefy
+
+
+		float ZZw_ta;///< Czas działania funkcji po zamknięciu wyłącznika
+		float ZZw_Ir;///< Prąd identyfikacji otwarcia wyłącznika
+		float ZZw_Ur;///< Napięcie identyfikacji otwarcia wyłacznika
+		short ZZw_to;///< Czas identyfikacji otwarcia wyłącznika
+
+		u8 Bl_PS[5];
+		u8 Zbz[5][2]; ///< zadziałanie bezzwloczne strefy
+		u8 Stf_ON[5]; ///< wlaczenie/odstawienie strefy
+		u8 Stf_W[5]; ///< działanie na wylaczenie/sygnalizacje strefy
+        u8 bl_; ///< wartosc nastawy aktywnosci blokady dzialania 1- blokada aktywna
+		u8 ZZw_ON; ///< włączenie automatyki załączenia na zwarcie
+    };
+
+
+	struct dane_wewnetrzne_ZDistS
+	{
+        float RL1Em; ///< Rezystancja pętli zwarciowej fazy L1 z ziemia (rejestracja)
+        float XL1Em; ///< Rezaktancja pętli zwarciowej fazy L1 z ziemia (rejestracja)
+        float RL2Em; ///< Rezystancja pętli zwarciowej fazy L2 z ziemia (rejestracja)
+        float XL2Em; ///< Rezaktancja pętli zwarciowej fazy L2 z ziemia (rejestracja)
+        float RL3Em; ///< Rezystancja pętli zwarciowej fazy L3 z ziemia (rejestracja)
+        float XL3Em; ///< Rezaktancja pętli zwarciowej fazy L3 z ziemia (rejestracja)
+        float RL1L2m; ///< Rezystancja pętli zwarciowej fazy L1 z L2 (rejestracja)
+        float XL1L2m; ///< Rezaktancja pętli zwarciowej fazy L1 z L2 (rejestracja)
+        float RL2L3m; ///< Rezystancja pętli zwarciowej fazy L2 z L3 (rejestracja)
+        float XL2L3m; ///< Rezaktancja pętli zwarciowej fazy L2 z L3 (rejestracja)
+        float RL3L1m; ///< Rezystancja pętli zwarciowej fazy L3 z L1 (rejestracja)
+        float XL3L1m; ///< Rezaktancja pętli zwarciowej fazy L3 z L1 (rejestracja)
+		short liczts[5][2]; ///<licznik czasu czas opoznienia dzialania strefy
+		short licznik_ZZwa;///< licznik do automatyki załączenia na zwarcie
+		short licznik_PIU;///< licznik pobudzeń sprawdzania obecności napiecia i prądu
+		//Wyjscia_rejestratora Rej; ///< dane ostatniego zaklocenia
+		//Time czas_; // moment wystapienia zaklocenia (rejestr tymczasowy - przed zapisem)
+		u32 dl_; // dlugosc czasu trwania zaklocenia (rejestr tymczasowy - przed zapisem)
+		u8 wsk_rej; // nowy zapis rejestracji parametrow zaklocenia (spelnienie kryterium identyfikacji)
+		u8 Pf[5][2]; // pobudzenia stref P[nr strefy][fazowe,miedzyfazowe]
+		u8 Pzf[5]; //pobudzenie stref
+		u8 P;// pobudzenie zbiorcze
+		u8 Zf[5][2]; // zadzialanie strefy
+		u8 Z[5]; // zadzialanie strefy
+		u8 Ws[5]; // wyłaczenie od strefy
+		u8 Zz; // Zadzialanie sygnal zbiorczy
+		u8 W; // wylaczenie sygnal zbiorczy
+		u8 R;//zwarcie z udziałem fazy L1
+		u8 S;//zwarcie z udziałem fazy L2
+		u8 T;//zwarcie z udziałem fazy L3
+		u8 Rbk;//zwarcie z udziałem fazy L1(bezkierunkowo)
+		u8 Sbk;//zwarcie z udziałem fazy L2(bezkierunkowo)
+		u8 Tbk;//zwarcie z udziałem fazy L3(bezkierunkowo)
+		u8 E;//zwarcie z udziałem ziemi
+		u8 W_ON;//wyłącznik zamkniety
+		u8 W_OFF;//wyłącznik otwarty
+		u8 ZZw; //aktywna automatyka załączenia na zwarcie
+		u8 ZZw_start; //spełnienie warunków uruchomienia automatyki załączenia na zwarcie
+		u8 ZZw_PIU; //pobudzenie kryterium napięcie/prąd zamknięcia wyłącznika
+		u8 ZZwP;//wyłączenie od automatyki załączenia na zwarcie
+	};
+
+struct ZDistS_logic
+{
+    struct binary_io stan_bl;
+    struct Wyjscia_ZDistA *WE_Zdist;
+	struct binary_io Bl_PS;
+	struct binary_io Bl_Ufail;
+	struct binary_io Z;
+	struct binary_io W_ON;
+	struct binary_io W_OFF;
+	struct binary_io test;
+
+	struct binary_io P;
+    struct binary_io P1;
+    struct binary_io P2;
+    struct binary_io P3;
+    struct binary_io P4;
+    struct binary_io P5;
+	struct binary_io R;
+	struct binary_io S;
+	struct binary_io T;
+	struct binary_io E;
+    struct binary_io Z1;
+    struct binary_io Z2;
+    struct binary_io Z3;
+    struct binary_io Z4;
+    struct binary_io Z5;
+    struct binary_io W;
+
+    struct binary_io PZZw;
+	struct binary_io ZZZw;
+
+	struct Nastawy_przeliczone_ZDistS nast_;
+	struct dane_wewnetrzne_ZDistS dw;
+};
+
+struct ZDistS_io
+{
+	u32 stan_bl_in;
+	u32 we_zdist_ptr_in;
+	u32 bl_ps_in;
+	u32 bl_ufail_in;
+	u32 z_in;
+	u32 w_on_in;
+	u32 w_off_in;
+	u32 test_in;
+
+	u32 p_out;
+	u32 p1_out;
+	u32 p2_out;
+	u32 p3_out;
+	u32 p4_out;
+	u32 p5_out;
+	u32 r_out;
+	u32 s_out;
+	u32 t_out;
+	u32 e_out;
+	u32 z1_out;
+	u32 z2_out;
+	u32 z3_out;
+	u32 z4_out;
+	u32 z5_out;
+	u32 w_out;
+}__attribute__((__packed__));
+
+struct ZDistS_params
+{
+	u32 bity; ///< nastawy bitowe;
+	u32 Stf1; ///< Sposób działania strefy 1
+	u32 Stf2; ///< Sposób działania strefy 2
+	u32 Stf3; ///< Sposób działania strefy 3
+	u32 Stf4; ///< Sposób działania strefy 4
+	u32 Stf5; ///< Sposób działania strefy 5
+	u32 ZZw_st; ///< strefa współpracy z automatyką załączenia na zwarcie
+
+	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 ts6LL;///< Czas wyłączenia strefy 5 zwarcia miedzyfazowe
+	double ZZw_ta;///< Czas działania funkcji po zamknięciu wyłącznika
+	double ZZw_Ir;///< Prąd identyfikacji otwarcia wyłącznika
+	double ZZw_Ur;///< Napięcie identyfikacji otwarcia wyłacznika
+	double ZZw_to;///< Czas identyfikacji otwarcia wyłącznika
+}__attribute__((__packed__));
+
+struct ZDistS_args
+{
+	struct ZDistS_io io;
+	struct ZDistS_params params;
+//	u16 crc;
+}__attribute__((__packed__));
+
+extern void ZDistS(void *args, void *logic);
+extern void ZDistS_100hz(void *args, void *logic);
+extern int ZDistS_initlog(void *arguments, void *logic);
+
+#endif /* ZDISTS_H_ */

src/an_gen.c

@@ -0,0 +1,60 @@
+/*
+ * an_gen.c
+ *
+ *  Created on: 19-07-2017
+ *      Author: KJ
+ */
+
+
+#include "tdefs.h"
+#include "misc.h"
+#include <math.h>
+
+#include "an_gen.h"
+#include "analog_in.h"
+#include "dev_ctrl.h"
+#include "elements.h"
+#include "config.h"
+#include <ti/sysbios/hal/Hwi.h>
+
+//u16 bus_an_samples_buf_force[MAX_AN_CARDS][4][4];
+
+#define SAMPLE_STEP	(50.0f/(SAMPLES_PER_MS*1000.0f))
+
+struct an_gen_force_params genpar;
+u8 an_gen_buf_ready = 0;
+
+int an_gen_initlog(void *arguments, void *logic)
+{
+	return 0;
+}
+
+void an_gen(void *arguments, void *logic)
+{
+	int i,j;
+	u8 an_gen_sample_num;
+
+	if(!(dev_ctrl_state & DEV_CTRL_STATE_TEST_AN) || !genpar.an_force_mask)
+	{
+		an_gen_buf_ready=0;
+		return;
+	}
+
+	UInt key = Hwi_disable();
+
+	an_gen_sample_num=bus_an_cur_sample_num+(SAMPLES_PER_MS*LOOP_CYCLE_MS);
+	an_gen_sample_num%=(SAMPLES_PER_MS*MAIN_FREQ_PERIOD_MS*2);
+
+	for(j=0;j<(SAMPLES_PER_MS*LOOP_CYCLE_MS);j++)
+	{
+		for(i=0;i<=(MAX_AN_CARDS/2 * 4);i++)
+			if(genpar.an_force_mask & (1<<i))
+				bus_an_samples_buf[i>>2][i%4][an_gen_sample_num] = (u16)(genpar.an_force_amp[i/4][i%4] * sinf(2 * PI * SAMPLE_STEP * (bus_an_cur_timestamp+(SAMPLES_PER_MS*LOOP_CYCLE_MS)+j) + genpar.an_force_ph[i/4][i%4]) + 32768);
+
+		an_gen_sample_num++;
+		an_gen_sample_num%=(SAMPLES_PER_MS*MAIN_FREQ_PERIOD_MS*2);
+	}
+
+	an_gen_buf_ready=1;
+	Hwi_restore(key);
+}

src/an_gen.h

@@ -0,0 +1,50 @@
+/*
+ * an_gen.h
+ *
+ *
+ *  Created on: 19-07-2017
+ *      Author: KJ
+ */
+
+#ifndef AN_GEN_H_
+#define AN_GEN_H_
+
+#include "tdefs.h"
+#include "misc.h"
+#include "an_gen.h"
+
+struct an_gen_logic
+{
+//	u16 an_count;
+//	u16 element_num[];
+};
+
+struct an_gen_io
+{
+}__attribute__((__packed__));
+
+struct an_gen_params
+{
+}__attribute__((__packed__));
+
+struct an_gen_args
+{
+	struct an_gen_io io;
+	struct an_gen_params params;
+//	u16 crc;
+}__attribute__((__packed__));
+
+struct an_gen_force_params
+{
+	u32 an_force_mask;
+	u16 an_force_amp[MAX_AN_CARDS/2][4];
+	float an_force_ph[MAX_AN_CARDS/2][4];
+} __attribute__((__packed__));
+
+extern struct an_gen_force_params genpar;
+extern u8 an_gen_buf_ready;
+
+extern int an_gen_initlog(void *args, void *logic);
+extern void an_gen(void *args, void *logic);
+
+#endif /* AN_GEN_H_ */

src/analog_in.c

@@ -0,0 +1,90 @@
+/*
+ * analog_in.c
+ *
+ *  Created on: 06-05-2014
+ *      Author: Krzysztof Jakubczyk
+ */
+
+#include "tdefs.h"
+#include "misc.h"
+
+#include "analog_in.h"
+
+int analog_in_initlog(void *arguments, void *logic)
+{
+	struct analog_in_args *args = (struct analog_in_args *)arguments;
+	struct analog_in_logic *log = (struct analog_in_logic *)logic;
+	u32 *params_ptr;
+	u32 *samples_buf_ptr;
+
+	log->kob_ptr = log_manager.nets_data + (args->io.kob_out >> 3);
+	log->kob_bit_no = args->io.kob_out & 0x07;
+
+	if(log->kob_ptr >= (log_manager.nets_data+sizeof(log_manager.nets_data)))
+		return -1;
+
+	log->cur_sample_ptr = (float *)(log_manager.nets_data + (args->io.sample_float_out >> 3));
+	if((u8*)log->cur_sample_ptr > (log_manager.nets_data+sizeof(log_manager.nets_data)-sizeof(float)))
+		return -1;
+
+	log->raw_sample_ptr = (short *)(log_manager.nets_data + (args->io.sample_raw_short_out >> 3));
+	if((u8*)log->raw_sample_ptr > (log_manager.nets_data+sizeof(log_manager.nets_data)-sizeof(short)))
+		return -1;
+
+	params_ptr = (u32 *)(log_manager.nets_data+(args->io.params_ptr_out>>3));
+
+	if((u8 *)params_ptr > (log_manager.nets_data+sizeof(log_manager.nets_data)-sizeof(void *)) )
+		return -1;
+
+	*params_ptr = (u32)&log->params_ext;//args->params;
+
+	if(args->params.card_addr>(MAX_AN_CARDS-1))
+		return -1;
+
+	if(args->params.phase_num>3)
+		return -1;
+
+	samples_buf_ptr = (u32 *)(log_manager.nets_data+(args->io.samples_buf_ptr_out>>3));
+
+	if((u8 *)samples_buf_ptr > (log_manager.nets_data+sizeof(log_manager.nets_data)-sizeof(void *)) )
+		return -1;
+
+	*samples_buf_ptr = (u32)&bus_an_samples_buf[args->params.card_addr][args->params.phase_num][0];
+
+	if(args->params.bits & ANALOG_NEGATION)
+		bus_an_samples_neg[args->params.card_addr][args->params.phase_num]=1;
+	else
+		bus_an_samples_neg[args->params.card_addr][args->params.phase_num]=0;
+
+	log->params_ext.bits=args->params.bits;
+	log->params_ext.card_addr=args->params.card_addr;
+	log->params_ext.jednostka=args->params.jednostka;
+	log->params_ext.multiplier=args->params.multiplier;
+	log->params_ext.offset=args->params.offset;
+	log->params_ext.phase_num=args->params.phase_num;
+	log->params_ext.znam_wtor=args->params.znam_wtor;
+	log->params_ext.znam_pierw=args->params.znam_pierw;
+	log->params_ext.nast.offset=args->params.offset;
+	log->params_ext.nast.mnoznik=args->params.multiplier;
+	//nast.offset = n.korekcja_offsetu * 32767 / n.zasieg / 1.4142136f;
+	//nast.mnoznik = 1.4142136f * n.korekcja_ampl * n.zasieg / 32767;
+
+	return 0;
+}
+
+void analog_in(void *arguments, void *logic)
+{
+	struct analog_in_args *args = (struct analog_in_args *)arguments;
+	struct analog_in_logic *log = (struct analog_in_logic *)logic;
+	//u16 sample;
+	short sample;
+
+	if(ic->kob_an & (1<<args->params.card_addr))
+		*log->kob_ptr|=(1<<log->kob_bit_no);
+	else
+		*log->kob_ptr&=~(1<<log->kob_bit_no);
+
+	sample = bus_an_samples_buf[args->params.card_addr][args->params.phase_num][bus_an_cur_sample_num] - 0x7FFF;
+	*log->cur_sample_ptr=((float)sample - args->params.offset ) * args->params.multiplier;
+	*log->raw_sample_ptr=sample;
+}

src/analog_in.h

@@ -0,0 +1,77 @@
+/*
+ * analog_in.h
+ *
+ *  Created on: 06-05-2014
+ *      Author: Krzysztof Jakubczyk
+ */
+
+#ifndef ANALOG_IN_H_
+#define ANALOG_IN_H_
+
+#include "tdefs.h"
+
+	struct Nastawa_przeliczona_analog_in
+	{
+		float mnoznik;///< stala przeliczenia int na float z korekcja wzmocnienia
+		float offset; ///< wartosc korekcji przesuniecia skladowej stalej
+	};
+
+	struct analog_in_params_extended
+	{
+		u32 card_addr;
+		u32 phase_num;
+		double offset;
+		double multiplier;
+	    double znam_wtor; ///< watosc znamionowa wtorna
+	    double znam_pierw; ///< wartosc znamionowa pierwotna
+	    long jednostka;
+	    u32 bits;
+	    struct Nastawa_przeliczona_analog_in nast;
+	}__attribute__((__packed__));
+
+struct analog_in_logic
+{
+	u8 *kob_ptr;
+	u8 kob_bit_no;
+	float *cur_sample_ptr;
+	short *raw_sample_ptr;
+	struct analog_in_params_extended params_ext;
+};
+
+struct analog_in_io
+{
+	u32 sample_float_out;
+	u32 samples_buf_ptr_out;
+	u32 params_ptr_out;
+	u32 sample_raw_short_out;
+	u32 kob_out;
+}__attribute__((__packed__));
+
+
+struct analog_in_params
+{
+	u32 card_addr;
+	u32 phase_num;
+	double offset;
+	double multiplier;
+    double znam_wtor; ///< watosc znamionowa wtorna
+    double znam_pierw; ///< wartosc znamionowa pierwotna
+    long jednostka;
+    u32 bits;
+}__attribute__((__packed__));
+
+
+//bits
+#define ANALOG_NEGATION	0x01
+
+struct analog_in_args
+{
+	struct analog_in_io io;
+	struct analog_in_params params;
+//	u16 crc;
+}__attribute__((__packed__));
+
+extern void analog_in(void *args, void *logic);
+extern int analog_in_initlog(void *arguments, void *logic);
+
+#endif /* ANALOG_IN_H_ */

src/and.c

@@ -0,0 +1,49 @@
+/*
+ * nand.c
+ *
+ *  Created on: 29-04-2014
+ *      Author: KJ
+ */
+
+
+#include "tdefs.h"
+#include "misc.h"
+
+#include "and.h"
+
+int and_initlog(void *arguments, void *logic)
+{
+	struct and_args *args = (struct and_args *)arguments;
+	struct and_logic *log = (struct and_logic *)logic;
+
+	log->out_ptr = log_manager.nets_data + (args->io.out >> 3);
+	log->out_bit_mask = 1<<(args->io.out & 0x07);
+
+	log->in1_ptr = log_manager.nets_data + (args->io.in1 >> 3);
+	log->in1_bit_mask = 1<<(args->io.in1 & 0x07);
+
+	log->in2_ptr = log_manager.nets_data + (args->io.in2 >> 3);
+	log->in2_bit_mask = 1<<(args->io.in2 & 0x07);
+
+	if(log->out_ptr >= (log_manager.nets_data+sizeof(log_manager.nets_data)))
+		return -1;
+
+	if(log->in1_ptr >= (log_manager.nets_data+sizeof(log_manager.nets_data)))
+		return -1;
+
+	if(log->in2_ptr >= (log_manager.nets_data+sizeof(log_manager.nets_data)))
+		return -1;
+
+	return 0;
+}
+
+void and(void *arguments, void *logic)
+{
+//	struct and_args *args = (struct and_args *)arguments;
+	struct and_logic *log = (struct and_logic *)logic;
+
+	if((*log->in1_ptr & log->in1_bit_mask) &&  (*log->in2_ptr & log->in2_bit_mask))
+		*log->out_ptr|=log->out_bit_mask;
+	else
+		*log->out_ptr&=~log->out_bit_mask;
+}

src/and.h

@@ -0,0 +1,46 @@
+/*
+ * nand.h
+ *
+ *  Created on: 29-04-2014
+ *      Author: KJ
+ */
+
+#ifndef AND_H_
+#define AND_H_
+
+#include "tdefs.h"
+
+struct and_logic
+{
+	u8 *out_ptr;
+	u8 out_bit_mask;
+
+	u8 *in1_ptr;
+	u8 in1_bit_mask;
+
+	u8 *in2_ptr;
+	u8 in2_bit_mask;
+};
+
+struct and_io
+{
+	u32 in1;
+	u32 in2;
+	u32 out;
+}__attribute__((__packed__));
+
+struct and_params
+{
+}__attribute__((__packed__));
+
+struct and_args
+{
+	struct and_io io;
+	struct and_params params;
+//	u16 crc;
+}__attribute__((__packed__));
+
+extern void and(void *args, void *logic);
+extern int and_initlog(void *args, void *logic);
+
+#endif /* AND_H_ */

src/and4.c

@@ -0,0 +1,46 @@
+/*
+ * and4.c
+ *
+ *  Created on: 15-02-2017
+ *      Author: Krzysztof Jakubczyk
+ */
+
+#include <math.h>
+
+#include "tdefs.h"
+#include "misc.h"
+
+#include "helper.h"
+#include "and4.h"
+
+int and4_initlog(void *arguments, void *logic)
+{
+	struct and4_args *args = (struct and4_args *)arguments;
+	struct and4_logic *log = (struct and4_logic *)logic;
+
+	if(set_bit_ptr_mask(args->io.in1_in,&log->in[0],&log->in_bit_mask[0]))
+		return -1;
+	if(set_bit_ptr_mask(args->io.in2_in,&log->in[1],&log->in_bit_mask[1]))
+		return -1;
+	if(set_bit_ptr_mask(args->io.in3_in,&log->in[2],&log->in_bit_mask[2]))
+		return -1;
+	if(set_bit_ptr_mask(args->io.in4_in,&log->in[3],&log->in_bit_mask[3]))
+		return -1;
+	if(set_bit_ptr_mask(args->io.out_out,&log->out,&log->out_bit_mask))
+		return -1;
+
+
+	return 0;
+}
+
+void and4(void *arguments, void *logic)
+{
+	struct and4_logic *log = (struct and4_logic *)logic;
+	u8 i;
+
+	for(i=0;i<4;i++)
+		if(!(*log->in[i] & log->in_bit_mask[i]))
+			break;
+
+	check_and_set_mask(i>=4,log->out,log->out_bit_mask);
+}

src/and4.h

@@ -0,0 +1,45 @@
+/*
+ * and4.h
+ *
+ *  Created on: 15-02-2017
+ *      Author: Krzysztof Jakubczyk
+ */
+
+#ifndef AND4_H_
+#define AND4_H_
+
+#include "tdefs.h"
+
+struct and4_logic
+{
+	u8 *in[4];
+	u8 in_bit_mask[4];
+
+	u8 *out;
+	u8 out_bit_mask;
+};
+
+struct and4_io
+{
+	u32 in1_in;
+	u32 in2_in;
+	u32 in3_in;
+	u32 in4_in;
+	u32 out_out;
+}__attribute__((__packed__));
+
+struct and4_params
+{
+}__attribute__((__packed__));
+
+struct and4_args
+{
+	struct and4_io io;
+	struct and4_params params;
+//	u16 crc;
+}__attribute__((__packed__));
+
+extern void and4(void *args, void *logic);
+extern int and4_initlog(void *arguments, void *logic);
+
+#endif /* AND4_H_ */

src/and8.c

@@ -0,0 +1,54 @@
+/*
+ * and8.c
+ *
+ *  Created on: 15-02-2017
+ *      Author: Krzysztof Jakubczyk
+ */
+
+#include <math.h>
+
+#include "tdefs.h"
+#include "misc.h"
+
+#include "helper.h"
+#include "and8.h"
+
+int and8_initlog(void *arguments, void *logic)
+{
+	struct and8_args *args = (struct and8_args *)arguments;
+	struct and8_logic *log = (struct and8_logic *)logic;
+
+	if(set_bit_ptr_mask(args->io.in1_in,&log->in[0],&log->in_bit_mask[0]))
+		return -1;
+	if(set_bit_ptr_mask(args->io.in2_in,&log->in[1],&log->in_bit_mask[1]))
+		return -1;
+	if(set_bit_ptr_mask(args->io.in3_in,&log->in[2],&log->in_bit_mask[2]))
+		return -1;
+	if(set_bit_ptr_mask(args->io.in4_in,&log->in[3],&log->in_bit_mask[3]))
+		return -1;
+	if(set_bit_ptr_mask(args->io.in5_in,&log->in[4],&log->in_bit_mask[4]))
+		return -1;
+	if(set_bit_ptr_mask(args->io.in6_in,&log->in[5],&log->in_bit_mask[5]))
+		return -1;
+	if(set_bit_ptr_mask(args->io.in7_in,&log->in[6],&log->in_bit_mask[6]))
+		return -1;
+	if(set_bit_ptr_mask(args->io.in8_in,&log->in[7],&log->in_bit_mask[7]))
+		return -1;
+	if(set_bit_ptr_mask(args->io.out_out,&log->out,&log->out_bit_mask))
+		return -1;
+
+
+	return 0;
+}
+
+void and8(void *arguments, void *logic)
+{
+	struct and8_logic *log = (struct and8_logic *)logic;
+	u8 i;
+
+	for(i=0;i<8;i++)
+		if(!(*log->in[i] & log->in_bit_mask[i]))
+			break;
+
+	check_and_set_mask(i>=8,log->out,log->out_bit_mask);
+}

src/and8.h

@@ -0,0 +1,49 @@
+/*
+ * and8.h
+ *
+ *  Created on: 15-02-2017
+ *      Author: Krzysztof Jakubczyk
+ */
+
+#ifndef AND8_H_
+#define AND8_H_
+
+#include "tdefs.h"
+
+struct and8_logic
+{
+	u8 *in[8];
+	u8 in_bit_mask[8];
+
+	u8 *out;
+	u8 out_bit_mask;
+};
+
+struct and8_io
+{
+	u32 in1_in;
+	u32 in2_in;
+	u32 in3_in;
+	u32 in4_in;
+	u32 in5_in;
+	u32 in6_in;
+	u32 in7_in;
+	u32 in8_in;
+	u32 out_out;
+}__attribute__((__packed__));
+
+struct and8_params
+{
+}__attribute__((__packed__));
+
+struct and8_args
+{
+	struct and8_io io;
+	struct and8_params params;
+//	u16 crc;
+}__attribute__((__packed__));
+
+extern void and8(void *args, void *logic);
+extern int and8_initlog(void *arguments, void *logic);
+
+#endif /* AND8_H_ */

src/bank_sel.c

@@ -0,0 +1,98 @@
+/*
+ * bank_sel.c
+ *
+ *  Created on: 13-12-2016
+ *      Author: KJ
+ */
+
+
+
+#include "tdefs.h"
+#include "misc.h"
+#include "helper.h"
+#include "bank_sel.h"
+#include "comm.h"
+#include "config.h"
+
+#include <ti/ipc/Notify.h>
+
+
+int bank_sel_initlog(void *arguments, void *logic)
+{
+	struct bank_sel_args *args = (struct bank_sel_args *)arguments;
+	struct bank_sel_logic *log = (struct bank_sel_logic *)logic;
+
+	if(set_bit_ptr_mask(args->io.bank0_in,&log->bank0_ptr,&log->bank0_bit_mask))
+		return -1;
+
+	if(set_bit_ptr_mask(args->io.bank1_in,&log->bank1_ptr,&log->bank1_bit_mask))
+		return -1;
+
+	if(set_bit_ptr_mask(args->io.bank2_in,&log->bank2_ptr,&log->bank2_bit_mask))
+		return -1;
+
+	if(set_bit_ptr_mask(args->io.bank3_in,&log->bank3_ptr,&log->bank3_bit_mask))
+		return -1;
+
+	if(set_bit_ptr_mask(args->io.bank4_in,&log->bank4_ptr,&log->bank4_bit_mask))
+		return -1;
+
+	if(set_bit_ptr_mask(args->io.bank5_in,&log->bank5_ptr,&log->bank5_bit_mask))
+		return -1;
+
+	if(set_bit_ptr_mask(args->io.blok_in,&log->blok_in,&log->blok_in_bit_mask))
+		return -1;
+
+	if(set_bit_ptr_mask(args->io.bank0_out,&log->bank0_out,&log->bank0_out_bit_mask))
+		return -1;
+	if(set_bit_ptr_mask(args->io.bank1_out,&log->bank1_out,&log->bank1_out_bit_mask))
+		return -1;
+	if(set_bit_ptr_mask(args->io.bank2_out,&log->bank2_out,&log->bank2_out_bit_mask))
+		return -1;
+	if(set_bit_ptr_mask(args->io.bank3_out,&log->bank3_out,&log->bank3_out_bit_mask))
+		return -1;
+	if(set_bit_ptr_mask(args->io.bank4_out,&log->bank4_out,&log->bank4_out_bit_mask))
+		return -1;
+	if(set_bit_ptr_mask(args->io.bank5_out,&log->bank5_out,&log->bank5_out_bit_mask))
+		return -1;
+
+	return 0;
+}
+
+void bank_sel(void *arguments, void *logic)
+{
+	struct bank_sel_logic *log = (struct bank_sel_logic *)logic;
+
+	if(!(*log->blok_in & log->blok_in_bit_mask))
+	{
+		if(*log->bank0_ptr & log->bank0_bit_mask)
+			log->sel_bank=0;
+		else if(*log->bank1_ptr & log->bank1_bit_mask)
+			log->sel_bank=1;
+		else if(*log->bank2_ptr & log->bank2_bit_mask)
+			log->sel_bank=2;
+		else if(*log->bank3_ptr & log->bank3_bit_mask)
+			log->sel_bank=3;
+		else if(*log->bank4_ptr & log->bank4_bit_mask)
+			log->sel_bank=4;
+		else if(*log->bank5_ptr & log->bank5_bit_mask)
+			log->sel_bank=5;
+		else
+			log->sel_bank=0;
+	}
+
+	check_and_set_mask(log->sel_bank==0,log->bank0_out,log->bank0_out_bit_mask);
+	check_and_set_mask(log->sel_bank==1,log->bank1_out,log->bank1_out_bit_mask);
+	check_and_set_mask(log->sel_bank==2,log->bank2_out,log->bank2_out_bit_mask);
+	check_and_set_mask(log->sel_bank==3,log->bank3_out,log->bank3_out_bit_mask);
+	check_and_set_mask(log->sel_bank==4,log->bank4_out,log->bank4_out_bit_mask);
+	check_and_set_mask(log->sel_bank==5,log->bank5_out,log->bank5_out_bit_mask);
+
+	if(log->t_cnt++ > (1200/LOOP_CYCLE_MS)) // every 1.2 secs
+	{
+
+		logman_notify|=(LOGMAN_NOTIFY_BANK0<<log->sel_bank) | LOGMAN_NOTIFY_NEW_EVENTS;
+//		Notify_sendEvent(notify.remoteProcId,notify.lineId,notify.eventId, NOTIFY_SEL_BANK0+log->sel_bank, TRUE);
+		log->t_cnt=0;
+	}
+}

src/bank_sel.h

@@ -0,0 +1,79 @@
+/*
+ * bank_sel.h
+ *
+ *
+ *  Created on: 13-12-2016
+ *      Author: KJ
+ */
+
+#ifndef BANK_SEL_H_
+#define BANK_SEL_H_
+
+#include "tdefs.h"
+
+
+struct bank_sel_logic
+{
+	u8 *bank0_ptr;
+	u8 bank0_bit_mask;
+	u8 *bank1_ptr;
+	u8 bank1_bit_mask;
+	u8 *bank2_ptr;
+	u8 bank2_bit_mask;
+	u8 *bank3_ptr;
+	u8 bank3_bit_mask;
+	u8 *bank4_ptr;
+	u8 bank4_bit_mask;
+	u8 *bank5_ptr;
+	u8 bank5_bit_mask;
+
+	u8 *blok_in;
+	u8 blok_in_bit_mask;
+	u8 *bank0_out;
+	u8 bank0_out_bit_mask;
+	u8 *bank1_out;
+	u8 bank1_out_bit_mask;
+	u8 *bank2_out;
+	u8 bank2_out_bit_mask;
+	u8 *bank3_out;
+	u8 bank3_out_bit_mask;
+	u8 *bank4_out;
+	u8 bank4_out_bit_mask;
+	u8 *bank5_out;
+	u8 bank5_out_bit_mask;
+	u32 t_cnt;
+	u32 sel_bank;
+};
+
+struct bank_sel_io
+{
+	u32 bank0_in;
+	u32 bank1_in;
+	u32 bank2_in;
+	u32 bank3_in;
+	u32 bank4_in;
+	u32 bank5_in;
+	u32 blok_in;
+	u32 bank0_out;
+	u32 bank1_out;
+	u32 bank2_out;
+	u32 bank3_out;
+	u32 bank4_out;
+	u32 bank5_out;
+}__attribute__((__packed__));
+
+struct bank_sel_params
+{
+}__attribute__((__packed__));
+
+struct bank_sel_args
+{
+	struct bank_sel_io io;
+	struct bank_sel_params params;
+//	u16 crc;
+}__attribute__((__packed__));
+
+extern void bank_sel(void *args, void *logic);
+extern int bank_sel_initlog(void *args, void *logic);
+
+#endif /* BANK_SEL_H_ */

src/bin_in.c

@@ -0,0 +1,97 @@
+/*
+ * bin_in.c
+ *
+ *  Created on: 07-04-2014
+ *      Author: Krzysztof Jakubczyk
+ */
+
+#include "tdefs.h"
+#include "misc.h"
+
+#include "bin_in.h"
+
+int bin_in_initlog(void *arguments, void *logic)
+{
+	struct bin_in_args *args = (struct bin_in_args *)arguments;
+	struct bin_in_logic *log = (struct bin_in_logic *)logic;
+
+	log->out_ptr = log_manager.nets_data + (args->io.out >> 3);
+	log->out_bit_mask = 1<<(args->io.out & 0x07);
+	log->kob_ptr = log_manager.nets_data + (args->io.kob_out >> 3);
+	log->kob_bit_mask = 1<<(args->io.kob_out & 0x07);
+
+	if(args->params.card_addr>=MAX_BIN_CARDS)
+	{
+		if(args->params.ac_filter)
+			ic->bin_ac_mask_ench[args->params.card_addr-16]|=(1<<args->params.in_num);
+		else
+			ic->bin_ac_mask_ench[args->params.card_addr-16]&=~(1<<args->params.in_num);
+	}
+	else
+	{
+		if(args->params.ac_filter)
+			ic->bin_ac_mask[args->params.card_addr]|=(1<<args->params.in_num);
+		else
+			ic->bin_ac_mask[args->params.card_addr]&=~(1<<args->params.in_num);
+	}
+
+	if(log->out_ptr >= (log_manager.nets_data+sizeof(log_manager.nets_data)))
+		return -1;
+
+	if(log->kob_ptr >= (log_manager.nets_data+sizeof(log_manager.nets_data)))
+		return -1;
+
+	if(args->params.card_addr>=(MAX_BIN_CARDS * 2)) // *2 bo mwd32
+		return -1;
+
+	log->in_num_mask=(1<<args->params.in_num);
+	log->card_addr_mask=(1<<args->params.card_addr);
+
+	if(args->params.card_addr>=16)
+	{
+		mwd32_mask|=1<<(args->params.card_addr&0x07);
+		ic->mwd32_present=1;
+	}
+
+	if(args->params.in_num>=8)
+		return -1;
+
+	return 0;
+}
+
+void bin_in(void *arguments, void *logic)
+{
+	struct bin_in_args *args = (struct bin_in_args *)arguments;
+	struct bin_in_logic *log = (struct bin_in_logic *)logic;
+
+
+	if(args->params.card_addr>=MAX_BIN_CARDS) // mwd32
+	{
+		if(bus_bin_data_ench[args->params.card_addr-16] & log->in_num_mask)
+			*log->out_ptr|=log->out_bit_mask;
+		else
+			*log->out_ptr&=~log->out_bit_mask;
+	}
+	else
+	{
+		if(bus_bin_data[args->params.card_addr] & log->in_num_mask)
+			*log->out_ptr|=log->out_bit_mask;
+		else
+			*log->out_ptr&=~log->out_bit_mask;
+	}
+
+	if(mwd32_mask & (1<<(args->params.card_addr&0x07)))
+	{
+		if(ic->kob_bin & (1<<(args->params.card_addr&0x07)))
+			*log->kob_ptr|=log->kob_bit_mask;
+		else
+			*log->kob_ptr&=~log->kob_bit_mask;
+	}
+	else
+	{
+		if(ic->kob_bin & log->card_addr_mask)
+			*log->kob_ptr|=log->kob_bit_mask;
+		else
+			*log->kob_ptr&=~log->kob_bit_mask;
+	}
+}

src/bin_in.h

@@ -0,0 +1,46 @@
+/*
+ * bin_in.h
+ *
+ *  Created on: 07-04-2014
+ *      Author: Krzysztof Jakubczyk
+ */
+
+#ifndef BIN_IN_H_
+#define BIN_IN_H_
+
+#include "tdefs.h"
+
+struct bin_in_logic
+{
+	u8 *out_ptr;
+	u8 out_bit_mask;
+	u8 *kob_ptr;
+	u8 kob_bit_mask;
+	u8 in_num_mask;
+	u16 card_addr_mask;
+};
+
+struct bin_in_io
+{
+	u32 out;  	 // one bit output for one binary input
+	u32 kob_out;
+}__attribute__((__packed__));
+
+struct bin_in_params
+{
+	u32 card_addr;
+	u32 in_num;
+	u32 ac_filter;
+}__attribute__((__packed__));
+
+struct bin_in_args
+{
+	struct bin_in_io io;
+	struct bin_in_params params;
+//	u16 crc;
+}__attribute__((__packed__));
+
+extern void bin_in(void *args, void *logic);
+extern int bin_in_initlog(void *args, void *logic);
+
+#endif /* BIN_IN_H_ */

src/buzzer.c

@@ -0,0 +1,38 @@
+/*
+ * buzzer.c
+ *
+ *  Created on: 09-10-2014
+ *      Author: Krzysztof Jakubczyk
+ */
+
+#include "tdefs.h"
+#include "misc.h"
+
+#include "led.h"
+
+int buzzer_initlog(void *arguments, void *logic)
+{
+	struct led_args *args = (struct led_args *)arguments;
+	struct led_logic *log = (struct led_logic *)logic;
+
+	log->in_ptr = log_manager.nets_data + (args->io.in  >> 3);
+	log->in_bit_no = args->io.in & 0x07;
+	log->blink_in_ptr = log_manager.nets_data + (args->io.blink_in  >> 3);
+	log->blink_in_bit_no = args->io.blink_in & 0x07;
+	log->clr_ptr = log_manager.nets_data + (args->io.clr_in >> 3);
+	log->clr_bit_no = args->io.clr_in & 0x07;
+
+	if(log->in_ptr >= (log_manager.nets_data+sizeof(log_manager.nets_data)))
+		return -1;
+
+	if(log->clr_ptr >= (log_manager.nets_data+sizeof(log_manager.nets_data)))
+		return -1;
+
+	if(log->blink_in_ptr >= (log_manager.nets_data+sizeof(log_manager.nets_data)))
+		return -1;
+
+	args->params.led_num=BUZZER_LED_NUM;
+
+	return 0;
+}
+

src/c37_94.c

@@ -0,0 +1,586 @@
+/*
+ * c37_94.c
+ *
+ *  Created on: 16-07-2019
+ *      Author: Krzysztof Jakubczyk
+ */
+
+#include <math.h>
+
+#include "tdefs.h"
+#include "misc.h"
+#include "config.h"
+
+#include "c37_94.h"
+#include "helper.h"
+#include "mkstream.h"
+
+#include <ti/ipc/Notify.h>
+
+#include "comm.h"
+#include <ti/sysbios/hal/Hwi.h>
+
+volatile struct stream_frame c37_str[C37_MAX_STREAMS][C37_STREAM_BUF_SIZE] __attribute__((aligned(4)));
+volatile u8 c37_str_bits[C37_MAX_STREAMS][C37_STREAM_BUF_SIZE] __attribute__((aligned(4)));
+volatile u32 c37_str_pos[C37_MAX_STREAMS] __attribute__((aligned(4)));
+
+int c37_94_initlog(void *arguments, void *logic)
+{
+	struct c37_94_args *args = (struct c37_94_args *)arguments;
+	struct c37_94_logic *log = (struct c37_94_logic *)logic;
+
+	if(set_pointer_in_ptr(args->io.stream_ptr_in,(u32 *)&log->stream_in))
+		return -1;
+
+	if(set_bit_ptr_struct(args->io.stream_en_in,&log->stream_en))
+		return -1;
+
+	if(set_bit_ptr_struct(args->io.no_sync_in,&log->no_sync))
+		return -1;
+
+	if(set_bit_ptr_struct(args->io.clr_in,&log->clr))
+		return -1;
+
+	if(set_bit_ptr_struct(args->io.ping_in,&log->ping))
+		return -1;
+
+	if(set_pointer_out_ptr(args->io.stream0_ptr_out,(u32 *)&log->stream_out[0]))
+		return -1;
+	if(set_bit_ptr_struct(args->io.stream0_act_out,&log->stream_act[0]))
+		return -1;
+	if(set_pointer_out_ptr(args->io.stream1_ptr_out,(u32 *)&log->stream_out[1]))
+		return -1;
+	if(set_bit_ptr_struct(args->io.stream1_act_out,&log->stream_act[1]))
+		return -1;
+	if(set_pointer_out_ptr(args->io.stream2_ptr_out,(u32 *)&log->stream_out[2]))
+		return -1;
+	if(set_bit_ptr_struct(args->io.stream2_act_out,&log->stream_act[2]))
+		return -1;
+
+	if(set_bit_ptr_struct(args->io.err_out,&log->err))
+		return -1;
+
+	if(set_bit_ptr_struct(args->io.y_bit_out,&log->y_bit))
+		return -1;
+
+	if(set_bit_ptr_struct(args->io.err2_out,&log->err2))
+		return -1;
+
+	if(set_bit_ptr_struct(args->io.y2_bit_out,&log->y_bit2))
+		return -1;
+
+	if(set_float_ptr(args->io.stream0_errs_float_out,&log->stream_errs[0]))
+		return -1;
+	if(set_float_ptr(args->io.stream1_errs_float_out,&log->stream_errs[1]))
+		return -1;
+	if(set_float_ptr(args->io.stream2_errs_float_out,&log->stream_errs[2]))
+		return -1;
+
+	if(set_bit_ptr_struct(args->io.link0_out,&log->link[0]))
+		return -1;
+	if(set_bit_ptr_struct(args->io.link1_out,&log->link[1]))
+		return -1;
+	if(set_bit_ptr_struct(args->io.link2_out,&log->link[2]))
+		return -1;
+
+	if(set_float_ptr(args->io.cur_shift_float_out,&log->cur_shift))
+		return -1;
+
+	if(set_float_ptr(args->io.cur_shift2_float_out,&log->cur_shift2))
+		return -1;
+
+	if(set_float_ptr(args->io.stream0_synt_errs_float_out,&log->stream_synt_errs[0]))
+		return -1;
+	if(set_float_ptr(args->io.stream1_synt_errs_float_out,&log->stream_synt_errs[1]))
+		return -1;
+	if(set_float_ptr(args->io.stream2_synt_errs_float_out,&log->stream_synt_errs[2]))
+		return -1;
+
+	if(set_float_ptr(args->io.ping_float_out,&log->ping_time))
+		return -1;
+
+	log->wr_bits=((args->params.bits & 0x00000001)?MUX_REG_EXT_CLK:0)|((args->params.mux_chans<=12?args->params.mux_chans:12)<<MUX_REG_CHAN_NUM_OFFSET);
+	ic->mux_reg=log->wr_bits|MUX_REG_SKIP_FF;
+	log->prev_addr=ic->mux_state & MUX_STATE_RX_BYTES_MASK;
+
+	//
+	log->s_delay=args->params.sample_delay/LOOP_CYCLE_MS;
+	if(args->params.sample_delay%LOOP_CYCLE_MS)
+		log->s_delay++;
+
+	log->s_delay*=(SAMPLES_PER_MS*LOOP_CYCLE_MS);
+
+	if(log->s_delay>=((C37_STREAM_BUF_SIZE-1)*(SAMPLES_PER_MS*LOOP_CYCLE_MS)))
+		log->s_delay=(C37_STREAM_BUF_SIZE-1)*(SAMPLES_PER_MS*LOOP_CYCLE_MS);
+	//
+
+	log->wr_addr=1;
+
+	ic->mux_shift=0;
+
+	// mux2
+	log->wr_bits2=((args->params.bits & MUX2_EXT_CLK)?MUX_REG_EXT_CLK:0)|((args->params.mux_chans<=12?args->params.mux_chans:12)<<MUX_REG_CHAN_NUM_OFFSET);
+	ic->mux2_reg=log->wr_bits2|MUX_REG_SKIP_FF;
+	log->prev_addr2=ic->mux2_state & MUX_STATE_RX_BYTES_MASK;
+	log->wr_addr2=1;
+	ic->mux2_shift=0;
+
+	log->my_mask = (args->params.serial_num<<2)&C37_SERIAL_MASK;
+	return 0;
+}
+
+
+void c37_94(void *arguments, void *logic)
+{
+	struct c37_94_logic *log = (struct c37_94_logic *)logic;
+	struct c37_94_args *args = (struct c37_94_args *)arguments;
+	int i,rx_bytes;
+	u8 j,k;
+	u8 cksum;
+	u16 find_stamp;
+	u16 cur_addr;
+	u16 mux_offset;
+	u8 already_incremented[C37_MAX_STREAMS]={0,0,0};
+	u8 need_pong=0;
+
+	static struct stream_frame tmp_frame;
+
+
+	if(check_struct(&log->clr))
+	{
+		for(i=0;i<C37_MAX_STREAMS;i++)
+		{
+			*log->stream_errs[i]=0;
+			*log->stream_synt_errs[i]=0;
+		}
+	}
+
+	for(i=0;i<C37_MAX_STREAMS;i++)
+	{
+		if(log->prev_pos[i]!=c37_str_pos[i])
+		{
+			if(log->link_up_cnt[i]>LINK_UP_TIME)
+			{
+				if(!check_struct(&log->link[i]))
+					*log->stream_errs[i]=0;
+				set_struct(&log->link[i]);
+			}
+			else
+				log->link_up_cnt[i]+=LOOP_CYCLE_MS;
+
+			while(log->prev_pos[i]!=c37_str_pos[i])
+			{
+				u16 prev_tstamp=(!log->prev_pos[i]?c37_str[i][C37_STREAM_BUF_SIZE-1].sample_stamp:c37_str[i][log->prev_pos[i]-1].sample_stamp) & 0x7FFF;
+				u16 next_tstamp=(c37_str[i][log->prev_pos[i]].sample_stamp)&0x7FFF;
+
+				if((prev_tstamp+(SAMPLES_PER_MS*LOOP_CYCLE_MS))%(SAMPLES_PER_MS*1000)!=next_tstamp)
+				{
+					if((log->prev_timestamp+(SAMPLES_PER_MS*LOOP_CYCLE_MS))%(SAMPLES_PER_MS*1000)==bus_an_cur_timestamp)
+						*log->stream_errs[i]+=1.0f;
+					already_incremented[i]=1;
+				}
+				log->prev_pos[i]++;
+				log->prev_pos[i]%=C37_STREAM_BUF_SIZE;
+			}
+
+			log->link_timeout_cnt[i]=0;
+			log->prev_pos[i]=c37_str_pos[i];
+		}
+		else
+		{
+			if(log->link_timeout_cnt[i]>LINK_TIMEOUT_TIME)
+			{
+				clear_struct(&log->link[i]);
+				log->link_up_cnt[i]=0;
+			}
+			else
+			{
+				if(log->link_timeout_cnt[i]>(1*LOOP_CYCLE_MS))
+				{
+					if((log->prev_timestamp+(SAMPLES_PER_MS*LOOP_CYCLE_MS))%(SAMPLES_PER_MS*1000)==bus_an_cur_timestamp)
+						*log->stream_errs[i]+=1.0f;
+					already_incremented[i]=1;
+				}
+				log->link_timeout_cnt[i]+=LOOP_CYCLE_MS;
+			}
+		}
+	}
+
+
+	check_and_set_struct(ic->mux_state & MUX_STATE_ERR,&log->err);
+	check_and_set_struct(ic->mux2_state & MUX_STATE_ERR,&log->err2);
+
+	cur_addr = ic->mux_state & MUX_STATE_RX_BYTES_MASK;
+	rx_bytes = cur_addr>=log->prev_addr ? cur_addr-log->prev_addr : C37_MUX_BUFSIZE + cur_addr - log->prev_addr;
+	mux_offset = log->prev_addr;
+/*
+	if(check_struct(&log->shift_out))
+	{
+		log->out_shift_cnt++;
+		log->out_shift_cnt&=0x07;
+		ic->mux_shift=(ic->mux_shift & 0x0F) | (log->out_shift_cnt<<4);
+	}
+*/
+
+// MUX1
+	if(!(ic->mux_state & MUX_STATE_ERR))
+	{
+		log->no_data_cnt+=LOOP_CYCLE_MS;
+
+		if(log->no_data_cnt > (C37_NO_DATA_SHIFT_INTERVAL))
+		{
+			log->no_data_cnt=0;
+			log->shift_cnt++;
+			log->shift_cnt&=0x07;
+			ic->mux_shift=(ic->mux_shift & 0xF0)|log->shift_cnt;
+			*log->cur_shift=log->shift_cnt;
+		}
+	}
+	else
+		log->no_data_cnt=0;
+
+	while(rx_bytes >= C37_FRAME_SIZE)
+	{
+		if(ic->mux_indata[mux_offset]!='T' || ic->mux_indata[(mux_offset+1)%C37_MUX_BUFSIZE]!='Z')
+		{
+			rx_bytes--;
+			mux_offset++;
+			mux_offset%=C37_MUX_BUFSIZE;
+			continue;
+		}
+
+		if(mux_offset + C37_FRAME_SIZE > C37_MUX_BUFSIZE)
+		{
+			memcpy((u8*)&tmp_frame,(u8*)&ic->mux_indata[mux_offset],C37_MUX_BUFSIZE - mux_offset);
+			memcpy((u8*)&tmp_frame+(C37_MUX_BUFSIZE-mux_offset),(u8*)&ic->mux_indata[0],C37_FRAME_SIZE-(C37_MUX_BUFSIZE-mux_offset));
+		}
+		else
+		{
+			memcpy((u8*)&tmp_frame,(u8*)&ic->mux_indata[mux_offset],C37_FRAME_SIZE);
+		}
+
+		cksum=CKSUM_IV;
+		for(j=0;j<C37_FRAME_SIZE-1;j++)
+			cksum+=*((u8*)&tmp_frame+j);
+
+		if(cksum == tmp_frame.cksum && ((tmp_frame.addr & C37_SERIAL_MASK) == log->my_mask))
+		{
+			if(tmp_frame.addr & 0x80)
+				need_pong=1;
+			if(tmp_frame.addr & 0x40 && log->ping_sent)
+			{
+				*log->ping_time=log->ping_cnt;
+				log->ping_sent=0;
+			}
+			tmp_frame.addr&=0x03;
+			log->no_data_cnt=0;
+
+			if(tmp_frame.addr <C37_MAX_STREAMS)
+			{
+				memcpy((u8 *)&c37_str[tmp_frame.addr][c37_str_pos[tmp_frame.addr]],(u8*)&tmp_frame,C37_FRAME_SIZE);
+				c37_str_bits[tmp_frame.addr][c37_str_pos[tmp_frame.addr]++]=0;
+				c37_str_pos[tmp_frame.addr]%=C37_STREAM_BUF_SIZE;
+			}
+		}
+//		else
+//			*log->cksum_err+=1.0;
+		//else odjac tylko 2 bajty TZ i szukac kolejnego?
+
+		rx_bytes-=C37_FRAME_SIZE;
+		mux_offset+=C37_FRAME_SIZE;
+		mux_offset%=C37_MUX_BUFSIZE;
+	}
+
+	log->prev_addr=mux_offset;
+
+//	*log->hw_err=(float)((ic->mux_state & MUX_STATE_ERR_CNT_MASK)>>MUX_STATE_ERR_CNT_OFFSET);
+	check_and_set_struct(ic->mux_state & MUX_STATE_YELLOW_BIT_IN, &log->y_bit);
+
+//MUX2
+	if(args->params.bits & MUX2_ACTIVE)
+	{
+		cur_addr = ic->mux2_state & MUX_STATE_RX_BYTES_MASK;
+		rx_bytes = cur_addr>=log->prev_addr2 ? cur_addr-log->prev_addr2 : C37_MUX_BUFSIZE + cur_addr - log->prev_addr2;
+		mux_offset = log->prev_addr2;
+
+		if(!(ic->mux2_state & MUX_STATE_ERR))
+		{
+			log->no_data_cnt2+=LOOP_CYCLE_MS;
+
+			if(log->no_data_cnt2 > (C37_NO_DATA_SHIFT_INTERVAL))
+			{
+				log->no_data_cnt2=0;
+				log->shift_cnt2++;
+				log->shift_cnt2&=0x07;
+				ic->mux2_shift=(ic->mux2_shift & 0xF0)|log->shift_cnt2;
+				*log->cur_shift2=log->shift_cnt2;
+			}
+		}
+		else
+			log->no_data_cnt2=0;
+
+		while(rx_bytes >= C37_FRAME_SIZE)
+		{
+			if(ic->mux2_indata[mux_offset]!='T' || ic->mux2_indata[(mux_offset+1)%C37_MUX_BUFSIZE]!='Z')
+			{
+				rx_bytes--;
+				mux_offset++;
+				mux_offset%=C37_MUX_BUFSIZE;
+				continue;
+			}
+
+			if(mux_offset + C37_FRAME_SIZE > C37_MUX_BUFSIZE)
+			{
+				memcpy((u8*)&tmp_frame,(u8*)&ic->mux2_indata[mux_offset],C37_MUX_BUFSIZE - mux_offset);
+				memcpy((u8*)&tmp_frame+(C37_MUX_BUFSIZE-mux_offset),(u8*)&ic->mux2_indata[0],C37_FRAME_SIZE-(C37_MUX_BUFSIZE-mux_offset));
+			}
+			else
+			{
+				memcpy((u8*)&tmp_frame,(u8*)&ic->mux2_indata[mux_offset],C37_FRAME_SIZE);
+			}
+
+			cksum=CKSUM_IV;
+			for(j=0;j<C37_FRAME_SIZE-1;j++)
+				cksum+=*((u8*)&tmp_frame+j);
+
+			if(cksum == tmp_frame.cksum && ((tmp_frame.addr & C37_SERIAL_MASK) == log->my_mask))
+			{
+				if(tmp_frame.addr & 0x80)
+					need_pong=1;
+				if(tmp_frame.addr & 0x40 && log->ping_sent)
+				{
+					*log->ping_time=log->ping_cnt;
+					log->ping_sent=0;
+				}
+				tmp_frame.addr&=0x03;
+				log->no_data_cnt2=0;
+
+				if(tmp_frame.addr <C37_MAX_STREAMS)
+				{
+					memcpy((u8 *)&c37_str[tmp_frame.addr][c37_str_pos[tmp_frame.addr]],(u8*)&tmp_frame,C37_FRAME_SIZE);
+					c37_str_bits[tmp_frame.addr][c37_str_pos[tmp_frame.addr]++]=0;
+					c37_str_pos[tmp_frame.addr]%=C37_STREAM_BUF_SIZE;
+				}
+			}
+	//		else
+	//			*log->cksum_err+=1.0;
+			//else odjac tylko 2 bajty TZ i szukac kolejnego?
+
+			rx_bytes-=C37_FRAME_SIZE;
+			mux_offset+=C37_FRAME_SIZE;
+			mux_offset%=C37_MUX_BUFSIZE;
+		}
+
+		log->prev_addr2=mux_offset;
+
+	//	*log->hw_err=(float)((ic->mux_state & MUX_STATE_ERR_CNT_MASK)>>MUX_STATE_ERR_CNT_OFFSET);
+		check_and_set_struct(ic->mux2_state & MUX_STATE_YELLOW_BIT_IN, &log->y_bit2);
+	}
+	//
+
+	if(bus_an_cur_timestamp>=log->s_delay)
+		find_stamp=bus_an_cur_timestamp-log->s_delay;
+	else
+		find_stamp=(SAMPLES_PER_MS*1000)+bus_an_cur_timestamp-log->s_delay;
+
+
+	for(i=0;i<C37_MAX_STREAMS;i++)
+	{
+		if(!check_struct(&log->no_sync))
+		{
+			if(!check_struct(&log->link[i]))
+			{
+				clear_struct(&log->stream_act[i]);
+				continue;
+			}
+
+			for(k=0;k<C37_STREAM_BUF_SIZE;k++)
+			{
+				if(c37_str[i][k].sample_stamp == find_stamp && !(c37_str_bits[i][k] & STATUS_FRAME_READ))
+				{
+					c37_str_bits[i][k]|=STATUS_FRAME_READ;
+					log->stream_out[i] = c37_str[i][k];
+//					*log->stream_snum[i] = c37_str[i][k].sample_stamp;
+					break;
+				}
+			}
+
+			if(k<C37_STREAM_BUF_SIZE)
+				set_struct(&log->stream_act[i]);
+			else
+			{
+				if(!already_incremented[i])
+					*log->stream_synt_errs[i]+=1.0f;
+					//*log->stream_errs[i]+=1.0f;
+				clear_struct(&log->stream_act[i]);
+			}
+		}
+		else
+		{
+			if(args->params.bits & 0x00000002) // no buf
+			{
+				if(!(c37_str_bits[i][(c37_str_pos[i]+C37_STREAM_BUF_SIZE-1) % C37_STREAM_BUF_SIZE] & STATUS_FRAME_READ))
+				{
+					c37_str_bits[i][(c37_str_pos[i]+C37_STREAM_BUF_SIZE-1) % C37_STREAM_BUF_SIZE]|=STATUS_FRAME_READ;
+					log->stream_out[i] = c37_str[i][(c37_str_pos[i]+C37_STREAM_BUF_SIZE-1) % C37_STREAM_BUF_SIZE];
+//					*log->stream_snum[i] = c37_str[i][(c37_str_pos[i]+C37_STREAM_BUF_SIZE-1) % C37_STREAM_BUF_SIZE].sample_stamp;
+					break;
+				}
+			}
+			else
+			{
+				for(k=0;k<C37_STREAM_BUF_SIZE;k++)
+				{
+
+					if(!(c37_str_bits[i][(c37_str_pos[i]+k) % C37_STREAM_BUF_SIZE] & STATUS_FRAME_READ))
+					{
+						c37_str_bits[i][(c37_str_pos[i]+k) % C37_STREAM_BUF_SIZE]|=STATUS_FRAME_READ;
+						log->stream_out[i] = c37_str[i][(c37_str_pos[i]+k) % C37_STREAM_BUF_SIZE];
+//						*log->stream_snum[i] = c37_str[i][(c37_str_pos[i]+k) % C37_STREAM_BUF_SIZE].sample_stamp;
+						break;
+					}
+				}
+
+				if(k<C37_STREAM_BUF_SIZE)
+					set_struct(&log->stream_act[i]);
+				else
+				{
+					if(!already_incremented[i])
+						*log->stream_synt_errs[i]+=1.0f;
+						//*log->stream_errs[i]+=1.0f;
+					clear_struct(&log->stream_act[i]);
+				}
+			}
+
+		}
+
+	}
+
+	//
+	log->prev_timestamp=bus_an_cur_timestamp;
+	if(log->stream_in->addr<C37_MAX_STREAMS)
+	{
+		memcpy((u8 *)&c37_str[log->stream_in->addr][c37_str_pos[log->stream_in->addr]],(u8*)log->stream_in,C37_FRAME_SIZE);
+		c37_str_bits[log->stream_in->addr][c37_str_pos[log->stream_in->addr]++]=0;
+		c37_str_pos[log->stream_in->addr]%=C37_STREAM_BUF_SIZE;
+
+		if(check_struct(&log->stream_en))
+		{
+			//
+			log->stream_in->addr|=log->my_mask;
+			log->stream_in->cksum+=log->my_mask;
+
+			if(check_struct(&log->ping) && log->ping_cnt==0)
+			{
+				log->stream_in->addr|=0x80; // ping req
+				log->stream_in->cksum+=0x80;
+				log->ping_sent=1;
+			}
+			if(need_pong)
+			{
+				log->stream_in->addr|=0x40;
+				log->stream_in->cksum+=0x40;
+			}
+
+			if(log->wr_addr + C37_FRAME_SIZE > C37_MUX_BUFSIZE)
+			{
+				memcpy((u8*)&ic->mux_outdata[log->wr_addr],(u8 *)log->stream_in,C37_MUX_BUFSIZE - log->wr_addr);
+				memcpy((u8*)ic->mux_outdata,(u8 *)log->stream_in+(C37_MUX_BUFSIZE - log->wr_addr),C37_FRAME_SIZE - (C37_MUX_BUFSIZE - log->wr_addr));
+			}
+			else
+				memcpy((u8*)&ic->mux_outdata[log->wr_addr],(u8 *)log->stream_in,C37_FRAME_SIZE);
+
+			log->wr_addr+=C37_FRAME_SIZE-1;
+			log->wr_addr%=C37_MUX_BUFSIZE;
+			ic->mux_reg=log->wr_bits|MUX_REG_WR|log->wr_addr;
+			log->wr_addr++;
+			log->wr_addr%=C37_MUX_BUFSIZE;
+			//
+			//mux2
+			if(args->params.bits & MUX2_ACTIVE)
+			{
+				if(log->wr_addr2 + C37_FRAME_SIZE > C37_MUX_BUFSIZE)
+				{
+					memcpy((u8*)&ic->mux2_outdata[log->wr_addr2],(u8 *)log->stream_in,C37_MUX_BUFSIZE - log->wr_addr2);
+					memcpy((u8*)ic->mux2_outdata,(u8 *)log->stream_in+(C37_MUX_BUFSIZE - log->wr_addr2),C37_FRAME_SIZE - (C37_MUX_BUFSIZE - log->wr_addr2));
+				}
+				else
+					memcpy((u8*)&ic->mux2_outdata[log->wr_addr2],(u8 *)log->stream_in,C37_FRAME_SIZE);
+
+				log->wr_addr2+=C37_FRAME_SIZE-1;
+				log->wr_addr2%=C37_MUX_BUFSIZE;
+				ic->mux2_reg=log->wr_bits2|MUX_REG_WR|log->wr_addr2;
+				log->wr_addr2++;
+				log->wr_addr2%=C37_MUX_BUFSIZE;
+			}
+		}
+		else
+		{
+			if(check_struct(&log->ping) && log->ping_cnt==0)
+			{
+				memcpy((u8 *)&c37_str[log->stream_in->addr][c37_str_pos[log->stream_in->addr]],(u8*)log->stream_in,C37_FRAME_SIZE);
+				c37_str_bits[log->stream_in->addr][c37_str_pos[log->stream_in->addr]++]=0;
+				c37_str_pos[log->stream_in->addr]%=C37_STREAM_BUF_SIZE;
+
+				log->ping_sent=1;
+				log->stream_in->addr|=0x80; // ping req
+				log->stream_in->cksum+=0x80;
+				log->stream_in->addr|=log->my_mask;
+				log->stream_in->cksum+=log->my_mask;
+
+				if(need_pong)
+				{
+					log->stream_in->addr|=0x40;
+					log->stream_in->cksum+=0x40;
+				}
+
+				//
+				if(log->wr_addr + C37_FRAME_SIZE > C37_MUX_BUFSIZE)
+				{
+					memcpy((u8*)&ic->mux_outdata[log->wr_addr],(u8 *)log->stream_in,C37_MUX_BUFSIZE - log->wr_addr);
+					memcpy((u8*)ic->mux_outdata,(u8 *)log->stream_in+(C37_MUX_BUFSIZE - log->wr_addr),C37_FRAME_SIZE - (C37_MUX_BUFSIZE - log->wr_addr));
+				}
+				else
+					memcpy((u8*)&ic->mux_outdata[log->wr_addr],(u8 *)log->stream_in,C37_FRAME_SIZE);
+
+				log->wr_addr+=C37_FRAME_SIZE-1;
+				log->wr_addr%=C37_MUX_BUFSIZE;
+				ic->mux_reg=log->wr_bits|MUX_REG_WR|log->wr_addr;
+				log->wr_addr++;
+				log->wr_addr%=C37_MUX_BUFSIZE;
+				//
+				//
+				if(args->params.bits & MUX2_ACTIVE)
+				{
+					if(log->wr_addr + C37_FRAME_SIZE > C37_MUX_BUFSIZE)
+					{
+						memcpy((u8*)&ic->mux2_outdata[log->wr_addr2],(u8 *)log->stream_in,C37_MUX_BUFSIZE - log->wr_addr2);
+						memcpy((u8*)ic->mux2_outdata,(u8 *)log->stream_in+(C37_MUX_BUFSIZE - log->wr_addr2),C37_FRAME_SIZE - (C37_MUX_BUFSIZE - log->wr_addr2));
+					}
+					else
+						memcpy((u8*)&ic->mux2_outdata[log->wr_addr2],(u8 *)log->stream_in,C37_FRAME_SIZE);
+
+					log->wr_addr2+=C37_FRAME_SIZE-1;
+					log->wr_addr2%=C37_MUX_BUFSIZE;
+					ic->mux2_reg=log->wr_bits2|MUX_REG_WR|log->wr_addr2;
+					log->wr_addr2++;
+					log->wr_addr2%=C37_MUX_BUFSIZE;
+					//
+				}
+			}
+		}
+	}
+
+	if(log->ping_cnt<5000)
+		log->ping_cnt+=LOOP_CYCLE_MS;
+	else
+	{
+		if(log->ping_sent)
+		{
+			*log->ping_time=999999.0f;
+			log->ping_sent=0;
+		}
+
+		log->ping_cnt=0;
+	}
+}

src/c37_94.h

@@ -0,0 +1,126 @@
+/*
+ * c37_94.h
+ *
+ *  Created on: 17-07-2019
+ *      Author: Krzysztof Jakubczyk
+ */
+
+#ifndef C37_94_H_
+#define C37_94_H_
+
+#include "tdefs.h"
+#include "helper.h"
+#include "mkstream.h"
+#include "eth.h"
+
+#define C37_MAX_STREAMS			3
+#define C37_STREAM_BUF_SIZE		16//8
+#define C37_NUM_OF_CHANS		6
+#define C37_FRAME_SIZE			sizeof(struct stream_frame)
+
+#define C37_NO_DATA_SHIFT_INTERVAL	100
+
+#define C37_SERIAL_MASK			0x3c
+
+extern volatile u8 c37_str_bits[C37_MAX_STREAMS][C37_STREAM_BUF_SIZE];
+//args->params.bits definitions
+
+#define EXT_CLK			0x00000001
+#define NO_BUF			0x00000002
+#define MUX2_ACTIVE		0x00000004
+#define MUX2_EXT_CLK	0x00000008
+
+struct c37_94_logic
+{
+	struct binary_io stream_en;
+	struct binary_io no_sync;
+	struct binary_io clr;
+	struct binary_io ping;
+	struct stream_frame *stream_in;
+	struct stream_frame stream_out[C37_MAX_STREAMS];
+	struct binary_io stream_act[C37_MAX_STREAMS];
+	struct binary_io link[C37_MAX_STREAMS];
+	float *stream_errs[C37_MAX_STREAMS];
+	float *stream_synt_errs[C37_MAX_STREAMS];
+	struct binary_io err;
+	struct binary_io y_bit;
+	struct binary_io err2;
+	struct binary_io y_bit2;
+	float *cur_shift;
+	float *cur_shift2;
+	float *ping_time;
+	u16 s_delay;
+	u16 wr_bits;
+	u16 wr_bits2;
+	u16 prev_addr;
+	u16 prev_addr2;
+	u16 wr_addr;
+	u16 wr_addr2;
+	u8 shift_cnt;
+	u8 shift_cnt2;
+	u8 out_shift_cnt;
+	u16 no_data_cnt;
+	u16 no_data_cnt2;
+	u32 prev_pos[C37_MAX_STREAMS];
+	u32 link_timeout_cnt[C37_MAX_STREAMS];
+	u32 link_up_cnt[C37_MAX_STREAMS];
+	u16 prev_timestamp;
+	u16 ping_cnt;
+	u16 ping_sent;
+	u8 my_mask;
+};
+
+struct c37_94_io
+{
+	u32 stream_en_in;
+	u32 stream_ptr_in;
+	u32 no_sync_in;
+	u32 clr_in;
+	u32 ping_in;
+
+	u32 stream0_ptr_out;
+	u32 stream0_act_out;
+	u32 link0_out;
+	u32 stream0_errs_float_out;
+
+	u32 stream1_ptr_out;
+	u32 stream1_act_out;
+	u32 link1_out;
+	u32 stream1_errs_float_out;
+
+	u32 stream2_ptr_out;
+	u32 stream2_act_out;
+	u32 link2_out;
+	u32 stream2_errs_float_out;
+	u32 err_out;
+	u32 y_bit_out;
+	u32 cur_shift_float_out;
+	u32 err2_out;
+	u32 y2_bit_out;
+	u32 cur_shift2_float_out;
+	u32 stream0_synt_errs_float_out;
+	u32 stream1_synt_errs_float_out;
+	u32 stream2_synt_errs_float_out;
+	u32 ping_float_out;
+
+}__attribute__((__packed__));
+
+struct c37_94_params
+{
+	u32 bits;
+	u32 mux_chans;
+	u32 sample_delay;
+	u32 serial_num;
+}__attribute__((__packed__));
+
+struct c37_94_args
+{
+	struct c37_94_io io;
+	struct c37_94_params params;
+//	u16 crc;
+}__attribute__((__packed__));
+
+extern void c37_94(void *args, void *logic);
+extern int c37_94_initlog(void *arguments, void *logic);
+
+#endif

src/cap_comp.c

@@ -0,0 +1,137 @@
+/*
+ * cap_comp.c
+ *
+ *  Created on: 19-08-2019
+ *      Author: Krzysztof Jakubczyk
+ */
+
+#include <math.h>
+
+#include "tdefs.h"
+#include "misc.h"
+#include "config.h"
+
+#include "helper.h"
+#include "cap_comp.h"
+#include "analog_in.h"
+
+int cap_comp_initlog(void *arguments, void *logic)
+{
+	struct cap_comp_args *args = (struct cap_comp_args *)arguments;
+	struct cap_comp_logic *log = (struct cap_comp_logic *)logic;
+/*
+	if(set_float_ptr(args->io.IL1_float_in,&log->I[0]))
+		return -1;
+	if(set_float_ptr(args->io.IL2_float_in,&log->I[1]))
+		return -1;
+	if(set_float_ptr(args->io.IL3_float_in,&log->I[2]))
+		return -1;
+
+	if(set_float_ptr(args->io.UL1_float_in,&log->U[0]))
+		return -1;
+	if(set_float_ptr(args->io.UL2_float_in,&log->U[1]))
+		return -1;
+	if(set_float_ptr(args->io.UL3_float_in,&log->U[2]))
+		return -1;
+*/
+	if(set_pointer_in_ptr(args->io.IL1_buf_ptr_in,(u32*)&log->IL_buf[0]))
+		return -1;
+	if(set_pointer_in_ptr(args->io.IL2_buf_ptr_in,(u32*)&log->IL_buf[1]))
+		return -1;
+	if(set_pointer_in_ptr(args->io.IL3_buf_ptr_in,(u32*)&log->IL_buf[2]))
+		return -1;
+
+	if(set_pointer_in_ptr(args->io.UL1_buf_ptr_in,(u32*)&log->UL_buf[0]))
+		return -1;
+	if(set_pointer_in_ptr(args->io.UL2_buf_ptr_in,(u32*)&log->UL_buf[1]))
+		return -1;
+	if(set_pointer_in_ptr(args->io.UL3_buf_ptr_in,(u32*)&log->UL_buf[2]))
+		return -1;
+
+	if(set_float_ptr(args->io.IL1_comp_float_out,&log->I_comp[0]))
+		return -1;
+	if(set_float_ptr(args->io.IL2_comp_float_out,&log->I_comp[1]))
+		return -1;
+	if(set_float_ptr(args->io.IL3_comp_float_out,&log->I_comp[2]))
+		return -1;
+
+	if(set_float_ptr(args->io.IL1_comp_prev_float_out,&log->I_comp_prev[0]))
+		return -1;
+	if(set_float_ptr(args->io.IL2_comp_prev_float_out,&log->I_comp_prev[1]))
+		return -1;
+	if(set_float_ptr(args->io.IL3_comp_prev_float_out,&log->I_comp_prev[2]))
+		return -1;
+
+	if(set_pointer_in_ptr(args->io.IL1_params_ptr_in,(u32 *)&log->I_params[0]))
+		return -1;
+	if(set_pointer_in_ptr(args->io.IL2_params_ptr_in,(u32 *)&log->I_params[1]))
+		return -1;
+	if(set_pointer_in_ptr(args->io.IL3_params_ptr_in,(u32 *)&log->I_params[2]))
+		return -1;
+
+	if(set_pointer_in_ptr(args->io.UL1_params_ptr_in,(u32 *)&log->U_params[0]))
+		return -1;
+	if(set_pointer_in_ptr(args->io.UL2_params_ptr_in,(u32 *)&log->U_params[1]))
+		return -1;
+	if(set_pointer_in_ptr(args->io.UL3_params_ptr_in,(u32 *)&log->U_params[2]))
+		return -1;
+
+	//po staremu log->mul=args->params.k*args->params.c/2.0f*(1 / log->I_params[0]->znam_pierw);
+	log->mul=args->params.k*args->params.c/2.0f*((log->U_params[0]->znam_pierw/log->U_params[0]->znam_wtor)*(log->I_params[0]->znam_wtor/log->I_params[0]->znam_pierw));
+	return 0;
+}
+
+void cap_comp(void *arguments, void *logic)
+{
+	struct cap_comp_logic *log = (struct cap_comp_logic *)logic;
+	struct cap_comp_args *args = (struct cap_comp_args *)arguments;
+	u8 i;
+	short snum_next = bus_an_cur_sample_num;
+	short snum_cur,snum_prev;
+	short snum_next2, snum_cur2,snum_prev2;
+
+	snum_cur = snum_next - 1;
+	if(snum_cur < 0)
+		snum_cur = (SAMPLES_PER_MS*MAIN_FREQ_PERIOD_MS*2)-1;
+
+	snum_prev = snum_cur - 1;
+	if(snum_prev < 0)
+		snum_prev = (SAMPLES_PER_MS*MAIN_FREQ_PERIOD_MS*2)-1;
+
+	snum_next2 = snum_next-SAMPLES_PER_MS;
+	if(snum_next2 < 0)
+		snum_next2 = (SAMPLES_PER_MS*MAIN_FREQ_PERIOD_MS*2)-SAMPLES_PER_MS;
+
+	snum_cur2 = snum_next2 - 1;
+	if(snum_cur2 < 0)
+		snum_cur2 = (SAMPLES_PER_MS*MAIN_FREQ_PERIOD_MS*2)-1;
+
+	snum_prev2 = snum_cur2 - 1;
+	if(snum_prev2 < 0)
+		snum_prev2 = (SAMPLES_PER_MS*MAIN_FREQ_PERIOD_MS*2)-1;
+
+
+	if(args->params.bits & 0x01)
+	{
+		for(i=0;i<3;i++)
+		{
+			float u_next = (((float)(log->UL_buf[i][snum_next] - 0x7FFF)) - log->U_params[i]->offset ) * log->U_params[i]->multiplier;
+			float u_prev = (((float)(log->UL_buf[i][snum_prev] - 0x7FFF)) - log->U_params[i]->offset ) * log->U_params[i]->multiplier;
+			float i_cur= (((float)(log->IL_buf[i][snum_cur] - 0x7FFF)) - log->I_params[i]->offset ) * log->I_params[i]->multiplier;
+			*log->I_comp[i]=i_cur-((u_next-u_prev)*log->mul);
+
+			u_next = (((float)(log->UL_buf[i][snum_next2] - 0x7FFF)) - log->U_params[i]->offset ) * log->U_params[i]->multiplier;
+			u_prev = (((float)(log->UL_buf[i][snum_prev2] - 0x7FFF)) - log->U_params[i]->offset ) * log->U_params[i]->multiplier;
+			i_cur= (((float)(log->IL_buf[i][snum_cur2] - 0x7FFF)) - log->I_params[i]->offset ) * log->I_params[i]->multiplier;
+			*log->I_comp_prev[i]=i_cur-((u_next-u_prev)*log->mul);
+		}
+	}
+	else
+	{
+		for(i=0;i<3;i++)
+		{
+			*log->I_comp[i]=(((float)(log->IL_buf[i][snum_cur] - 0x7FFF)) - log->I_params[i]->offset ) * log->I_params[i]->multiplier;
+			*log->I_comp_prev[i]=(((float)(log->IL_buf[i][snum_cur2] - 0x7FFF)) - log->I_params[i]->offset ) * log->I_params[i]->multiplier;
+		}
+	}
+}

src/cap_comp.h

@@ -0,0 +1,64 @@
+/*
+ * cap_comp.h
+ *
+ *  Created on: 19-08-2019
+ *      Author: Krzysztof Jakubczyk
+ */
+
+#ifndef CAP_COMP_H_
+#define CAP_COMP_H_
+
+#include "tdefs.h"
+
+struct cap_comp_logic
+{
+	float *I_comp[3];
+	float *I_comp_prev[3];
+	u16 *IL_buf[3];
+	u16 *UL_buf[3];
+	struct analog_in_params *I_params[3];
+	struct analog_in_params *U_params[3];
+	float mul;
+};
+
+struct cap_comp_io
+{
+	u32 IL1_buf_ptr_in;
+	u32 IL1_params_ptr_in;
+	u32 IL2_buf_ptr_in;
+	u32 IL2_params_ptr_in;
+	u32 IL3_buf_ptr_in;
+	u32 IL3_params_ptr_in;
+	u32 UL1_buf_ptr_in;
+	u32 UL1_params_ptr_in;
+	u32 UL2_buf_ptr_in;
+	u32 UL2_params_ptr_in;
+	u32 UL3_buf_ptr_in;
+	u32 UL3_params_ptr_in;
+	u32 IL1_comp_float_out;
+	u32 IL2_comp_float_out;
+	u32 IL3_comp_float_out;
+	u32 IL1_comp_prev_float_out;
+	u32 IL2_comp_prev_float_out;
+	u32 IL3_comp_prev_float_out;
+}__attribute__((__packed__));
+
+
+struct cap_comp_params
+{
+	u32 bits;
+	double k;
+	double c;
+}__attribute__((__packed__));
+
+struct cap_comp_args
+{
+	struct cap_comp_io io;
+	struct cap_comp_params params;
+//	u16 crc;
+}__attribute__((__packed__));
+
+extern void cap_comp(void *args, void *logic);
+extern int cap_comp_initlog(void *arguments, void *logic);
+
+#endif

src/cfg_state.c

@@ -0,0 +1,27 @@
+/*
+ * cfg_state.c
+ *
+ *  Created on: 22-02-2017
+ *      Author:
+ */
+
+
+#include "cfg_state.h"
+
+#include "helper.h"
+
+int state_initlog(void *arguments, void *logic)
+{
+	struct state_args *args = (struct state_args *)arguments;
+	struct state_logic *log = (struct state_logic *)logic;
+
+	if(set_bit_ptr_mask(args->io.out,&log->out_bit,&log->out_bit_mask))
+		return -1;
+
+	if (args->params.bity)
+		*log->out_bit |= log->out_bit_mask;
+	else
+		*log->out_bit &= ~log->out_bit_mask;
+
+	return 0;
+}

src/cfg_state.h

@@ -0,0 +1,38 @@
+/*
+ * cfg_state.h
+ *
+ *  Created on: 22-02-2017
+ *      Author:
+ */
+
+#ifndef CFG_STATE_H_
+#define CFG_STATE_H_
+
+#include "tdefs.h"
+
+struct state_logic
+{
+	u8* out_bit;
+	u8 out_bit_mask;
+};
+
+
+struct state_params
+{
+    u32 bity;
+}__attribute__((__packed__));
+
+struct state_io
+{
+	u32 out;
+}__attribute__((__packed__));
+
+struct state_args
+{
+	struct state_io io;
+	struct state_params params;
+}__attribute__((__packed__));
+
+extern int state_initlog(void *arguments, void *logic);
+
+#endif /* CFG_STATE_H_ */

src/cfg_var.h

@@ -8,6 +8,8 @@
 #ifndef CFG_VAR_H_
 #define CFG_VAR_H_
 
+#include "misc.h"
+
 extern const struct config_lookup_table cfg_lut[];
 extern const unsigned int cfg_lut_elements;
 

src/chka.c

@@ -0,0 +1,239 @@
+/*
+ * chka.c
+ *
+ *  Created on: 07-03-2018
+ *      Author: Krzysztof Jakubczyk
+ */
+
+#include "tdefs.h"
+#include "misc.h"
+
+#include "chka.h"
+#include "helper.h"
+#include <math.h>
+
+int chka_initlog(void *arguments, void *logic)
+{
+	struct chka_args *args = (struct chka_args *)arguments;
+	struct chka_logic *log = (struct chka_logic *)logic;
+
+	if(set_bit_ptr_struct(args->io.stan_bl_in,&log->stan_bl))
+		return -1;
+	if(set_bit_ptr_struct(args->io.test_in,&log->test))
+		return -1;
+	if(set_bit_ptr_struct(args->io.zezw_l1_in,&log->zezw[0]))
+		return -1;
+	if(set_bit_ptr_struct(args->io.zezw_l2_in,&log->zezw[1]))
+		return -1;
+	if(set_bit_ptr_struct(args->io.zezw_l3_in,&log->zezw[2]))
+		return -1;
+	if(set_bit_ptr_struct(args->io.pl1_out,&log->P[0]))
+		return -1;
+	if(set_bit_ptr_struct(args->io.pl2_out,&log->P[1]))
+		return -1;
+	if(set_bit_ptr_struct(args->io.pl3_out,&log->P[2]))
+		return -1;
+	if(set_bit_ptr_struct(args->io.p3f_out,&log->P[3]))
+		return -1;
+	if(set_bit_ptr_struct(args->io.w3f_out,&log->W))
+		return -1;
+	if(set_bit_ptr_struct(args->io.z3f_out,&log->Z))
+		return -1;
+
+	if(set_float_ptr(args->io.wel1_float_in,&log->We[0]))
+		return -1;
+	if(set_float_ptr(args->io.wel2_float_in,&log->We[1]))
+		return -1;
+	if(set_float_ptr(args->io.wel3_float_in,&log->We[2]))
+		return -1;
+
+	log->Wn = args->params.Wn * args->params.Wn;
+	log->Wn_hyst = log->Wn * args->params.k * args->params.k;
+
+	log->t0=(u32)(args->params.t0*1000);
+	return 0;
+}
+
+void chka(void *arguments, void *logic)
+{
+	struct chka_logic *log = (struct chka_logic *)logic;
+	struct chka_args *args = (struct chka_args *)arguments;
+	float tplus_value;
+	u8 w,i;
+
+	if((args->params.bity & 0x00000001) && !((args->params.bity & 0x00000002) && check_struct(&log->stan_bl))) // ON && unblocked
+	{
+		for(i=0;i<3;i++)
+		{
+			if(!check_struct(&log->zezw[i]))
+			{
+				log->dw.p[i]=0;
+				log->dw.w[i]=0;
+				log->dw.t[i]=0;
+				log->dw.lp[i]=0;
+				log->dw.lp2[i]=0;
+				continue;
+			}
+
+			w=0;
+
+			sprawdz_P(&log->dw.p[i],
+				*log->We[i]>log->Wn,
+				*log->We[i]<log->Wn_hyst,
+				&log->dw.lp[i],
+				3,3);
+
+			if(log->dw.p[i])
+			{
+				if(args->params.typ_chki == CHKA_SIL_ZAL)
+				{
+					tplus_value=sqrtf(*log->We[i]);
+					tplus_value/=args->params.Wn;
+					tplus_value=powf(tplus_value,(float)args->params.n);
+					tplus_value-=1;
+
+					if(!tplus_value || tplus_value<0)
+						tplus_value=0.0000001;
+					tplus_value=args->params.tm/tplus_value;
+					tplus_value*=(1000/LOOP_CYCLE_MS);
+
+					if(tplus_value)
+					{
+						tplus_value=1000000000/tplus_value;
+						log->dw.t[i]+=tplus_value;
+					}
+					else
+						log->dw.t[i]=1000000000;
+
+
+					if(log->dw.t[i]>=1000000000)
+					{
+						log->dw.t[i]=1000000000;
+						w=1;
+					}
+					else
+						w=0;
+				}
+				else if(args->params.typ_chki == CHKA_STALA)
+				{
+					w=1;
+ 				}
+				else if(args->params.typ_chki == CHKA_IDMT)
+				{
+					tplus_value=sqrtf(*log->We[i]);
+					tplus_value/=args->params.Wn;
+					tplus_value=powf(tplus_value,(float)args->params.n);
+					tplus_value-=1;
+
+					if(!tplus_value || tplus_value<0)
+						tplus_value=0.0000001;
+					tplus_value=args->params.tm/tplus_value;
+					tplus_value*=(1000/LOOP_CYCLE_MS);
+
+					if(tplus_value)
+					{
+						tplus_value=1000000000/tplus_value;
+						log->dw.t[i]+=tplus_value;
+					}
+					else
+						log->dw.t[i]=1000000000;
+
+
+					if(log->dw.t[i]>=1000000000)
+					{
+						log->dw.t[i]=1000000000;
+						w=1;
+					}
+					else
+						w=0;
+				}
+			}
+			else
+			{
+				if(args->params.typ_chki == CHKA_IDMT)
+				{
+					tplus_value=sqrtf(*log->We[i]);
+					tplus_value/=args->params.Wn;
+					tplus_value=powf(tplus_value,(float)args->params.n);
+					tplus_value=(1-tplus_value);
+
+					if(!tplus_value || tplus_value<0)
+						tplus_value=0.0000001;
+					tplus_value=args->params.tm/tplus_value;
+					tplus_value*=(1000/LOOP_CYCLE_MS);
+
+					if(tplus_value)
+					{
+						tplus_value=1000000000/tplus_value;
+						if(tplus_value<=log->dw.t[i])
+							log->dw.t[i]-=tplus_value;
+						else
+							log->dw.t[i]=0;
+					}
+					else
+						log->dw.t[i]=0;
+				}
+				else
+					log->dw.t[i]=0;
+			}
+
+			if(w)
+			{
+				if(log->dw.lp2[i]>log->t0)
+					log->dw.w[i]=1;
+				else
+					log->dw.lp2[i]+=LOOP_CYCLE_MS;
+			}
+			else
+			{
+				log->dw.lp2[i]=0;
+				log->dw.w[i]=0;
+			}
+		}
+
+		if(args->params.bity & 0x00000004) // OR logic
+		{
+			log->dw.w[3]=log->dw.w[0]||log->dw.w[1]||log->dw.w[2];
+			log->dw.p[3]=log->dw.p[0]||log->dw.p[1]||log->dw.p[2];
+		}
+		else
+		{
+			log->dw.w[3]=log->dw.w[0]&&log->dw.w[1]&&log->dw.w[2];
+			log->dw.p[3]=log->dw.p[0]&&log->dw.p[1]&&log->dw.p[2];
+		}
+
+
+		if(check_struct(&log->test))
+		{
+			log->dw.p[0]=1;
+			log->dw.p[1]=1;
+			log->dw.p[2]=1;
+			log->dw.p[3]=1;
+			log->dw.w[0]=1;
+			log->dw.w[1]=1;
+			log->dw.w[2]=1;
+			log->dw.w[3]=1;
+		}
+
+
+		check_and_set_struct(log->dw.p[0],&log->P[0]);
+		check_and_set_struct(log->dw.p[1],&log->P[1]);
+		check_and_set_struct(log->dw.p[2],&log->P[2]);
+		check_and_set_struct(log->dw.p[3],&log->P[3]);
+		check_and_set_struct(log->dw.w[3],&log->Z);
+
+		if(args->params.bity & 0x00000008) // na wylacz
+		{
+			check_and_set_struct(log->dw.w[3],&log->W);
+		}
+	}
+	else
+	{
+		clear_struct(&log->P[0]);
+		clear_struct(&log->P[1]);
+		clear_struct(&log->P[2]);
+		clear_struct(&log->P[3]);
+		clear_struct(&log->W);
+		clear_struct(&log->Z);
+	}
+}

src/chka.h

@@ -0,0 +1,82 @@
+/*
+ * chka.h
+ *
+ *  Created on: 07-03-2018
+ *      Author: Krzysztof Jakubczyk
+ */
+
+#ifndef CHKA_H_
+#define CHKA_H_
+
+#include "tdefs.h"
+#include "helper.h"
+
+#define CHKA_SIL_ZAL	0
+#define CHKA_STALA		1
+#define CHKA_IDMT		2
+
+struct dane_wewnetrzne_chka
+{
+		short lp[3]; ///<licznik filtracji pobudzen
+		u32 lp2[3]; ///<licznik filtracji pobudzen
+		u8 p[4];
+		u8 w[4];
+		u32 t[3];
+};
+
+struct chka_logic
+{
+	struct binary_io stan_bl;
+	struct binary_io test;
+	struct binary_io P[4];
+	struct binary_io W;
+	struct binary_io Z;
+	struct binary_io zezw[3];
+
+	float *We[3];
+	float Wn;
+	float Wn_hyst;
+	u32 t0;
+	struct dane_wewnetrzne_chka dw;
+};
+
+struct chka_io
+{
+	u32 stan_bl_in;
+	u32 test_in;
+	u32 wel1_float_in;
+	u32 zezw_l1_in;
+	u32 wel2_float_in;
+	u32 zezw_l2_in;
+	u32 wel3_float_in;
+	u32 zezw_l3_in;
+	u32 pl1_out;
+	u32 pl2_out;
+	u32 pl3_out;
+	u32 p3f_out;
+	u32 z3f_out;
+	u32 w3f_out;
+}__attribute__((__packed__));
+
+struct chka_params
+{
+	u32 bity;
+	u32 typ_chki;
+	double Wn;
+	double tm;
+	double n;
+	double t0;
+	double k;
+}__attribute__((__packed__));
+
+struct chka_args
+{
+	struct chka_io io;
+	struct chka_params params;
+//	u16 crc;
+}__attribute__((__packed__));
+
+extern int chka_initlog(void *arguments, void *logic);
+extern void chka(void *arguments, void *logic);
+
+#endif /* CHKA_H_ */

src/chka_ieee.c

@@ -0,0 +1,327 @@
+/*
+ * chka_ieee.c
+ *
+ *  Created on: 08-08-2018
+ *      Author: Krzysztof Jakubczyk
+ */
+
+#include "tdefs.h"
+#include "misc.h"
+#include "helper.h"
+
+#include "chka_ieee.h"
+#include <math.h>
+
+int chka_ieee_initlog(void *arguments, void *logic)
+{
+	struct chka_ieee_args *args = (struct chka_ieee_args *)arguments;
+	struct chka_ieee_logic *log = (struct chka_ieee_logic *)logic;
+
+	if(set_bit_ptr_struct(args->io.stan_bl_in,&log->stan_bl))
+		return -1;
+	if(set_bit_ptr_struct(args->io.test_in,&log->test))
+		return -1;
+	if(set_bit_ptr_struct(args->io.zezw_l1_in,&log->zezw[0]))
+		return -1;
+	if(set_bit_ptr_struct(args->io.zezw_l2_in,&log->zezw[1]))
+		return -1;
+	if(set_bit_ptr_struct(args->io.zezw_l3_in,&log->zezw[2]))
+		return -1;
+	if(set_bit_ptr_struct(args->io.pl1_out,&log->P[0]))
+		return -1;
+	if(set_bit_ptr_struct(args->io.pl2_out,&log->P[1]))
+		return -1;
+	if(set_bit_ptr_struct(args->io.pl3_out,&log->P[2]))
+		return -1;
+	if(set_bit_ptr_struct(args->io.p3f_out,&log->P[3]))
+		return -1;
+	if(set_bit_ptr_struct(args->io.w3f_out,&log->W))
+		return -1;
+	if(set_bit_ptr_struct(args->io.z3f_out,&log->Z))
+		return -1;
+	if(set_bit_ptr_struct(args->io.relax_out,&log->relax))
+		return -1;
+
+	if(set_float_ptr(args->io.wel1_float_in,&log->We[0]))
+		return -1;
+	if(set_float_ptr(args->io.wel2_float_in,&log->We[1]))
+		return -1;
+	if(set_float_ptr(args->io.wel3_float_in,&log->We[2]))
+		return -1;
+
+	log->Wn = args->params.Wn * args->params.Wn;
+	log->Wn_hyst = log->Wn * args->params.kp * args->params.kp;
+
+	/// predefined curves
+	if(args->params.typ_chki == CHKA_INVERSE)
+	{
+		args->params.typ_chki=CHKA_SIL_ZAL;
+		args->params.k=0.14;
+		args->params.c=0;
+		args->params.alfa=0.02;
+		args->params.tr=0;
+	}
+	else if(args->params.typ_chki == CHKA_VERY_INVERSE)
+	{
+		args->params.typ_chki=CHKA_SIL_ZAL;
+		args->params.k=13.5;
+		args->params.c=0;
+		args->params.alfa=1;
+		args->params.tr=0;
+	}
+	else if(args->params.typ_chki == CHKA_EXTREMELY_INVERSE)
+	{
+		args->params.typ_chki=CHKA_SIL_ZAL;
+		args->params.k=80;
+		args->params.c=0;
+		args->params.alfa=2;
+		args->params.tr=0;
+	}
+	else if(args->params.typ_chki == CHKA_IEEE_MODERATELY_INVERSE)
+	{
+		args->params.typ_chki=CHKA_IDMT;
+		args->params.k=0.0515;
+		args->params.c=0.1140;
+		args->params.alfa=0.02;
+		args->params.tr=4.85;
+		log->ieee_mi=1;
+	}
+	else if(args->params.typ_chki == CHKA_IEEE_VERY_INVERSE)
+	{
+		args->params.typ_chki=CHKA_IDMT;
+		args->params.k=19.61;
+		args->params.c=0.491;
+		args->params.alfa=2;
+		args->params.tr=21.6;
+	}
+	else if(args->params.typ_chki == CHKA_IEEE_EXTREMELY_INVERSE)
+	{
+		args->params.typ_chki=CHKA_IDMT;
+		args->params.k=28.2;
+		args->params.c=0.1217;
+		args->params.alfa=2;
+		args->params.tr=29.1;
+	}
+	///
+
+	if(args->params.typ_chki == CHKA_STALA)
+		log->t0=(u32)(args->params.c*1000);
+	else
+		log->t0=(u32)(args->params.c*1000*args->params.TMS);
+
+	log->kTMS=args->params.TMS*args->params.k;
+	log->trTMS=args->params.TMS*args->params.tr;
+	
+	log->t_blok_max = (u32)(args->params.t_blok * 1000);
+	log->t_blok = 0;
+	
+	return 0;
+}
+
+void chka_ieee(void *arguments, void *logic)
+{
+	struct chka_ieee_logic *log = (struct chka_ieee_logic *)logic;
+	struct chka_ieee_args *args = (struct chka_ieee_args *)arguments;
+	float tplus_value;
+	u8 w,i;
+
+	if((args->params.bity & 0x00000001) && !((args->params.bity & 0x00000002) && check_struct(&log->stan_bl))) // ON && unblocked
+	{
+		log->t_blok = 0;
+		
+		for(i=0;i<3;i++)
+		{
+			if(!check_struct(&log->zezw[i]))
+			{
+				log->dw.p[i]=0;
+				log->dw.w[i]=0;
+				log->dw.t[i]=0;
+				log->dw.lp[i]=0;
+				log->dw.lp2[i]=0;
+				continue;
+			}
+
+			w=0;
+
+			sprawdz_P(&log->dw.p[i],
+				*log->We[i]>log->Wn,
+				*log->We[i]<log->Wn_hyst,
+				&log->dw.lp[i],
+				3,3);
+
+			if(log->dw.p[i])
+			{
+				if(args->params.typ_chki == CHKA_SIL_ZAL)
+				{
+					tplus_value=sqrtf(*log->We[i]);
+					tplus_value/=args->params.Wn;
+					tplus_value=powf(tplus_value,(float)args->params.alfa);
+					tplus_value-=1;
+
+					if(!tplus_value || tplus_value<0)
+						tplus_value=0.0000001;
+					tplus_value=log->kTMS/tplus_value;
+					tplus_value*=(1000/LOOP_CYCLE_MS);
+
+					if(tplus_value)
+					{
+						tplus_value=1000000000/tplus_value;
+						log->dw.t[i]+=tplus_value;
+					}
+					else
+						log->dw.t[i]=1000000000;
+
+
+					if(log->dw.t[i]>=1000000000)
+					{
+						log->dw.t[i]=1000000000;
+						w=1;
+					}
+					else
+						w=0;
+				}
+				else if(args->params.typ_chki == CHKA_STALA)
+				{
+					w=1;
+ 				}
+				else if(args->params.typ_chki == CHKA_IDMT)
+				{
+					tplus_value=sqrtf(*log->We[i]);
+					tplus_value/=args->params.Wn;
+					tplus_value=powf(tplus_value,(float)args->params.alfa);
+					tplus_value-=1;
+
+					if(!tplus_value || tplus_value<0)
+						tplus_value=0.0000001;
+					tplus_value=log->kTMS/tplus_value;
+					tplus_value*=(1000/LOOP_CYCLE_MS);
+
+					if(tplus_value)
+					{
+						tplus_value=1000000000/tplus_value;
+						log->dw.t[i]+=tplus_value;
+					}
+					else
+						log->dw.t[i]=1000000000;
+
+
+					if(log->dw.t[i]>=1000000000)
+					{
+						log->dw.t[i]=1000000000;
+						w=1;
+					}
+					else
+						w=0;
+				}
+			}
+			else
+			{
+				if(args->params.typ_chki == CHKA_IDMT)
+				{
+					tplus_value=sqrtf(*log->We[i]);
+					tplus_value/=args->params.Wn;
+					if(log->ieee_mi)
+						tplus_value=powf(tplus_value,(float)2.00);
+					else
+						tplus_value=powf(tplus_value,(float)args->params.alfa);
+
+					tplus_value=(1-tplus_value);
+
+					if(!tplus_value || tplus_value<0)
+						tplus_value=0.0000001;
+					tplus_value=log->trTMS/tplus_value;
+					tplus_value*=(1000/LOOP_CYCLE_MS);
+
+					if(tplus_value)
+					{
+						tplus_value=1000000000/tplus_value;
+						if(tplus_value>=(float)log->dw.t[i])
+							log->dw.t[i]=0;
+						else
+							log->dw.t[i]-=tplus_value;
+					}
+					else
+						log->dw.t[i]=0;
+				}
+				else
+					log->dw.t[i]=0;
+			}
+
+			if(w)
+			{
+				if(log->dw.lp2[i]>log->t0)
+					log->dw.w[i]=1;
+				else
+					log->dw.lp2[i]+=LOOP_CYCLE_MS;
+			}
+			else
+			{
+				log->dw.lp2[i]=0;
+				log->dw.w[i]=0;
+			}
+		}
+
+		if(args->params.bity & 0x00000004) // OR logic
+		{
+			log->dw.w[3]=log->dw.w[0]||log->dw.w[1]||log->dw.w[2];
+			log->dw.p[3]=log->dw.p[0]||log->dw.p[1]||log->dw.p[2];
+		}
+		else
+		{
+			log->dw.w[3]=log->dw.w[0]&&log->dw.w[1]&&log->dw.w[2];
+			log->dw.p[3]=log->dw.p[0]&&log->dw.p[1]&&log->dw.p[2];
+		}
+
+
+		if(czy_test_R() && check_struct(&log->test))
+		{
+			log->dw.p[0]=1;
+			log->dw.p[1]=1;
+			log->dw.p[2]=1;
+			log->dw.p[3]=1;
+			log->dw.w[0]=1;
+			log->dw.w[1]=1;
+			log->dw.w[2]=1;
+			log->dw.w[3]=1;
+		}
+
+
+		check_and_set_struct(log->dw.p[0],&log->P[0]);
+		check_and_set_struct(log->dw.p[1],&log->P[1]);
+		check_and_set_struct(log->dw.p[2],&log->P[2]);
+		check_and_set_struct(log->dw.p[3],&log->P[3]);
+		check_and_set_struct(log->dw.w[3],&log->Z);
+
+		if(args->params.bity & 0x00000008) // na wylacz
+		{
+			check_and_set_struct(log->dw.w[3],&log->W);
+		}
+	}
+	else
+	{
+		if (log->t_blok < log->t_blok_max)
+		{
+			log->t_blok += LOOP_CYCLE_MS;				
+		}
+		else
+		{
+			for(i=0;i<3;i++)
+			{
+			log->dw.p[i]=0;
+			log->dw.w[i]=0;
+			log->dw.t[i]=0;
+			log->dw.lp2[i]=0;
+			}			
+		}
+		
+ 
+		clear_struct(&log->P[0]);
+		clear_struct(&log->P[1]);
+		clear_struct(&log->P[2]);
+		clear_struct(&log->P[3]);
+		clear_struct(&log->W);
+		clear_struct(&log->Z);
+	}
+
+	check_and_set_struct(!log->dw.t[0]&&!log->dw.t[1]&&!log->dw.t[2] && !((args->params.typ_chki == CHKA_STALA)&&w),&log->relax);
+}

src/chka_ieee.h

@@ -0,0 +1,101 @@
+/*
+ * chka_ieee.h
+ *
+ *  Created on: 08-08-2018
+ *      Author: Krzysztof Jakubczyk
+ */
+
+#ifndef CHKA_IEEE_H_
+#define CHKA_IEEE_H_
+
+#include "tdefs.h"
+#include "helper.h"
+
+//#include "pawel_usun_to.h"
+
+#define CHKA_SIL_ZAL	0
+#define CHKA_STALA		1
+#define CHKA_IDMT		2
+#define CHKA_INVERSE					3
+#define CHKA_VERY_INVERSE				4
+#define CHKA_EXTREMELY_INVERSE			5
+#define CHKA_IEEE_MODERATELY_INVERSE	6
+#define CHKA_IEEE_VERY_INVERSE			7
+#define CHKA_IEEE_EXTREMELY_INVERSE		8
+
+struct dane_wewnetrzne_chka_ieee
+{
+		short lp[3]; ///<licznik filtracji pobudzen
+		u32 lp2[3]; ///<licznik filtracji pobudzen
+		u8 p[4];
+		u8 w[4];
+		u32 t[3];
+};
+
+struct chka_ieee_logic
+{
+	struct binary_io stan_bl;
+	struct binary_io test;
+	struct binary_io P[4];
+	struct binary_io W;
+	struct binary_io Z;
+	struct binary_io zezw[3];
+	struct binary_io relax;
+
+	float *We[3];
+	float Wn;
+	float Wn_hyst;
+	u32 t0;
+	float kTMS;
+	float trTMS;
+	struct dane_wewnetrzne_chka_ieee dw;
+	u8 ieee_mi;
+	u32 t_blok;
+	u32 t_blok_max;
+};
+
+struct chka_ieee_io
+{
+	u32 stan_bl_in;
+	u32 test_in;
+	u32 wel1_float_in;
+	u32 zezw_l1_in;
+	u32 wel2_float_in;
+	u32 zezw_l2_in;
+	u32 wel3_float_in;
+	u32 zezw_l3_in;
+	u32 pl1_out;
+	u32 pl2_out;
+	u32 pl3_out;
+	u32 p3f_out;
+	u32 z3f_out;
+	u32 w3f_out;
+	u32 relax_out;
+}__attribute__((__packed__));
+
+struct chka_ieee_params
+{
+	u32 bity;
+	u32 typ_chki;
+	double Wn;
+	double tr;
+	double kp;
+	double TMS;
+	double k;
+	double c;
+	double alfa;
+	double t_blok;
+}__attribute__((__packed__));
+
+struct chka_ieee_args
+{
+	struct chka_ieee_io io;
+	struct chka_ieee_params params;
+//	u16 crc;
+}__attribute__((__packed__));
+
+extern int chka_ieee_initlog(void *arguments, void *logic);
+extern void chka_ieee(void *arguments, void *logic);
+
+#endif /* CHKA_IEEE_H_ */
+

src/cnt.c

@@ -0,0 +1,64 @@
+/*
+ * cnt.c
+ *
+ *  Created on: 10-06-2019
+ *      Author: Krzysztof Jakubczyk
+ */
+
+#include <math.h>
+
+#include "tdefs.h"
+#include "misc.h"
+
+#include "helper.h"
+#include "cnt.h"
+
+float cnt_mem[8] = {0,0,0,0,0,0,0,0};
+
+int cnt_initlog(void *arguments, void *logic)
+{
+	struct cnt_args *args = (struct cnt_args *)arguments;
+	struct cnt_logic *log = (struct cnt_logic *)logic;
+
+	if(set_bit_ptr_mask(args->io.Pwe_in,&log->Pwe,&log->Pwe_bit_mask))
+		return -1;
+
+	if(set_bit_ptr_mask(args->io.Kas_in,&log->Kas,&log->Kas_bit_mask))
+		return -1;
+
+	if(set_bit_ptr_mask(args->io.Pwy_out,&log->Pwy,&log->Pwy_bit_mask))
+		return -1;
+
+	if(set_float_ptr(args->io.Licznik_float_out,&log->licznik))
+		return -1;
+
+	log->on = args->params.bity & 0x0001;
+    log->Wr = args->params.Wr_; // przepisanie wartosci progowej PKW
+    log->id = args->params.id & 0x0007;
+
+//	Semaphore_post(spi_semaphore);
+
+	return 0;
+}
+
+void cnt(void *arguments, void *logic)
+{
+	struct cnt_logic *log = (struct cnt_logic *)logic;
+	struct cnt_args *args = (struct cnt_args *)arguments;
+
+	if(log->on)   // jesli funkcja przekaznika aktywna
+    {
+		if (*log->Kas & log->Kas_bit_mask)
+			cnt_mem[log->id]=args->params.kas;
+
+		if (*log->Pwe & log->Pwe_bit_mask)
+    		cnt_mem[log->id] += 1.0;
+
+		check_and_set_mask(cnt_mem[log->id]>=log->Wr,log->Pwy,log->Pwy_bit_mask);
+
+		*log->licznik = cnt_mem[log->id];
+    }
+	else
+        *log->licznik = 0;
+}
+

src/cnt.h

@@ -0,0 +1,57 @@
+/*
+ * cnt.h
+ *
+ *  Created on: 11-06-2019
+ *      Author: Krzysztof Jakubczyk
+ */
+
+#ifndef CNT_H_
+#define CNT_H_
+
+#include "tdefs.h"
+
+extern float cnt_mem[8];
+
+struct cnt_logic
+{
+	u8 *Pwe;
+	u8 Pwe_bit_mask;
+	u8 *Kas;
+	u8 Kas_bit_mask;
+	u8 *Pwy;
+	u8 Pwy_bit_mask;
+
+	float *licznik;
+
+	u16 Wr; ///< wartosc progowa sygnalizacji
+    u8 on; ///< wartosc nastawy aktywnosci PKWa 1- aktywny
+    u8 id;
+};
+
+struct cnt_io
+{
+	u32 Pwe_in;
+	u32 Kas_in;
+	u32 Pwy_out;
+	u32 Licznik_float_out;
+}__attribute__((__packed__));
+
+struct cnt_params
+{
+	u32 bity; ///< nastawy bitowe;
+	double Wr_; ///< wartosc progowa sygnalizacji
+	double kas; // wartosc przepisywana przy kasowaniu
+	u32 id; // id pkw od 0..7
+}__attribute__((__packed__));
+
+struct cnt_args
+{
+	struct cnt_io io;
+	struct cnt_params params;
+//	u16 crc;
+}__attribute__((__packed__));
+
+extern void cnt(void *args, void *logic);
+extern int cnt_initlog(void *arguments, void *logic);
+
+#endif /* CNT_H_ */

src/comm.h

@@ -8,8 +8,10 @@
 #ifndef COMM_H_
 #define COMM_H_
 
+/*
 #include <ti/ipc/MessageQ.h>
 #include <ti/sysbios/hal/Timer.h>
+*/
 #include "tdefs.h"
 
 #define DSP_CMD_INIT_COMM				0x01

src/comp_s.c

@@ -0,0 +1,84 @@
+/*
+ * comp_s.c
+ *
+ *  Created on: 08-05-2014
+ *      Author: Krzysztof Jakubczyk
+ */
+
+#include "tdefs.h"
+#include "misc.h"
+#include "helper.h"
+#include "analog_in.h"
+
+#include "comp_s.h"
+
+int comp_s_initlog(void *arguments, void *logic)
+{
+	struct comp_s_args *args = (struct comp_s_args *)arguments;
+	struct comp_s_logic *log = (struct comp_s_logic *)logic;
+	struct analog_in_params *an_params;
+	
+	u32 *an_params_ptr;
+	u32 *buf_ptr;
+
+	if(set_bit_ptr(args->io.P_out,&log->P,&log->P_bit_no))
+		return -1;
+
+	an_params_ptr = (u32 *)(log_manager.nets_data + (args->io.param_an_ptr_in >> 3));
+	if((u8*)an_params_ptr > (log_manager.nets_data+sizeof(log_manager.nets_data) - sizeof(void *)))
+		return -1;
+
+	if(!*an_params_ptr) // param in not connected or wrong elements order (analog_in should be run before)
+		return -1;
+			
+	an_params=(struct analog_in_params *)*an_params_ptr;
+
+	log->an_params=an_params;
+	
+	buf_ptr = (u32 *)(log_manager.nets_data + (args->io.buf_u16_ptr_in >> 3));
+	if((u8*)buf_ptr > (log_manager.nets_data+sizeof(log_manager.nets_data) - sizeof(void *)))
+		return -1;
+
+	if(!*buf_ptr) // param in not connected or wrong elements order (analog_in should be run before)
+		return -1;
+
+	log->buf_ptr=(u16*)*buf_ptr;
+
+	log->nast_.limit1_ = args->params.Wr_ *  args->params.mnoz_; // wyliczenie wartosci rozruchowej algorytmu
+	log->nast_.l_powt_pob = args->params.l_powt_pob;
+
+	return 0;
+}
+
+void comp_s(void *arguments, void *logic)
+{
+//	struct comp_s_args *args = (struct comp_s_args *)arguments;
+	struct comp_s_logic *log = (struct comp_s_logic *)logic;
+
+	short i,i1,i2;
+	float pr;
+
+	short pobud = 0;
+	i2 = bus_an_cur_sample_num;
+
+	for (i=0;i<(SAMPLES_PER_MS*MAIN_FREQ_PERIOD_MS);i++)
+	{
+		i1 = i2 - i;
+	    if(i1<0)
+	    	i1 += (SAMPLES_PER_MS*MAIN_FREQ_PERIOD_MS*2);
+		pr = (float)(log->buf_ptr[i1] - 0x7FFF);
+		pr*=log->an_params->multiplier;
+
+		if (pr < 0) pr = 0 - pr;
+		
+		if (pr > log->nast_.limit1_)
+			pobud ++;		
+		
+	}
+		if (pobud >=  log->nast_.l_powt_pob)
+			log->pob = 1;
+		else
+			log->pob = 0;
+
+		check_and_set(log->pob,log->P,log->P_bit_no);
+}

src/comp_s.h

@@ -0,0 +1,59 @@
+/*
+ * comp_s.h
+ *
+ *  Created on: 01-04-2022
+ *      Author: Pawel
+ */
+
+#ifndef COMP_S_H_
+#define COMP_S_H_
+
+#include "tdefs.h"
+//#include "pawel_usun_to.h"
+
+struct nastawy_przeliczone_comp_s
+{
+    float limit1_; ///< wartosc rozruchowa
+	short l_powt_pob;
+};
+
+struct comp_s_logic
+{
+	u16 *buf_ptr;
+	struct analog_in_params *an_params;
+	
+	u8 *P;
+	u8 P_bit_no;
+
+	struct nastawy_przeliczone_comp_s nast_;
+   	u8 pob;
+};
+
+struct comp_s_io
+{
+    u32 buf_u16_ptr_in;
+	u32 param_an_ptr_in;
+    u32 P_out;
+
+}__attribute__((__packed__));
+
+struct comp_s_params
+{
+    double Wr_; ///< wartosc nastawy rozruchowej przekaznika w krotnosciach wartosci znamionowej
+    //double kp_; ///< wartosc nastawy wspolczynnika powrotu
+    double mnoz_; ///< mnoznik wart_roz
+    u32 l_powt_pob;
+    //u32 l_powt_odp;
+}__attribute__((__packed__));
+
+struct comp_s_args
+{
+	struct comp_s_io io;
+	struct comp_s_params params;
+//	u16 crc;
+}__attribute__((__packed__));
+
+extern void comp_s(void *args, void *logic);
+extern int comp_s_initlog(void *arguments, void *logic);
+
+#endif /* COMP_S_H_ */

src/const_flt.c

@@ -0,0 +1,28 @@
+/*
+ * counter.c
+ *
+ *  Created on: 04-06-2018
+ *      Author: Krzysztof Jakubczyk
+ */
+
+#include <math.h>
+
+#include "tdefs.h"
+#include "misc.h"
+
+#include "helper.h"
+#include "const_flt.h"
+
+int const_flt_initlog(void *arguments, void *logic)
+{
+	struct const_flt_args *args = (struct const_flt_args *)arguments;
+	struct const_flt_logic *log = (struct const_flt_logic *)logic;
+
+	if(set_float_ptr(args->io.out_float_out,&log->out))
+		return -1;
+
+	*log->out=(float)args->params.val;
+
+	return 0;
+}
+

src/const_flt.h

@@ -0,0 +1,37 @@
+/*
+ * const_flt.h
+ *
+ *  Created on: 04-06-2017
+ *      Author: Krzysztof Jakubczyk
+ */
+
+#ifndef CONST_FLT_H_
+#define CONST_FLT_H_
+
+#include "tdefs.h"
+
+struct const_flt_logic
+{
+	float *out;
+};
+
+struct const_flt_io
+{
+	u32 out_float_out;
+}__attribute__((__packed__));
+
+struct const_flt_params
+{
+	double val;
+}__attribute__((__packed__));
+
+struct const_flt_args
+{
+	struct const_flt_io io;
+	struct const_flt_params params;
+//	u16 crc;
+}__attribute__((__packed__));
+
+extern int const_flt_initlog(void *arguments, void *logic);
+
+#endif /* CONST_FLT_H_ */

src/counter.c

@@ -0,0 +1,46 @@
+/*
+ * counter.c
+ *
+ *  Created on: 04-06-2018
+ *      Author: Krzysztof Jakubczyk
+ */
+
+#include <math.h>
+
+#include "tdefs.h"
+#include "misc.h"
+
+#include "helper.h"
+#include "counter.h"
+
+int counter_initlog(void *arguments, void *logic)
+{
+	struct counter_args *args = (struct counter_args *)arguments;
+	struct counter_logic *log = (struct counter_logic *)logic;
+
+	if(set_bit_ptr_struct(args->io.in_in,&log->in))
+		return -1;
+
+	if(set_bit_ptr_struct(args->io.clr_in,&log->clr))
+		return -1;
+
+	if(set_float_ptr(args->io.out_float_out,&log->out))
+		return -1;
+
+	return 0;
+}
+
+void counter(void *arguments, void *logic)
+{
+	struct counter_logic *log = (struct counter_logic *)logic;
+
+	if(!check_struct(&log->clr))
+	{
+		if(check_struct(&log->in))
+			log->cnt++;
+	}
+	else
+		log->cnt=0;
+
+	*log->out=(float)log->cnt;
+}

src/counter.h

@@ -0,0 +1,42 @@
+/*
+ * counter.h
+ *
+ *  Created on: 04-06-2017
+ *      Author: Krzysztof Jakubczyk
+ */
+
+#ifndef COUNTER_H_
+#define COUNTER_H_
+
+#include "tdefs.h"
+
+struct counter_logic
+{
+	struct binary_io in;
+	struct binary_io clr;
+	u32 cnt;
+	float *out;
+};
+
+struct counter_io
+{
+	u32 in_in;
+	u32 clr_in;
+	u32 out_float_out;
+}__attribute__((__packed__));
+
+struct counter_params
+{
+}__attribute__((__packed__));
+
+struct counter_args
+{
+	struct counter_io io;
+	struct counter_params params;
+//	u16 crc;
+}__attribute__((__packed__));
+
+extern void counter(void *args, void *logic);
+extern int counter_initlog(void *arguments, void *logic);
+
+#endif /* COUNTER_H_ */

src/ddr.c

@@ -0,0 +1,219 @@
+/*
+ * ddr.c
+ *
+ *  Created on: 26-05-2014
+ *      Author: KJ
+ */
+
+
+#include "tdefs.h"
+#include "misc.h"
+
+#include <ti/ipc/Notify.h>
+#include <string.h>
+#include "ddr.h"
+#include "ddr_drv.h"
+#include "rec_an.h"
+#include "rec_bin.h"
+#include "comm.h"
+#include "misc.h"
+#include "config.h"
+
+#pragma LOCATION(ddr_bank0,0xc4000000) // @ non-cached memory above 128MB
+volatile u8 ddr_bank0[DDR_REG_BANK_SIZE];
+#pragma LOCATION(ddr_bank1,0xc4100000) // @ non-cached memory above 128MB
+volatile u8 ddr_bank1[DDR_REG_BANK_SIZE];
+#pragma LOCATION(ddr_bank2,0xc4200000) // @ non-cached memory above 128MB
+volatile u8 ddr_bank2[DDR_REG_BANK_SIZE];
+#pragma LOCATION(ddr_bank3,0xc4300000) // @ non-cached memory above 128MB
+volatile u8 ddr_bank3[DDR_REG_BANK_SIZE];
+
+volatile struct ddr_reg_inf ddr_regs = {	.cur_reg_bank = 0,
+									.bank[0].data = (void*) ddr_bank0,
+									.bank[0].state = BANK_BUFFERING,
+									.bank[0].addr_offset = 0,
+									.bank[0].pre_trigger_cnt = 0,
+									.bank[0].post_trigger_cnt = 0,
+			 						.bank[0].total_cnt = 0,
+									.bank[1].data = (void*) ddr_bank1,
+									.bank[2].data = (void*) ddr_bank2,
+									.bank[3].data = (void*) ddr_bank3,
+								};
+
+int ddr_initlog(void *arguments, void *logic)
+{
+	struct ddr_args *args = (struct ddr_args *)arguments;
+	struct ddr_logic *log = (struct ddr_logic *)logic;
+
+	log->trigger_ptr = log_manager.nets_data + (args->io.trigger_in >> 3);
+	log->trigger_bit_no = args->io.trigger_in & 0x07;
+	if(log->trigger_ptr >= (log_manager.nets_data+sizeof(log_manager.nets_data)))
+		return -1;
+
+	switch((enum ddr_fs)args->params.f_sampling)
+	{
+		case Fs_100Hz:
+			log->decimation=10/LOOP_CYCLE_MS;
+			break;
+		case Fs_50Hz:
+			log->decimation=20/LOOP_CYCLE_MS;
+			break;
+		case Fs_10Hz:
+			log->decimation=100/LOOP_CYCLE_MS;
+			break;
+		case Fs_5Hz:
+			log->decimation=200/LOOP_CYCLE_MS;
+			break;
+		case Fs_1Hz:
+			log->decimation=1000/LOOP_CYCLE_MS;
+			break;
+		case Fs_0_5Hz:
+			log->decimation=2000/LOOP_CYCLE_MS;
+			break;
+		case Fs_0_1Hz:
+			log->decimation=10000/LOOP_CYCLE_MS;
+			break;
+		default:
+			log->decimation=10/LOOP_CYCLE_MS;
+			break;
+	}
+
+	log->pre_trigger_samples = args->params.pre_trigger_time / log->decimation;
+	if(args->params.pre_trigger_time)
+		log->pre_trigger_samples++;
+
+	log->post_trigger_samples = args->params.post_trigger_time / log->decimation;
+	if(args->params.post_trigger_time)
+		log->post_trigger_samples++;
+
+	log->max_reg_samples = args->params.max_reg_time / log->decimation;
+	if(args->params.max_reg_time)
+		log->max_reg_samples++;
+
+	return 0;
+}
+
+void ddr(void *arguments, void *logic)
+{
+	struct ddr_logic *log = (struct ddr_logic *)logic;
+	//struct ddr_args *args = (struct ddr_args *)arguments;
+	struct rec_an_logic *an_log;
+	struct rec_bin_logic *bin_log;
+	u16 sample_buf[(MAX_SAMPLE_SIZE/sizeof(u16)) + 8];
+	int i,bit_cnt=0,pos=0;
+	u8 new_sample=0;
+
+	if(ddr_drv_log_ptr == NULL) // ddr driver not initialized?
+		return;
+
+	if(!log->decimation_cnt--)
+	{
+		log->decimation_cnt=log->decimation;
+		new_sample=1;
+	}
+
+	switch(ddr_regs.bank[ddr_regs.cur_reg_bank].state)
+	{
+		case BANK_BUFFERING:
+			if(*log->trigger_ptr & (1<<log->trigger_bit_no))
+			{
+				ddr_regs.bank[ddr_regs.cur_reg_bank].state=BANK_TRIGGERED;
+				ddr_regs.bank[ddr_regs.cur_reg_bank].tr_time=(timesync_bits & CFG_TSYNC_USE_SWCLK)?cur_time_sw.tv_sec:cur_time.tv_sec;
+				ddr_regs.bank[ddr_regs.cur_reg_bank].tr_time_ms=(timesync_bits & CFG_TSYNC_USE_SWCLK)?cur_time_sw.tv_usec:cur_time.tv_usec;
+				ddr_regs.bank[ddr_regs.cur_reg_bank].sample_size=ddr_drv_log_ptr->sample_size;
+				ddr_regs.bank[ddr_regs.cur_reg_bank].an_count=ddr_drv_log_ptr->an_count;
+				ddr_regs.bank[ddr_regs.cur_reg_bank].bin_count=ddr_drv_log_ptr->bin_count;
+				ddr_regs.bank[ddr_regs.cur_reg_bank].post_trigger_cnt=0;
+				ddr_regs.bank[ddr_regs.cur_reg_bank].trigger_offset=ddr_regs.bank[ddr_regs.cur_reg_bank].addr_offset;
+				ddr_regs.bank[ddr_regs.cur_reg_bank].total_cnt=ddr_regs.bank[ddr_regs.cur_reg_bank].pre_trigger_cnt;
+			}
+			else
+			{
+				if(new_sample && ddr_regs.bank[ddr_regs.cur_reg_bank].pre_trigger_cnt<log->pre_trigger_samples)
+					ddr_regs.bank[ddr_regs.cur_reg_bank].pre_trigger_cnt++;
+			}
+			break;
+
+		case BANK_TRIGGERED:
+			if(new_sample)
+			{
+				if(ddr_regs.bank[ddr_regs.cur_reg_bank].total_cnt++>=log->max_reg_samples || ddr_regs.bank[ddr_regs.cur_reg_bank].post_trigger_cnt>=log->post_trigger_samples)
+				{
+					// send notify to ARM
+					ddr_regs.bank[ddr_regs.cur_reg_bank].state=BANK_FILLED;
+					ddr_regs.bank[ddr_regs.cur_reg_bank].decimation=log->decimation;
+					ddr_regs.cur_reg_bank++;
+					ddr_regs.cur_reg_bank%=DDR_MAX_REG_BANKS;
+					ddr_regs.bank[ddr_regs.cur_reg_bank].state=BANK_BUFFERING;
+					ddr_regs.bank[ddr_regs.cur_reg_bank].addr_offset=0;
+					ddr_regs.bank[ddr_regs.cur_reg_bank].post_trigger_cnt=0;
+					ddr_regs.bank[ddr_regs.cur_reg_bank].pre_trigger_cnt=0;
+					ddr_regs.bank[ddr_regs.cur_reg_bank].trigger_offset=0;
+					ddr_regs.bank[ddr_regs.cur_reg_bank].total_cnt=0;
+					logman_notify|=LOGMAN_NOTIFY_NEW_DDR;
+//					Notify_sendEvent(notify.remoteProcId,notify.lineId,notify.eventId, NOTIFY_NEW_DDR_REG, TRUE);
+				}
+				else
+				{
+					if(*log->trigger_ptr & (1<<log->trigger_bit_no))
+						ddr_regs.bank[ddr_regs.cur_reg_bank].post_trigger_cnt=0;
+					else
+						ddr_regs.bank[ddr_regs.cur_reg_bank].post_trigger_cnt++;
+				}
+			}
+			break;
+
+		case BANK_EMPTY:
+		case BANK_FILLED:
+		default:
+			ddr_regs.bank[ddr_regs.cur_reg_bank].state=BANK_BUFFERING;
+			ddr_regs.bank[ddr_regs.cur_reg_bank].addr_offset=0;
+			ddr_regs.bank[ddr_regs.cur_reg_bank].post_trigger_cnt=0;
+			ddr_regs.bank[ddr_regs.cur_reg_bank].pre_trigger_cnt=0;
+			ddr_regs.bank[ddr_regs.cur_reg_bank].trigger_offset=0;
+			ddr_regs.bank[ddr_regs.cur_reg_bank].total_cnt=0;
+			break;
+	}
+
+
+
+//
+//  will be overwritten by ARM
+//	*((u32 *)&sample_buf[0]) = 0; // sample number 1..n
+//	*((u32 *)&sample_buf[2]) = 0; // time stamp 0..n*1ms @ 1 kHz
+//
+	if(new_sample)
+	{
+
+		pos = 4;
+
+		for(i=0;i<ddr_drv_log_ptr->an_count;i++)
+		{
+			an_log = (struct rec_an_logic *)log_manager.log_element[ddr_drv_log_ptr->element_num[i] & 0x3FFF].fun_log_ptr;
+			sample_buf[pos]=*an_log->in_ptr;
+			pos++;
+		}
+
+		sample_buf[pos]=0;
+
+		for(;i<(ddr_drv_log_ptr->an_count+ddr_drv_log_ptr->bin_count);i++)
+		{
+			bin_log = (struct rec_bin_logic *)log_manager.log_element[ddr_drv_log_ptr->element_num[i] & 0x3FFF].fun_log_ptr;
+
+			if(*bin_log->in_ptr & bin_log->in_bit_mask)
+				sample_buf[pos]|=(1<<(bit_cnt%16));
+
+			if(!(++bit_cnt%16) && bit_cnt)
+			{
+				pos++;
+				sample_buf[pos]=0;
+			}
+		}
+
+		if(ddr_regs.bank[ddr_regs.cur_reg_bank].addr_offset + ddr_drv_log_ptr->sample_size > DDR_REG_BANK_SIZE)
+			ddr_regs.bank[ddr_regs.cur_reg_bank].addr_offset=0;
+
+		memcpy((u8*)ddr_regs.bank[ddr_regs.cur_reg_bank].data+ddr_regs.bank[ddr_regs.cur_reg_bank].addr_offset,(void *)sample_buf,ddr_drv_log_ptr->sample_size);
+		ddr_regs.bank[ddr_regs.cur_reg_bank].addr_offset+=ddr_drv_log_ptr->sample_size;
+	}
+}

src/ddr.h

@@ -0,0 +1,102 @@
+/*
+ * ddr.h
+ *
+ *
+ *  Created on: 26-05-2017
+ *      Author: KJ
+ */
+
+#ifndef DDR_H_
+#define DDR_H_
+
+#include "tdefs.h"
+
+#define MAX_SAMPLE_SIZE		512
+
+
+#define DDR_REG_BANK_SIZE 		0x100000
+
+// bank states
+#define BANK_EMPTY				0x00
+#define BANK_BUFFERING			0x01
+#define BANK_TRIGGERED			0x02
+#define BANK_FILLED				0x03
+
+#define DDR_MAX_REG_BANKS		4
+
+struct ddr_reg_data
+{
+	u8 *data;
+	u8 state;
+	u32 addr_offset;
+	u32 pre_trigger_cnt;
+	u32 post_trigger_cnt;
+	u32 total_cnt;
+	u32 trigger_offset;
+	u32 tr_time;
+	u32 tr_time_ms;
+	u16 sample_size;
+	u8 an_count;
+	u16 bin_count;
+	u16 decimation;
+}__attribute__((__packed__));
+
+struct ddr_reg_inf
+{
+	u8 cur_reg_bank;
+	struct ddr_reg_data bank[DDR_MAX_REG_BANKS];
+}__attribute__((__packed__));
+
+enum ddr_fs
+{
+	Fs_100Hz,
+	Fs_50Hz,
+	Fs_10Hz,
+	Fs_5Hz,
+	Fs_1Hz,
+	Fs_0_5Hz,
+	Fs_0_1Hz
+};
+
+extern volatile u8 ddr_bank0[DDR_REG_BANK_SIZE];
+extern volatile u8 ddr_bank1[DDR_REG_BANK_SIZE];
+extern volatile u8 ddr_bank2[DDR_REG_BANK_SIZE];
+extern volatile u8 ddr_bank3[DDR_REG_BANK_SIZE];
+
+extern volatile struct ddr_reg_inf ddr_regs;
+
+struct ddr_logic
+{
+	u8 *trigger_ptr;
+	u8 trigger_bit_no;
+	u32 decimation;
+	u32 decimation_cnt;
+	u32 pre_trigger_samples;
+	u32 post_trigger_samples;
+	u32 max_reg_samples;
+};
+
+struct ddr_io
+{
+	u32 trigger_in;
+}__attribute__((__packed__));
+
+struct ddr_params
+{
+	u32 pre_trigger_time;
+	u32 post_trigger_time;
+	u32 max_reg_time;
+	u32 f_sampling;
+}__attribute__((__packed__));
+
+struct ddr_args
+{
+	struct ddr_io io;
+	struct ddr_params params;
+//	u16 crc;
+}__attribute__((__packed__));
+
+extern int ddr_initlog(void *args, void *logic);
+extern void ddr(void *args, void *logic);
+
+#endif /* DDR_H_ */

src/ddr_drv.c

@@ -0,0 +1,98 @@
+/*
+ * ddr_drv.c
+ *
+ *  Created on: 26-05-2017
+ *      Author: KJ
+ */
+
+
+#include "tdefs.h"
+#include "misc.h"
+
+#include <string.h>
+#include "rec_bin.h"
+#include "rec_float.h"
+#include "ddr.h"
+#include "ddr_drv.h"
+
+struct ddr_drv_logic *ddr_drv_log_ptr = NULL;
+
+int ddr_drv_initlog(void *arguments, void *logic)
+{
+	struct ddr_drv_logic *log = (struct ddr_drv_logic *)logic;
+	int i;
+
+	log->an_count=0;
+	log->bin_count=0;
+
+	for(i=0;i<MAX_LOG_ELEMENTS;i++) /* find analog channels */
+	{
+		struct rec_float_args *args;
+
+		args =  (struct rec_float_args *)log_manager.log_element[i].fun_args_ptr;
+
+		if((log_manager.log_element[i].flags & FUNCTION_IS_REC_FLOAT) && (args->params.bits & REC_CHAN_ENABLED_DDR))
+		{
+			if((u8 *)&log->element_num[log->an_count]>(u8 *)(log_manager.buf+sizeof(log_manager.buf)-sizeof(u16)))
+				return -1;
+
+			log->element_num[log->an_count]=i|((log_manager.log_element[i].flags & FUNCTION_IS_REC_FLOAT)?ELEMENT_IS_REC_FLOAT:0);
+			log->an_count++;
+		}
+	}
+
+	log->sample_size=log->an_count * sizeof(u16);
+
+	for(i=0;i<MAX_LOG_ELEMENTS;i++) /* find binary channels */
+	{
+		struct rec_bin_args *args;
+
+		args =  (struct rec_bin_args *)log_manager.log_element[i].fun_args_ptr;
+
+		if((log_manager.log_element[i].flags & FUNCTION_IS_REC_BIN) && (args->params.bits & REC_CHAN_ENABLED_DDR))
+		{
+			if((u8 *)&log->element_num[log->an_count+log->bin_count]>(u8 *)(log_manager.buf+sizeof(log_manager.buf)-sizeof(u16)))
+				return -1;
+
+			log->element_num[log->an_count+log->bin_count]=i;
+			log->bin_count++;
+		}
+	}
+
+	log->sample_size+=((log->bin_count/16)*2);
+	if(log->bin_count%16)
+		log->sample_size+=2;
+
+	log->sample_size+=8; // sample number && time stamp
+
+	if(log->sample_size>MAX_SAMPLE_SIZE)
+		return -1;
+
+	for(i=0;i<MAX_LOG_ELEMENTS;i++)
+	{
+		if(log_manager.log_element[i].flags & FUNCTION_IS_DDR)
+		{
+//			struct ddr_args *args;
+			struct ddr_logic *dlog;
+
+//			args = (struct ddr_args *)log_manager.log_element[i].fun_args_ptr;
+			dlog = (struct ddr_logic *)log_manager.log_element[i].fun_log_ptr;
+
+			if(dlog->max_reg_samples > ((DDR_REG_BANK_SIZE / log->sample_size) - 2))
+				dlog->max_reg_samples = ((DDR_REG_BANK_SIZE / log->sample_size) - 2);
+				//return -1;
+
+			if((dlog->post_trigger_samples + dlog->pre_trigger_samples) > dlog->max_reg_samples)
+			{
+				dlog->post_trigger_samples=dlog->max_reg_samples/2;
+				dlog->pre_trigger_samples=dlog->max_reg_samples/2;
+			//	return -1;
+			}
+		}
+	}
+
+	ddr_drv_log_ptr=(struct ddr_drv_logic *)logic;
+
+	return 0;
+}
+

src/ddr_drv.h

@@ -0,0 +1,44 @@
+/*
+ * ddr_drv.h
+ *
+ *
+ *  Created on: 26-05-2017
+ *      Author: KJ
+ */
+
+#ifndef DDR_DRV_H_
+#define DDR_DRV_H_
+
+#include "tdefs.h"
+#include "ddr.h"
+
+#define ELEMENT_IS_REC_FLOAT	0x8000
+
+extern struct ddr_drv_logic *ddr_drv_log_ptr;
+
+struct ddr_drv_logic
+{
+	u16 an_count;
+	u16 bin_count;
+	u16 sample_size;
+	u16 element_num[];
+};
+
+struct ddr_drv_io
+{
+}__attribute__((__packed__));
+
+struct ddr_drv_params
+{
+}__attribute__((__packed__));
+
+struct ddr_drv_args
+{
+	struct ddr_drv_io io;
+	struct ddr_drv_params params;
+//	u16 crc;
+}__attribute__((__packed__));
+
+extern int ddr_drv_initlog(void *args, void *logic);
+
+#endif /* DDR_DRV_H_ */

src/dec_month.c

@@ -0,0 +1,118 @@
+/*
+ * klapacz.c
+ *
+ *  Created on: 07-04-2014
+ *      Author: Krzysztof Jakubczyk
+ */
+
+#include "tdefs.h"
+#include "misc.h"
+
+#include "helper.h"
+#include "dec_month.h"
+#include <time.h>
+//volatile struct klapacz_args tkl;
+
+int dec_month_initlog(void *arguments, void *logic)
+{
+	struct dec_month_args *args = (struct dec_month_args *)arguments;
+	struct dec_month_logic *log = (struct dec_month_logic *)logic;
+
+	if(set_bit_ptr_struct(args->io.sty,&log->mon[0]))
+		return -1;
+	if(set_bit_ptr_struct(args->io.lut,&log->mon[1]))
+		return -1;
+	if(set_bit_ptr_struct(args->io.marz,&log->mon[2]))
+		return -1;
+	if(set_bit_ptr_struct(args->io.kwie,&log->mon[3]))
+		return -1;
+	if(set_bit_ptr_struct(args->io.maj,&log->mon[4]))
+		return -1;
+	if(set_bit_ptr_struct(args->io.czer,&log->mon[5]))
+		return -1;
+	if(set_bit_ptr_struct(args->io.lip,&log->mon[6]))
+		return -1;
+	if(set_bit_ptr_struct(args->io.sier,&log->mon[7]))
+		return -1;
+	if(set_bit_ptr_struct(args->io.wrz,&log->mon[8]))
+		return -1;
+	if(set_bit_ptr_struct(args->io.paz,&log->mon[9]))
+		return -1;
+	if(set_bit_ptr_struct(args->io.lis,&log->mon[10]))
+		return -1;
+	if(set_bit_ptr_struct(args->io.gru,&log->mon[11]))
+		return -1;
+	if(set_bit_ptr_struct(args->io.zima,&log->zima))
+		return -1;
+	if(set_bit_ptr_struct(args->io.lato,&log->lato))
+		return -1;
+
+	return 0;
+}
+
+extern void my_gmtime(const uint32_t *timer, struct tm *timep);
+extern uint8_t isindst(struct tm *tb, uint8_t cest_cet_n);
+
+void dec_month(void *arguments, void *logic)
+{
+//	struct dec_month_args *args = (struct dec_month_args *)arguments;
+	struct dec_month_logic *log = (struct dec_month_logic *)logic;
+    struct tm tim;
+    u8 i;
+
+	my_gmtime((const uint32_t*)&cur_time.tv_sec,&tim);
+
+	for(i=0;i<12;i++)
+		check_and_set_struct(tim.tm_mon==i,&log->mon[i]);
+
+	if(isindst(&tim,0))
+	{
+		set_struct(&log->lato);
+		clear_struct(&log->zima);
+	}
+	else
+	{
+		set_struct(&log->zima);
+		clear_struct(&log->lato);
+	}
+	/*u8 day_of_week;
+
+	day_of_week = (cur_time.tv_sec / 86400 + 4)%7;
+
+	check_and_set_struct((day_of_week==0),&log->niedz);
+	check_and_set_struct((day_of_week==1),&log->pon);
+	check_and_set_struct((day_of_week==2),&log->wt);
+	check_and_set_struct((day_of_week==3),&log->sr);
+	check_and_set_struct((day_of_week==4),&log->czw);
+	check_and_set_struct((day_of_week==5),&log->pt);
+	check_and_set_struct((day_of_week==6),&log->sob);
+	check_and_set_struct((day_of_week==7),&log->niedz);
+	*/
+
+	/*
+		local function GetMonth(seconds)
+	    local dayduration,year = 3600*24
+	    local days={31,0,31,30,31,30,31,31,30,31,30,31}
+	    for i=1970,10000 do -- For some reason too lazy to use while
+	        local yeardays = i%4 == 0 and i%100 ~= 0 and 366 or 365
+	        local yearduration = dayduration * yeardays
+	        if yearduration < seconds then
+	            seconds = seconds - yearduration
+	        else
+	            year = i break
+	        end
+	    end
+	    days[2]=(year%4==0) and 29 or 28
+	    seconds = seconds%(365*24*3600)
+	    for i=1,12 do
+	        if seconds>days[i]*dayduration then
+	            seconds=seconds-days[i]*dayduration
+	        else
+	            return --i + year*12  <-- If you want a unique ID
+	        end
+	    end
+	end
+	*/
+
+	
+}

src/dec_month.h

@@ -0,0 +1,57 @@
+/*
+ * klapacz.h
+ *
+ *  Created on: 07-04-2014
+ *      Author: Krzysztof Jakubczyk
+ */
+
+#ifndef DEC_MONTH_H_
+#define DEC_MONTH_H_
+
+#include "tdefs.h"
+
+struct dec_month_logic
+{
+
+	struct binary_io mon[12]; // one bit
+
+	struct binary_io zima; // one bit
+	struct binary_io lato; // one bit
+
+};
+
+struct dec_month_io
+{
+	u32 sty; // one bit
+	u32 lut; // one bit
+	u32 marz; // one bit
+	u32 kwie; // one bit
+	u32 maj; // one bit
+	u32 czer; // one bit
+	u32 lip; // one bit	
+	u32 sier; // one bit	
+	u32 wrz; // one bit	
+	u32 paz; // one bit	
+	u32 lis; // one bit	
+	u32 gru; // one bit
+
+	u32 zima; // one bit
+	u32 lato; // one bit
+	
+}__attribute__((__packed__));
+
+struct dec_month_params
+{
+}__attribute__((__packed__));
+
+struct dec_month_args
+{
+	struct dec_month_io io;
+	struct dec_month_params params;
+//	u16 crc;
+}__attribute__((__packed__));
+
+extern void dec_month(void *args, void *logic);
+extern int dec_month_initlog(void *args, void *logic);
+
+#endif /* DEC_MONTH_H_ */

src/demux8.c

@@ -0,0 +1,64 @@
+/*
+ * demux8.c
+ *
+ *  Created on: 22-05-2017
+ *      Author: Krzysztof Jakubczyk
+ */
+
+#include <math.h>
+
+#include "tdefs.h"
+#include "misc.h"
+
+#include "helper.h"
+#include "demux8.h"
+
+int demux8_initlog(void *arguments, void *logic)
+{
+	struct demux8_args *args = (struct demux8_args *)arguments;
+	struct demux8_logic *log = (struct demux8_logic *)logic;
+
+	if(set_bit_ptr_struct(args->io.we_in,&log->we))
+		return -1;
+	if(set_bit_ptr_struct(args->io.a0_in,&log->a0))
+		return -1;
+	if(set_bit_ptr_struct(args->io.a1_in,&log->a1))
+		return -1;
+	if(set_bit_ptr_struct(args->io.a2_in,&log->a2))
+		return -1;
+
+	if(set_bit_ptr_struct(args->io.wy1_out,&log->wy[0]))
+		return -1;
+	if(set_bit_ptr_struct(args->io.wy2_out,&log->wy[1]))
+		return -1;
+	if(set_bit_ptr_struct(args->io.wy3_out,&log->wy[2]))
+		return -1;
+	if(set_bit_ptr_struct(args->io.wy4_out,&log->wy[3]))
+		return -1;
+	if(set_bit_ptr_struct(args->io.wy5_out,&log->wy[4]))
+		return -1;
+	if(set_bit_ptr_struct(args->io.wy6_out,&log->wy[5]))
+		return -1;
+	if(set_bit_ptr_struct(args->io.wy7_out,&log->wy[6]))
+		return -1;
+	if(set_bit_ptr_struct(args->io.wy8_out,&log->wy[7]))
+		return -1;
+
+	return 0;
+}
+
+void demux8(void *arguments, void *logic)
+{
+	struct demux8_logic *log = (struct demux8_logic *)logic;
+	u8 choice,i;
+
+	choice = check_struct(&log->a0)?1:0;
+	choice |= check_struct(&log->a1)?2:0;
+	choice |= check_struct(&log->a2)?4:0;
+
+	for(i=0;i<8;i++)
+		clear_struct(&log->wy[i]);
+
+	if (check_struct(&log->we))
+		set_struct(&log->wy[choice]);
+}

src/demux8.h

@@ -0,0 +1,52 @@
+/*
+ * demux8.h
+ *
+ *  Created on: 22-05-2017
+ *      Author: Krzysztof Jakubczyk
+ */
+
+#ifndef DEMUX8_H_
+#define DEMUX8_H_
+
+#include "tdefs.h"
+
+struct demux8_logic
+{
+	struct binary_io we;
+	struct binary_io a0;
+	struct binary_io a1;
+	struct binary_io a2;
+	struct binary_io wy[8];
+};
+
+struct demux8_io
+{
+	u32 we_in;
+	u32 a0_in;
+	u32 a1_in;
+	u32 a2_in;
+	u32 wy1_out;
+	u32 wy2_out;
+	u32 wy3_out;
+	u32 wy4_out;
+	u32 wy5_out;
+	u32 wy6_out;
+	u32 wy7_out;
+	u32 wy8_out;
+}__attribute__((__packed__));
+
+struct demux8_params
+{
+}__attribute__((__packed__));
+
+struct demux8_args
+{
+	struct demux8_io io;
+	struct demux8_params params;
+//	u16 crc;
+}__attribute__((__packed__));
+
+extern void demux8(void *args, void *logic);
+extern int demux8_initlog(void *arguments, void *logic);
+
+#endif /* DEMUX8_H_ */

src/destream.c

@@ -0,0 +1,58 @@
+/*
+ * destream.c
+ *
+ *  Created on: 23-04-2019
+ *      Author: Krzysztof Jakubczyk
+ */
+
+#include <math.h>
+
+#include "tdefs.h"
+#include "misc.h"
+
+#include "helper.h"
+#include "destream.h"
+#include "analog_in.h"
+
+int destream_initlog(void *arguments, void *logic)
+{
+	struct destream_args *args = (struct destream_args *)arguments;
+	struct destream_logic *log = (struct destream_logic *)logic;
+	u8 i;
+
+	if(set_pointer_in_ptr(args->io.stream_ptr_in,(u32*)&log->stream))
+		return -1;
+
+	if(set_float_ptr(args->io.A1L1_float_out,&log->A[0]))
+		return -1;
+	if(set_float_ptr(args->io.A1L2_float_out,&log->A[1]))
+		return -1;
+	if(set_float_ptr(args->io.A1L3_float_out,&log->A[2]))
+		return -1;
+	if(set_float_ptr(args->io.snum_float_out,&log->snum))
+		return -1;
+
+	for(i=0;i<16;i++)
+		if(set_bit_ptr_struct(args->io.b_out[i],&log->b[i]))
+			return -1;
+
+	return 0;
+}
+
+void destream(void *arguments, void *logic)
+{
+	struct destream_logic *log = (struct destream_logic *)logic;
+//	struct destream_args *args = (struct mkstream_args *)arguments;
+
+	u32 i;
+
+	for(i=0;i<3;i++)
+	{
+		*log->A[i]=log->stream->A[i];
+		*log->snum=(float)log->stream->sample_stamp;
+	}
+
+	for(i=0;i<16;i++)
+		check_and_set_struct(log->stream->bits & (1<<i),&log->b[i]);
+
+}

src/destream.h

@@ -0,0 +1,52 @@
+/*
+ * destream.h
+ *
+ *  Created on: 23-04-2019
+ *      Author: Krzysztof Jakubczyk
+ */
+
+#ifndef DESTREAM_H_
+#define DESTREAM_H_
+
+#include "tdefs.h"
+#include "analog_in.h"
+#include "mkstream.h"
+#include "helper.h"
+
+struct destream_logic
+{
+	float *A[3];
+	float *snum;
+
+	struct stream_frame *stream;
+	struct binary_io b[16];
+};
+
+struct destream_io
+{
+	u32 stream_ptr_in;
+
+	u32 A1L1_float_out;
+	u32 A1L2_float_out;
+	u32 A1L3_float_out;
+	u32 snum_float_out;
+	u32 b_out[16];
+}__attribute__((__packed__));
+
+
+struct destream_params
+{
+
+}__attribute__((__packed__));
+
+struct destream_args
+{
+	struct destream_io io;
+	struct destream_params params;
+//	u16 crc;
+}__attribute__((__packed__));
+
+extern void destream(void *args, void *logic);
+extern int destream_initlog(void *arguments, void *logic);
+
+#endif

src/dev_ctrl.c

@@ -0,0 +1,258 @@
+/*
+ * dev_ctrl.c
+ *
+ *  Created on: 07-02-2017
+ *      Author: Krzysztof Jakubczyk
+ */
+
+#include "tdefs.h"
+#include "misc.h"
+
+#include "dev_ctrl.h"
+#include "helper.h"
+
+u32 dev_ctrl_state = 0;
+u32 powered_off=220;
+u32 service_mode = 0;
+
+int dev_ctrl_initlog(void *arguments, void *logic)
+{
+	struct dev_ctrl_args *args = (struct dev_ctrl_args *)arguments;
+	struct dev_ctrl_logic *log = (struct dev_ctrl_logic *)logic;
+
+	if(set_bit_ptr_mask(args->io.test_we_in,&log->test_we,&log->test_we_bit_mask))
+		return -1;
+	if(set_bit_ptr_mask(args->io.test_wy_in,&log->test_wy,&log->test_wy_bit_mask))
+		return -1;
+	if(set_bit_ptr_mask(args->io.test_log_in,&log->test_log,&log->test_log_bit_mask))
+		return -1;
+	if(set_bit_ptr_mask(args->io.blok_wy_in,&log->blok_wy,&log->blok_wy_bit_mask))
+		return -1;
+	if(set_bit_ptr_mask(args->io.test_an_in,&log->test_an,&log->test_an_bit_mask))
+		return -1;
+	if(set_bit_ptr_struct(args->io.pps2_in,&log->pps2))
+		return -1;
+	if(set_bit_ptr_struct(args->io.service_mode_in,&log->service))
+		return -1;
+	if(set_bit_ptr_mask(args->io.pwr1_ok_out,&log->pwr1_ok,&log->pwr1_ok_bit_mask))
+		return -1;
+	if(set_bit_ptr_mask(args->io.pwr2_ok_out,&log->pwr2_ok,&log->pwr2_ok_bit_mask))
+		return -1;
+	if(set_bit_ptr_mask(args->io.pwr2_ok_out,&log->pwr2_ok,&log->pwr2_ok_bit_mask))
+		return -1;
+	if(set_bit_ptr_mask(args->io.nowe_nast_out,&log->nowe_nast,&log->nowe_nast_bit_mask))
+		return -1;
+	if(set_bit_ptr_mask(args->io.blad_konf_out,&log->blad_konf,&log->blad_konf_bit_mask))
+		return -1;
+	if(set_bit_ptr_mask(args->io.blad_sd_out,&log->blad_sd,&log->blad_sd_bit_mask))
+		return -1;
+
+	if(set_bit_ptr_struct(args->io.mgb_ch1_act_out,&log->mgb_ch[0]))
+		return -1;
+	if(set_bit_ptr_struct(args->io.mgb_ch2_act_out,&log->mgb_ch[1]))
+		return -1;
+	if(set_bit_ptr_struct(args->io.mgb_ch3_act_out,&log->mgb_ch[2]))
+		return -1;
+	if(set_bit_ptr_struct(args->io.mgb_ch4_act_out,&log->mgb_ch[3]))
+		return -1;
+	if(set_bit_ptr_struct(args->io.mgb_ch5_act_out,&log->mgb_ch[4]))
+		return -1;
+	if(set_bit_ptr_struct(args->io.mgb_ch6_act_out,&log->mgb_ch[5]))
+		return -1;
+	if(set_bit_ptr_struct(args->io.mgb_ch7_act_out,&log->mgb_ch[6]))
+		return -1;
+	if(set_bit_ptr_struct(args->io.mgb_ch8_act_out,&log->mgb_ch[7]))
+		return -1;
+
+	if(set_bit_ptr_struct(args->io.mki_zp6_act_out,&log->mki_zp6))
+		return -1;
+	if(set_bit_ptr_struct(args->io.mki_iec1_act_out,&log->mki_iec[0]))
+		return -1;
+	if(set_bit_ptr_struct(args->io.mki_iec2_act_out,&log->mki_iec[1]))
+		return -1;
+	if(set_bit_ptr_struct(args->io.mki_iec3_act_out,&log->mki_iec[2]))
+		return -1;
+	if(set_bit_ptr_struct(args->io.mki_iec4_act_out,&log->mki_iec[3]))
+		return -1;
+
+	if(set_bit_ptr_struct(args->io.pps_ok_out,&log->pps_ok))
+		return -1;
+	if(set_bit_ptr_struct(args->io.ptp_ok_out,&log->ptp_ok))
+		return -1;
+	if(set_bit_ptr_struct(args->io.ntp_ok_out,&log->ntp_ok))
+		return -1;
+	if(set_bit_ptr_struct(args->io.irigb_fix_ok_out,&log->irigb_fix_ok))
+		return -1;
+	if(set_bit_ptr_struct(args->io.iec_err_out,&log->iec_err))
+		return -1;
+	if(set_bit_ptr_struct(args->io.pps_sw_out,&log->pps_sw))
+		return -1;
+	if(set_float_ptr(args->io.sat_cnt_float_out,&log->sat_cnt))
+		return -1;
+
+	dev_ctrl_state&=~DEV_CTRL_STATE_SD_ERR;
+	dev_ctrl_state&=~DEV_CTRL_STATE_PPS_OK;
+	dev_ctrl_state&=~DEV_CTRL_STATE_PTP_OK;
+	dev_ctrl_state&=~DEV_CTRL_STATE_IRIGB_FIX_OK;
+
+	return 0;
+}
+
+void dev_ctrl(void *arguments, void *logic)
+{
+	struct dev_ctrl_logic *log = (struct dev_ctrl_logic *)logic;
+
+	if(powered_off)
+	{
+		if(powered_off>=LOOP_CYCLE_MS)
+			powered_off-=LOOP_CYCLE_MS;
+		else
+			powered_off=0;
+	}
+	else
+	{
+		check_and_set_mask(!(IN_DATA01 & (1<<12)),log->pwr1_ok,log->pwr1_ok_bit_mask);
+		check_and_set_mask(!(IN_DATA01 & (1<<5)),log->pwr2_ok,log->pwr2_ok_bit_mask);
+	}
+
+	if(check_struct(&log->service))
+		service_mode=1;
+	else
+		service_mode=0;
+
+	if(*log->test_we & log->test_we_bit_mask)
+		dev_ctrl_state|=DEV_CTRL_STATE_TEST_IN;
+	else
+		dev_ctrl_state&=~DEV_CTRL_STATE_TEST_IN;
+
+	if(*log->test_wy & log->test_wy_bit_mask)
+		dev_ctrl_state|=DEV_CTRL_STATE_TEST_OUT;
+	else
+		dev_ctrl_state&=~DEV_CTRL_STATE_TEST_OUT;
+
+	if(*log->test_log & log->test_log_bit_mask)
+		dev_ctrl_state|=DEV_CTRL_STATE_TEST_LOG;
+	else
+		dev_ctrl_state&=~DEV_CTRL_STATE_TEST_LOG;
+
+	if(*log->blok_wy & log->blok_wy_bit_mask)
+		dev_ctrl_state|=DEV_CTRL_STATE_BLOCK_OUT;
+	else
+		dev_ctrl_state&=~DEV_CTRL_STATE_BLOCK_OUT;
+
+	if(*log->test_an & log->test_an_bit_mask)
+		dev_ctrl_state|=DEV_CTRL_STATE_TEST_AN;
+	else
+		dev_ctrl_state&=~DEV_CTRL_STATE_TEST_AN;
+
+
+	check_and_set_mask(dev_ctrl_state & DEV_CTRL_STATE_CFG_CHANGE,log->nowe_nast,log->nowe_nast_bit_mask);
+	dev_ctrl_state&=~DEV_CTRL_STATE_CFG_CHANGE;
+	check_and_set_mask(dev_ctrl_state & DEV_CTRL_STATE_CFG_ERR,log->blad_konf,log->blad_konf_bit_mask);
+	check_and_set_mask(dev_ctrl_state & DEV_CTRL_STATE_SD_ERR,log->blad_sd,log->blad_sd_bit_mask);
+}
+
+void dev_ctrl_20hz(void *arguments, void *logic)
+{
+	struct dev_ctrl_logic *log = (struct dev_ctrl_logic *)logic;
+	struct time_data irigb_time;
+	u8 i;
+
+	if(ic->sync_reg & 0xC000) // IRIG-B or PPS
+	{
+		log->pps_timeout_cnt2=0;
+
+		if(log->pps_timeout_cnt>100)
+			dev_ctrl_state|=DEV_CTRL_STATE_PPS_OK;
+		else
+			log->pps_timeout_cnt++;
+	}
+	else
+	{
+		log->pps_timeout_cnt=0;
+		if(log->pps_timeout_cnt2>100)
+			dev_ctrl_state&=~DEV_CTRL_STATE_PPS_OK;
+		else
+			log->pps_timeout_cnt2++;
+	}
+
+	if(ic->sync_reg & 0x4000)
+	{
+		irigb_time=irigb_process_frame();
+		if(timesync_method==SYNC_METHOD_IRIG_B || timesync_method==SYNC_METHOD_IRIG_B_ZPRAE || (timesync_method==SYNC_METHOD_CUSTOM && (timesync_bits & CFG_TSYNC_FROM_DSP)))
+		{
+			if(irigb_time.fix_sat & 0x10)
+			{
+				if(cur_time.tv_usec>50 && cur_time.tv_usec<950)
+					cur_time.tv_sec = irigb_time.secs;
+
+				if(cur_time_sw.tv_usec>50 && cur_time_sw.tv_usec<950)
+					cur_time_sw.tv_sec = irigb_time.secs;
+			}
+		}
+
+		if(irigb_time.fix_sat & 0x10)
+		{
+			log->fix_timeout_cnt2=0;
+			if(log->fix_timeout_cnt>100)
+				dev_ctrl_state|=DEV_CTRL_STATE_IRIGB_FIX_OK;
+			else
+				log->fix_timeout_cnt++;
+// zrobione juz wyzej - bez rozdzialu na irigb i irigb_zprae
+//			if((timesync_method==SYNC_METHOD_IRIG_B_ZPRAE || (timesync_method==SYNC_METHOD_CUSTOM && (timesync_bits & CFG_TSYNC_FROM_DSP))) && cur_time.tv_usec>50 && cur_time.tv_usec<950)
+//				cur_time.tv_sec = irigb_time.secs;
+
+			*log->sat_cnt=irigb_time.fix_sat & 0x0f;
+		}
+		else
+		{
+			*log->sat_cnt=0;
+			log->fix_timeout_cnt=0;
+			if(log->fix_timeout_cnt2>100)
+				dev_ctrl_state&=~DEV_CTRL_STATE_IRIGB_FIX_OK;
+			else
+				log->fix_timeout_cnt2++;
+		}
+	}
+	else
+	{
+		*log->sat_cnt=0;
+		log->fix_timeout_cnt=0;
+		if(log->fix_timeout_cnt2>100)
+			dev_ctrl_state&=~DEV_CTRL_STATE_IRIGB_FIX_OK;
+		else
+			log->fix_timeout_cnt2++;
+	}
+
+	if(pps3_timeout_cnt>60000)
+		clear_struct(&log->pps_sw);
+	else
+		set_struct(&log->pps_sw);
+
+	if(check_struct(&log->pps2))
+	{
+		if(!(ic->sync_reg & MKI_PPS_IN))
+			ic->sync_reg|=MKI_PPS_IN;
+	}
+	else
+	{
+		if(ic->sync_reg & MKI_PPS_IN)
+			ic->sync_reg&=~MKI_PPS_IN;
+	}
+
+	check_and_set_struct(dev_ctrl_state&DEV_CTRL_STATE_PPS_OK,&log->pps_ok);
+	check_and_set_struct(dev_ctrl_state&DEV_CTRL_STATE_PTP_OK,&log->ptp_ok);
+	check_and_set_struct(dev_ctrl_state&DEV_CTRL_STATE_NTP_OK,&log->ntp_ok);
+	check_and_set_struct(dev_ctrl_state&DEV_CTRL_STATE_IRIGB_FIX_OK,&log->irigb_fix_ok);
+	for(i=0;i<8;i++)
+		check_and_set_struct(dev_ctrl_state & (DEV_CTRL_STATE_MGB_CHAN1<<i),&log->mgb_ch[i]);
+
+	check_and_set_struct(dev_ctrl_state & (DEV_CTRL_STATE_MKI_CHAN_ZP),&log->mki_zp6);
+	check_and_set_struct(dev_ctrl_state & (DEV_CTRL_STATE_MKI_IEC_ERR),&log->iec_err);
+
+	check_and_set_struct(dev_ctrl_state & (DEV_CTRL_STATE_MKI_IEC_CHAN1),&log->mki_iec[0]);
+	check_and_set_struct(dev_ctrl_state & (DEV_CTRL_STATE_MKI_IEC_CHAN2),&log->mki_iec[1]);
+	check_and_set_struct(dev_ctrl_state & (DEV_CTRL_STATE_MKI_IEC_CHAN3),&log->mki_iec[2]);
+	check_and_set_struct(dev_ctrl_state & (DEV_CTRL_STATE_MKI_IEC_CHAN4),&log->mki_iec[3]);
+
+}

src/dev_ctrl.h

@@ -0,0 +1,142 @@
+/*
+ * dev_ctrl.h
+ *
+ *  Created on: 07-02-2017
+ *      Author: Krzysztof Jakubczyk
+ */
+
+#ifndef DEV_CTRL_H_
+#define DEV_CTRL_H_
+
+#include "tdefs.h"
+#include "helper.h"
+
+struct dev_ctrl_logic
+{
+	u8 *pwr1_ok;
+	u8 pwr1_ok_bit_mask;
+	u8 *pwr2_ok;
+	u8 pwr2_ok_bit_mask;
+	u8 *nowe_nast;
+	u8 nowe_nast_bit_mask;
+	u8 *blad_konf;
+	u8 blad_konf_bit_mask;
+	u8 *blad_sd;
+	u8 blad_sd_bit_mask;
+
+	u8 *test_we;
+	u8 test_we_bit_mask;
+	u8 *test_wy;
+	u8 test_wy_bit_mask;
+	u8 *test_log;
+	u8 test_log_bit_mask;
+	u8 *blok_wy;
+	u8 blok_wy_bit_mask;
+	u8 *test_an;
+	u8 test_an_bit_mask;
+	struct binary_io pps2;
+	float *sat_cnt;
+
+	struct binary_io mgb_ch[8];
+	struct binary_io mki_zp6;
+	struct binary_io mki_iec[4];
+	struct binary_io pps_ok;
+	struct binary_io ptp_ok;
+	struct binary_io ntp_ok;
+	struct binary_io irigb_fix_ok;
+	struct binary_io iec_err;
+	struct binary_io pps_sw;
+	struct binary_io service;
+	u16 pps_timeout_cnt;
+	u16 pps_timeout_cnt2;
+	u16 fix_timeout_cnt;
+	u16 fix_timeout_cnt2;
+};
+
+struct dev_ctrl_io
+{
+	u32 test_we_in;
+	u32 test_wy_in;
+	u32 test_log_in;
+	u32 blok_wy_in;
+	u32 test_an_in;
+	u32 pps2_in;
+	u32 service_mode_in;
+	u32 pwr1_ok_out;
+	u32 pwr2_ok_out;
+	u32 nowe_nast_out;
+	u32 blad_konf_out;
+	u32 blad_sd_out;
+	u32 mgb_ch1_act_out;
+	u32 mgb_ch2_act_out;
+	u32 mgb_ch3_act_out;
+	u32 mgb_ch4_act_out;
+	u32 mgb_ch5_act_out;
+	u32 mgb_ch6_act_out;
+	u32 mgb_ch7_act_out;
+	u32 mgb_ch8_act_out;
+	u32 mki_zp6_act_out;
+	u32 mki_iec1_act_out;
+	u32 mki_iec2_act_out;
+	u32 mki_iec3_act_out;
+	u32 mki_iec4_act_out;
+	u32 pps_ok_out;
+	u32 ptp_ok_out;
+	u32 irigb_fix_ok_out;
+	u32 iec_err_out;
+	u32 sat_cnt_float_out;
+	u32 ntp_ok_out;
+	u32 pps_sw_out;
+}__attribute__((__packed__));
+
+struct dev_ctrl_params
+{
+}__attribute__((__packed__));
+
+struct dev_ctrl_args
+{
+	struct dev_ctrl_io io;
+	struct dev_ctrl_params params;
+//	u16 crc;
+}__attribute__((__packed__));
+
+extern u32 dev_ctrl_state;
+extern u32 service_mode;
+
+#define DEV_CTRL_STATE_TEST_IN		0x01
+#define DEV_CTRL_STATE_TEST_OUT		0x02
+#define DEV_CTRL_STATE_TEST_LOG		0x04
+#define DEV_CTRL_STATE_BLOCK_OUT	0x08
+#define DEV_CTRL_STATE_TEST_AN		0x10
+#define DEV_CTRL_STATE_CFG_CHANGE	0x0100
+#define DEV_CTRL_STATE_CFG_ERR		0x0200
+#define DEV_CTRL_STATE_SD_ERR		0x0400
+#define DEV_CTRL_STATE_PPS_OK		0x0800
+#define DEV_CTRL_STATE_PTP_OK		0x1000
+#define DEV_CTRL_STATE_IRIGB_FIX_OK	0x2000
+#define DEV_CTRL_STATE_NTP_OK		0x4000
+#define DEV_CTRL_STATE_NTP_HISZP_OK	0x8000
+#define DEV_CTRL_STATE_MGB_CHAN1	0x010000UL
+#define DEV_CTRL_STATE_MGB_CHAN2	0x020000
+#define DEV_CTRL_STATE_MGB_CHAN3	0x040000
+#define DEV_CTRL_STATE_MGB_CHAN4	0x080000
+#define DEV_CTRL_STATE_MGB_CHAN5	0x100000
+#define DEV_CTRL_STATE_MGB_CHAN6	0x200000
+#define DEV_CTRL_STATE_MGB_CHAN7	0x400000
+#define DEV_CTRL_STATE_MGB_CHAN8	0x800000
+#define DEV_CTRL_STATE_MKI_CHAN_ZP		0x1000000
+#define DEV_CTRL_STATE_MKI_IEC_ERR		0x2000000
+#define DEV_CTRL_STATE_MKI_UNUSED1		0x4000000
+#define DEV_CTRL_STATE_MKI_UNUSED2		0x8000000
+//
+//
+#define DEV_CTRL_STATE_MKI_IEC_CHAN1	0x10000000
+#define DEV_CTRL_STATE_MKI_IEC_CHAN2	0x20000000
+#define DEV_CTRL_STATE_MKI_IEC_CHAN3	0x40000000
+#define DEV_CTRL_STATE_MKI_IEC_CHAN4	0x80000000
+
+extern int dev_ctrl_initlog(void *arguments, void *logic);
+extern void dev_ctrl(void *arguments, void *logic);
+extern void dev_ctrl_20hz(void *arguments, void *logic);
+
+#endif /* DEV_CTRL_H_ */

src/dfr.c

@@ -0,0 +1,219 @@
+/*
+ * dfr.c
+ *
+ *  Created on: 24-06-2014
+ *      Author: KJ
+ */
+
+
+#include "tdefs.h"
+#include "misc.h"
+
+#include <ti/ipc/Notify.h>
+#include <string.h>
+#include "dfr.h"
+#include "dfr_drv.h"
+#include "rec_an.h"
+#include "rec_buf.h"
+#include "rec_bin.h"
+#include "comm.h"
+#include "misc.h"
+#include "config.h"
+
+#pragma LOCATION(bank0,0xc4400000) // @ non-cached memory above 128MB
+volatile u8 bank0[REG_BANK_SIZE];
+#pragma LOCATION(bank1,0xc4800000) // @ non-cached memory above 128MB
+volatile u8 bank1[REG_BANK_SIZE];
+#pragma LOCATION(bank2,0xc4c00000) // @ non-cached memory above 128MB
+volatile u8 bank2[REG_BANK_SIZE];
+#pragma LOCATION(bank3,0xc5000000) // @ non-cached memory above 128MB
+volatile u8 bank3[REG_BANK_SIZE];
+
+volatile struct reg_inf regs = {	.cur_reg_bank = 0,
+									.bank[0].data = (void*) bank0,
+									.bank[0].state = BANK_BUFFERING,
+									.bank[0].addr_offset = 0,
+									.bank[0].pre_trigger_cnt = 0,
+									.bank[0].post_trigger_cnt = 0,
+									.bank[0].total_cnt = 0,
+									.bank[1].data = (void*) bank1,
+									.bank[2].data = (void*) bank2,
+									.bank[3].data = (void*) bank3,
+								};
+
+int dfr_initlog(void *arguments, void *logic)
+{
+	struct dfr_args *args = (struct dfr_args *)arguments;
+	struct dfr_logic *log = (struct dfr_logic *)logic;
+
+	log->trigger_ptr = log_manager.nets_data + (args->io.trigger_in >> 3);
+	log->trigger_bit_no = args->io.trigger_in & 0x07;
+	if(log->trigger_ptr >= (log_manager.nets_data+sizeof(log_manager.nets_data)))
+		return -1;
+
+	return 0;
+}
+
+void dfr(void *arguments, void *logic)
+{
+	struct dfr_logic *log = (struct dfr_logic *)logic;
+	struct dfr_args *args = (struct dfr_args *)arguments;
+	struct rec_an_logic *an_log;
+	struct rec_buf_logic *an_buf_log;
+	struct rec_bin_logic *bin_log;
+	u16 sample_buf[(MAX_SAMPLE_SIZE/sizeof(u16)) + 8];
+	int i,bit_cnt=0,pos=0;
+	int sdiff;
+	u32 prev_offset;
+	short *sample_buf_prev;
+
+	if(dfr_drv_log_ptr == NULL) // dfr driver not initialized?
+		return;
+
+	sdiff=cur_sample_diff;
+
+	while(sdiff)
+	{
+		switch(regs.bank[regs.cur_reg_bank].state)
+		{
+			case BANK_BUFFERING:
+				if(*log->trigger_ptr & (1<<log->trigger_bit_no))
+				{
+					regs.bank[regs.cur_reg_bank].state=BANK_TRIGGERED;
+					regs.bank[regs.cur_reg_bank].tr_time=(timesync_bits & CFG_TSYNC_USE_SWCLK)?cur_time_sw.tv_sec:cur_time.tv_sec;
+					regs.bank[regs.cur_reg_bank].tr_time_ms=(timesync_bits & CFG_TSYNC_USE_SWCLK)?cur_time_sw.tv_usec:cur_time.tv_usec;
+					regs.bank[regs.cur_reg_bank].sample_size=dfr_drv_log_ptr->sample_size;
+					regs.bank[regs.cur_reg_bank].an_count=dfr_drv_log_ptr->an_count;
+					regs.bank[regs.cur_reg_bank].bin_count=dfr_drv_log_ptr->bin_count;
+					regs.bank[regs.cur_reg_bank].post_trigger_cnt=0;
+					regs.bank[regs.cur_reg_bank].trigger_offset=regs.bank[regs.cur_reg_bank].addr_offset;
+					regs.bank[regs.cur_reg_bank].total_cnt=regs.bank[regs.cur_reg_bank].pre_trigger_cnt;
+				}
+				else
+				{
+					if(regs.bank[regs.cur_reg_bank].pre_trigger_cnt<args->params.pre_trigger_time)
+						regs.bank[regs.cur_reg_bank].pre_trigger_cnt++;
+				}
+				break;
+
+			case BANK_TRIGGERED:
+				if(regs.bank[regs.cur_reg_bank].total_cnt++>=args->params.max_reg_time || regs.bank[regs.cur_reg_bank].post_trigger_cnt>=args->params.post_trigger_time)
+				{
+					// send notify to ARM
+					regs.bank[regs.cur_reg_bank].state=BANK_FILLED;
+					regs.cur_reg_bank++;
+					regs.cur_reg_bank%=MAX_REG_BANKS;
+					regs.bank[regs.cur_reg_bank].state=BANK_BUFFERING;
+					regs.bank[regs.cur_reg_bank].addr_offset=0;
+					regs.bank[regs.cur_reg_bank].post_trigger_cnt=0;
+					regs.bank[regs.cur_reg_bank].pre_trigger_cnt=0;
+					regs.bank[regs.cur_reg_bank].trigger_offset=0;
+					regs.bank[regs.cur_reg_bank].total_cnt=0;
+					logman_notify|=LOGMAN_NOTIFY_NEW_DFR;
+	//				Notify_sendEvent(notify.remoteProcId,notify.lineId,notify.eventId, NOTIFY_NEW_DFR_REG, TRUE);
+				}
+				else
+				{
+					if(*log->trigger_ptr & (1<<log->trigger_bit_no))
+						regs.bank[regs.cur_reg_bank].post_trigger_cnt=0;
+					else
+						regs.bank[regs.cur_reg_bank].post_trigger_cnt++;
+				}
+				break;
+
+			case BANK_EMPTY:
+			case BANK_FILLED:
+			default:
+				regs.bank[regs.cur_reg_bank].state=BANK_BUFFERING;
+				regs.bank[regs.cur_reg_bank].addr_offset=0;
+				regs.bank[regs.cur_reg_bank].post_trigger_cnt=0;
+				regs.bank[regs.cur_reg_bank].pre_trigger_cnt=0;
+				regs.bank[regs.cur_reg_bank].trigger_offset=0;
+				regs.bank[regs.cur_reg_bank].total_cnt=0;
+				break;
+		}
+
+
+
+	//
+	//  will be overwritten by ARM
+	//	*((u32 *)&sample_buf[0]) = 0; // sample number 1..n
+	//	*((u32 *)&sample_buf[2]) = 0; // time stamp 0..n*1ms @ 1 kHz
+	//
+
+		pos = 4;
+
+
+		for(i=0;i<dfr_drv_log_ptr->an_count;i++)
+		{
+			if(regs.bank[regs.cur_reg_bank].addr_offset >= (dfr_drv_log_ptr->sample_size))
+				prev_offset = regs.bank[regs.cur_reg_bank].addr_offset - (dfr_drv_log_ptr->sample_size);
+			else
+				prev_offset = dfr_drv_log_ptr->max_offset - (dfr_drv_log_ptr->sample_size);
+
+			sample_buf_prev = (short*)((u8*)regs.bank[regs.cur_reg_bank].data+prev_offset+(pos<<1));
+
+			if(dfr_drv_log_ptr->element_num[i] & ELEMENT_IS_REC_BUF)
+			{
+				an_buf_log = (struct rec_buf_logic *)log_manager.log_element[dfr_drv_log_ptr->element_num[i] & 0x3FFF].fun_log_ptr;
+
+				sample_buf[pos]=(short)an_buf_log->buf_ptr[bus_an_cur_sample_num]-0x7FFF;
+
+				if(sdiff>SAMPLES_PER_MS)
+				{
+					int snum;
+					snum = bus_an_cur_sample_num;
+					snum-= (sdiff-SAMPLES_PER_MS);
+					if(snum<0)
+						snum+=(SAMPLES_PER_MS*2*MAIN_FREQ_PERIOD_MS);
+					*sample_buf_prev=(short)an_buf_log->buf_ptr[snum]-0x7FFF;
+				}
+			}
+			else
+			{
+				an_log = (struct rec_an_logic *)log_manager.log_element[dfr_drv_log_ptr->element_num[i] & 0x3FFF].fun_log_ptr;
+				sample_buf[pos]=*an_log->in_ptr;
+
+				if(sdiff>SAMPLES_PER_MS)//first sample interpolation
+				{
+#if SAMPLES_INTERPOLATION==1
+					*sample_buf_prev=((short)*an_log->in_ptr+*sample_buf_prev)>>1;
+#elif SAMPLES_INTERPOLATION==2
+					*sample_buf_prev=32768;
+#else
+					*sample_buf_prev=sample_buf[pos]; // only phase shift
+#endif
+				}
+
+			}
+			pos++;
+		}
+
+		sample_buf[pos]=0;
+		bit_cnt=0;
+
+		for(;i<(dfr_drv_log_ptr->an_count+dfr_drv_log_ptr->bin_count);i++)
+		{
+			bin_log = (struct rec_bin_logic *)log_manager.log_element[dfr_drv_log_ptr->element_num[i] & 0x3FFF].fun_log_ptr;
+
+			if(*bin_log->in_ptr & bin_log->in_bit_mask)
+				sample_buf[pos]|=(1<<(bit_cnt%16));
+
+			if(!(++bit_cnt%16) && bit_cnt)
+			{
+				pos++;
+				sample_buf[pos]=0;
+			}
+		}
+
+		if(regs.bank[regs.cur_reg_bank].addr_offset + dfr_drv_log_ptr->sample_size > REG_BANK_SIZE)
+			regs.bank[regs.cur_reg_bank].addr_offset=0;
+
+		memcpy((u8*)regs.bank[regs.cur_reg_bank].data+regs.bank[regs.cur_reg_bank].addr_offset,(void *)sample_buf,dfr_drv_log_ptr->sample_size);
+		regs.bank[regs.cur_reg_bank].addr_offset+=dfr_drv_log_ptr->sample_size;
+
+		sdiff-=SAMPLES_PER_MS;
+		if(sdiff<0)
+			sdiff=0;
+	}
+}

src/dfr.h

@@ -0,0 +1,84 @@
+/*
+ * dfr.h
+ *
+ *
+ *  Created on: 24-06-2014
+ *      Author: KJ
+ */
+
+#ifndef DFR_H_
+#define DFR_H_
+
+#include "tdefs.h"
+
+#define MAX_SAMPLE_SIZE		512
+
+#define REG_BANK_SIZE 			0x400000
+#define AN_IS_FLOAT			 	0x80000000
+
+// bank states
+#define BANK_EMPTY				0x00
+#define BANK_BUFFERING			0x01
+#define BANK_TRIGGERED			0x02
+#define BANK_FILLED				0x03
+
+#define MAX_REG_BANKS			4
+
+struct reg_data
+{
+	u8 *data;
+	u8 state;
+	u32 addr_offset;
+	u32 pre_trigger_cnt;
+	u32 post_trigger_cnt;
+	u32 total_cnt;
+	u32 trigger_offset;
+	u32 tr_time;
+	u32 tr_time_ms;
+	u16 sample_size;
+	u8 an_count;
+	u16 bin_count;
+}__attribute__((__packed__));
+
+struct reg_inf
+{
+	u8 cur_reg_bank;
+	struct reg_data bank[MAX_REG_BANKS];
+}__attribute__((__packed__));
+
+extern volatile u8 bank0[REG_BANK_SIZE];
+extern volatile u8 bank1[REG_BANK_SIZE];
+extern volatile u8 bank2[REG_BANK_SIZE];
+extern volatile u8 bank3[REG_BANK_SIZE];
+
+extern volatile struct reg_inf regs;
+
+struct dfr_logic
+{
+	u8 *trigger_ptr;
+	u8 trigger_bit_no;
+};
+
+struct dfr_io
+{
+	u32 trigger_in;
+}__attribute__((__packed__));
+
+struct dfr_params
+{
+	u32 pre_trigger_time;
+	u32 post_trigger_time;
+	u32 max_reg_time;
+}__attribute__((__packed__));
+
+struct dfr_args
+{
+	struct dfr_io io;
+	struct dfr_params params;
+//	u16 crc;
+}__attribute__((__packed__));
+
+extern int dfr_initlog(void *args, void *logic);
+extern void dfr(void *args, void *logic);
+
+#endif /* DFR_H_ */

src/dfr_drv.c

@@ -0,0 +1,122 @@
+/*
+ * dfr_drv.c
+ *
+ *  Created on: 23-10-2014
+ *      Author: KJ
+ */
+
+
+#include "tdefs.h"
+#include "misc.h"
+
+#include <string.h>
+#include "rec_bin.h"
+#include "rec_an.h"
+#include "rec_buf.h"
+#include "rec_float.h"
+#include "dfr.h"
+#include "dfr_drv.h"
+
+struct dfr_drv_logic *dfr_drv_log_ptr = NULL;
+
+int dfr_drv_initlog(void *arguments, void *logic)
+{
+	struct dfr_drv_logic *log = (struct dfr_drv_logic *)logic;
+	int i;
+
+	log->an_count=0;
+	log->bin_count=0;
+
+	for(i=0;i<MAX_LOG_ELEMENTS;i++) /* find analog channels */
+	{
+		if(log_manager.log_element[i].flags & (FUNCTION_IS_REC_AN|FUNCTION_IS_REC_FLOAT|FUNCTION_IS_REC_BUF))
+		{
+			if(log_manager.log_element[i].flags & FUNCTION_IS_REC_AN)
+			{
+				struct rec_an_args *args;
+
+				args =  (struct rec_an_args *)log_manager.log_element[i].fun_args_ptr;
+				if(!(args->params.bits & REC_CHAN_ENABLED_DFR))
+					continue;
+			}
+			else if(log_manager.log_element[i].flags & FUNCTION_IS_REC_BUF)
+			{
+				struct rec_buf_args *args;
+
+				args =  (struct rec_buf_args *)log_manager.log_element[i].fun_args_ptr;
+				if(!(args->params.bits & REC_CHAN_ENABLED_DFR))
+					continue;
+			}
+			else
+			{
+				struct rec_float_args *args;
+
+				args =  (struct rec_float_args *)log_manager.log_element[i].fun_args_ptr;
+				if(!(args->params.bits & REC_CHAN_ENABLED_DFR))
+					continue;
+			}
+
+
+			if((u8 *)&log->element_num[log->an_count]>(u8 *)(log_manager.buf+sizeof(log_manager.buf)-sizeof(u16)))
+				return -1;
+
+			log->element_num[log->an_count]=i|((log_manager.log_element[i].flags & FUNCTION_IS_REC_FLOAT)?ELEMENT_IS_REC_FLOAT:(log_manager.log_element[i].flags & FUNCTION_IS_REC_BUF)?ELEMENT_IS_REC_BUF:0);
+			log->an_count++;
+		}
+	}
+
+	log->sample_size=log->an_count * sizeof(u16);
+
+	for(i=0;i<MAX_LOG_ELEMENTS;i++) /* find binary channels */
+	{
+		struct rec_bin_args *args;
+
+		args =  (struct rec_bin_args *)log_manager.log_element[i].fun_args_ptr;
+
+		if((log_manager.log_element[i].flags & FUNCTION_IS_REC_BIN) && (args->params.bits & REC_CHAN_ENABLED_DFR))
+		{
+			if((u8 *)&log->element_num[log->an_count+log->bin_count]>(u8 *)(log_manager.buf+sizeof(log_manager.buf)-sizeof(u16)))
+				return -1;
+
+			log->element_num[log->an_count+log->bin_count]=i;
+			log->bin_count++;
+		}
+	}
+
+	log->sample_size+=((log->bin_count/16)*2);
+	if(log->bin_count%16)
+		log->sample_size+=2;
+
+	log->sample_size+=8; // sample number && time stamp
+
+	if(log->sample_size>MAX_SAMPLE_SIZE)
+		return -1;
+
+	for(i=0;i<MAX_LOG_ELEMENTS;i++)
+	{
+		if(log_manager.log_element[i].flags & FUNCTION_IS_DFR)
+		{
+			struct dfr_args *args;
+
+			args =  (struct dfr_args *)log_manager.log_element[i].fun_args_ptr;
+
+			if(args->params.max_reg_time > ((REG_BANK_SIZE / log->sample_size) - 2))
+				args->params.max_reg_time=((REG_BANK_SIZE / log->sample_size) - 2);
+				//return -1;
+
+			if((args->params.post_trigger_time + args->params.pre_trigger_time) > args->params.max_reg_time)
+			{
+				args->params.post_trigger_time=args->params.max_reg_time/2;
+				args->params.pre_trigger_time=args->params.max_reg_time/2;
+//				return -1;
+			}
+		}
+	}
+
+	log->max_offset=REG_BANK_SIZE/dfr_drv_log_ptr->sample_size*dfr_drv_log_ptr->sample_size;
+
+	dfr_drv_log_ptr=(struct dfr_drv_logic *)logic;
+
+	return 0;
+}
+

src/dfr_drv.h

@@ -0,0 +1,45 @@
+/*
+ * dfr_drv.h
+ *
+ *
+ *  Created on: 23-10-2014
+ *      Author: KJ
+ */
+
+#ifndef DFR_DRV_H_
+#define DFR_DRV_H_
+
+#include "tdefs.h"
+
+#define ELEMENT_IS_REC_FLOAT	0x8000
+#define ELEMENT_IS_REC_BUF		0x4000
+
+extern struct dfr_drv_logic *dfr_drv_log_ptr;
+
+struct dfr_drv_logic
+{
+	u16 an_count;
+	u16 bin_count;
+	u16 sample_size;
+	u32 max_offset;
+	u16 element_num[];
+};
+
+struct dfr_drv_io
+{
+}__attribute__((__packed__));
+
+struct dfr_drv_params
+{
+}__attribute__((__packed__));
+
+struct dfr_drv_args
+{
+	struct dfr_drv_io io;
+	struct dfr_drv_params params;
+//	u16 crc;
+}__attribute__((__packed__));
+
+extern int dfr_drv_initlog(void *args, void *logic);
+
+#endif /* DFR_DRV_H_ */

src/e_addvec.c

@@ -0,0 +1,69 @@
+/*
+ * e_addvec.c
+ *
+ *  Created on: 10-06-2016
+ *      Author: Krzysztof Jakubczyk
+ */
+
+#include "tdefs.h"
+#include "misc.h"
+
+#include "e_addvec.h"
+#include "analog_in.h"
+#include <math.h>
+
+int e_addvec_initlog(void *arguments, void *logic)
+{
+	struct e_addvec_args *args = (struct e_addvec_args *)arguments;
+	struct e_addvec_logic *log = (struct e_addvec_logic *)logic;
+
+	log->orta1_ptr = (float *)(log_manager.nets_data + (args->io.orta1_float_in >> 3));
+	if((u8 *)log->orta1_ptr > (log_manager.nets_data+sizeof(log_manager.nets_data) - sizeof(float)))
+		return -1;
+
+	log->ortb1_ptr = (float *)(log_manager.nets_data + (args->io.ortb1_float_in >> 3));
+	if((u8 *)log->ortb1_ptr > (log_manager.nets_data+sizeof(log_manager.nets_data) - sizeof(float)))
+		return -1;
+
+	log->orta2_ptr = (float *)(log_manager.nets_data + (args->io.orta2_float_in >> 3));
+	if((u8 *)log->orta2_ptr > (log_manager.nets_data+sizeof(log_manager.nets_data) - sizeof(float)))
+		return -1;
+
+	log->ortb2_ptr = (float *)(log_manager.nets_data + (args->io.ortb2_float_in >> 3));
+	if((u8 *)log->ortb2_ptr > (log_manager.nets_data+sizeof(log_manager.nets_data) - sizeof(float)))
+		return -1;
+
+	log->orta_ptr = (float *)(log_manager.nets_data + (args->io.orta_float_out >> 3));
+	if((u8 *)log->orta_ptr > (log_manager.nets_data+sizeof(log_manager.nets_data) - sizeof(float)))
+		return -1;
+
+	log->ortb_ptr = (float *)(log_manager.nets_data + (args->io.ortb_float_out >> 3));
+	if((u8 *)log->ortb_ptr > (log_manager.nets_data+sizeof(log_manager.nets_data) - sizeof(float)))
+		return -1;
+
+	log->esk_ptr = (float *)(log_manager.nets_data + (args->io.esk_float_out >> 3));
+	if((u8 *)log->esk_ptr > (log_manager.nets_data+sizeof(log_manager.nets_data) - sizeof(float)))
+		return -1;
+
+	return 0;
+}
+
+void e_addvec(void *arguments, void *logic)
+{
+	struct e_addvec_args *args = (struct e_addvec_args *)arguments;
+	struct e_addvec_logic *log = (struct e_addvec_logic *)logic;
+
+	float orta, ortb;
+
+	orta = *log->orta1_ptr + *log->orta2_ptr;
+	ortb = *log->ortb1_ptr + *log->ortb2_ptr;
+
+	if(args->io.esk_float_out)
+		*log->esk_ptr=(orta*orta + ortb*ortb)/2;
+
+	if(args->io.orta_float_out)
+		*log->orta_ptr = orta;
+
+	if(args->io.ortb_float_out)
+		*log->ortb_ptr = ortb;
+}

src/e_addvec.h

@@ -0,0 +1,49 @@
+/*
+ * e_addvec.h
+ *
+ *  Created on: 10-06-2016
+ *      Author: Krzysztof Jakubczyk
+ */
+
+#ifndef E_ADDVEC_H_
+#define E_ADDVEC_H_
+
+#include "tdefs.h"
+
+struct e_addvec_logic
+{
+	float *orta1_ptr;
+	float *ortb1_ptr;
+	float *orta2_ptr;
+	float *ortb2_ptr;
+	float *orta_ptr;
+	float *ortb_ptr;
+	float *esk_ptr;
+};
+
+struct e_addvec_io
+{
+	u32 orta1_float_in;
+	u32 ortb1_float_in;
+	u32 orta2_float_in;
+	u32 ortb2_float_in;
+	u32 orta_float_out;
+	u32 ortb_float_out;
+	u32 esk_float_out;
+}__attribute__((__packed__));
+
+struct e_addvec_params
+{
+}__attribute__((__packed__));
+
+struct e_addvec_args
+{
+	struct e_addvec_io io;
+	struct e_addvec_params params;
+//	u16 crc;
+}__attribute__((__packed__));
+
+extern void e_addvec(void *args, void *logic);
+extern int e_addvec_initlog(void *arguments, void *logic);
+
+#endif /* E_ADDVEC_H_ */

src/e_avg.c

@@ -0,0 +1,84 @@
+/*
+ * e_avg.c
+ *
+ *  Created on: 12-05-2016
+ *      Author: Krzysztof Jakubczyk
+ */
+
+#include "tdefs.h"
+#include "misc.h"
+#include "config.h"
+
+#include "e_avg.h"
+#include "analog_in.h"
+#include <math.h>
+
+int e_avg_initlog(void *arguments, void *logic)
+{
+	struct e_avg_args *args = (struct e_avg_args *)arguments;
+	struct e_avg_logic *log = (struct e_avg_logic *)logic;
+	struct analog_in_params *an_params;
+	u32 *an_params_ptr;
+	u32 *buf_ptr;
+
+	an_params_ptr = (u32 *)(log_manager.nets_data + (args->io.param_an_ptr_in >> 3));
+	if((u8*)an_params_ptr > (log_manager.nets_data+sizeof(log_manager.nets_data) - sizeof(void *)))
+		return -1;
+
+	if(!*an_params_ptr) // param in not connected or wrong elements order (analog_in should be run before)
+		return -1;
+
+	an_params=(struct analog_in_params *)*an_params_ptr;
+
+	buf_ptr = (u32 *)(log_manager.nets_data + (args->io.buf_u16_ptr_in >> 3));
+	if((u8*)buf_ptr > (log_manager.nets_data+sizeof(log_manager.nets_data) - sizeof(void *)))
+		return -1;
+
+	if(!*buf_ptr) // param in not connected or wrong elements order (analog_in should be run before)
+		return -1;
+
+	log->buf_ptr=(u16*)*buf_ptr;
+
+	log->avg_ptr = (float *)(log_manager.nets_data + (args->io.avg_float_out >> 3));
+	if((u8 *)log->avg_ptr > (log_manager.nets_data+sizeof(log_manager.nets_data) - sizeof(float)))
+		return -1;
+
+	log->savg_ptr = (float *)(log_manager.nets_data + (args->io.savg_float_out >> 3));
+	if((u8 *)log->savg_ptr > (log_manager.nets_data+sizeof(log_manager.nets_data) - sizeof(float)))
+		return -1;
+
+	log->multiplier = an_params->multiplier; /* (float)1.1107 */;
+	log->multiplier /= (SAMPLES_PER_MS*MAIN_FREQ_PERIOD_MS);
+	log->offset = 32767 + an_params->offset;
+
+	return 0;
+}
+
+void e_avg(void *arguments, void *logic)
+{
+	struct e_avg_args *args = (struct e_avg_args *)arguments;
+	struct e_avg_logic *log = (struct e_avg_logic *)logic;
+    short i,i1,i2;
+	float skut;
+	float pr;
+
+	i2 = bus_an_cur_sample_num;
+	skut = 0;
+
+	for (i=0;i<(SAMPLES_PER_MS*MAIN_FREQ_PERIOD_MS);i++/*=2*/)
+	{
+		i1 = i2 - i;
+	    if(i1<0)
+	    	i1 += (SAMPLES_PER_MS*MAIN_FREQ_PERIOD_MS*2);
+		pr = (float)log->buf_ptr[i1] - log->offset;
+		skut+=fabs(pr);
+	}
+
+	skut*=log->multiplier;
+
+	if(args->io.avg_float_out)
+		*log->avg_ptr=skut;
+
+	if(args->io.savg_float_out)
+		*log->savg_ptr=skut*skut;
+}

src/e_avg.h

@@ -0,0 +1,44 @@
+/*
+ * e_avg.h
+ *
+ *  Created on: 12-05-2016
+ *      Author: Krzysztof Jakubczyk
+ */
+
+#ifndef E_AVG_H_
+#define E_AVG_H_
+
+#include "tdefs.h"
+
+struct e_avg_logic
+{
+	float multiplier;
+	float offset;
+	u16 *buf_ptr;
+	float *avg_ptr;
+	float *savg_ptr;
+};
+
+struct e_avg_io
+{
+	u32 buf_u16_ptr_in;
+	u32 param_an_ptr_in;
+	u32 avg_float_out;
+	u32 savg_float_out;
+}__attribute__((__packed__));
+
+struct e_avg_params
+{
+}__attribute__((__packed__));
+
+struct e_avg_args
+{
+	struct e_avg_io io;
+	struct e_avg_params params;
+//	u16 crc;
+}__attribute__((__packed__));
+
+extern void e_avg(void *args, void *logic);
+extern int e_avg_initlog(void *arguments, void *logic);
+
+#endif /* E_AVG_H_ */

src/e_avg_1t.c

@@ -0,0 +1,109 @@
+/*
+ * e_avg_1t.c
+ *
+ *  Created on: 17-05-2016
+ *      Author: Krzysztof Jakubczyk
+ */
+
+#include "tdefs.h"
+#include "misc.h"
+
+#include "e_avg_1t.h"
+#include "analog_in.h"
+#include <math.h>
+#include <string.h>
+
+int e_avg_1t_initlog(void *arguments, void *logic)
+{
+	struct e_avg_1t_args *args = (struct e_avg_1t_args *)arguments;
+	struct e_avg_1t_logic *log = (struct e_avg_1t_logic *)logic;
+
+//	an_params=(struct analog_in_params *)*an_params_ptr;
+
+	log->probka_ptr = (float *)(log_manager.nets_data + (args->io.probka_float_in >> 3));
+	if((u8 *)log->probka_ptr > (log_manager.nets_data + sizeof(log_manager.nets_data) - sizeof(float)))
+		return -1;
+
+	log->avg_t_ptr = (float *)(log_manager.nets_data + (args->io.avg_t_float_out >> 3));
+	if((u8 *)log->avg_t_ptr > (log_manager.nets_data+sizeof(log_manager.nets_data) - sizeof(float)))
+		return -1;
+
+    memset(&log->plus, 0x00, sizeof(log->plus));
+    memset(&log->minus, 0x00, sizeof(log->minus));
+	log->licz_zero = 0;
+    memset(&log->stan_, 0x00, sizeof(log->stan_)); // zerowanie wyjsc
+
+	return 0;
+}
+
+wylicz_f(struct e_avg_1t_logic *log, struct e_avg_1t_dane_wew *d)
+{
+    float dopelnienie;
+    float okres;
+
+
+    //wyliczenie okresu pojedynczej iteracji
+    dopelnienie = log->probka_n_minus1 / (log->probka_n_minus1 - log->probka_n_);
+    okres = dopelnienie + d->reszta_ + d->il_p_;
+    log->stan_.n++; // zmiana znaczika przejscia przez zero
+    //
+
+    log->stan_.Usr = d->war_sr_ / okres; //wartosc srednia wyprostowana
+    log->stan_.Uperf = d->war_sr_;// wyliczenie ilorazu wartosci sredniej wyprostowanej z czestotliwoscia
+	log->stan_.T = okres;// okres przebiegu w ilosciach probek
+
+    d->reszta_ = 1 - dopelnienie;
+    d->war_sr_ = 0; //zerowanie licznika wartosci sredniej wyprostowanej przy przejsciu przez zero
+    d->il_p_ = 0;//zerowanie licznika pelnych probek(odliczanie nowego okresu)
+}
+
+void e_avg_1t(void *arguments, void *logic)
+{
+	struct e_avg_1t_args *args = (struct e_avg_1t_args *)arguments;
+	struct e_avg_1t_logic *log = (struct e_avg_1t_logic *)logic;
+
+    u8 przejscie_z_plusa = 0;
+    u8 przejscie_z_minusa = 0;
+
+	log->probka_n_ = *log->probka_ptr;/* * (float)1.1107;*/
+
+    //szukanie przejsc przez zero
+	if ((log->probka_n_minus1 <0 ) && (log->probka_n_ >= 0)) przejscie_z_minusa = 1;
+	if ((log->probka_n_minus1 >0 ) && (log->probka_n_ <= 0)) przejscie_z_plusa = 1;
+
+	//
+
+	if(fabs(log->probka_n_)< 0.01) log->licz_zero++; else log->licz_zero = 0;
+
+	if (log->plus.il_p_> ((MAIN_FREQ_PERIOD_MS/LOOP_CYCLE_MS)*10) || log->minus.il_p_ > ((MAIN_FREQ_PERIOD_MS/LOOP_CYCLE_MS)*10) || log->licz_zero > (MAIN_FREQ_PERIOD_MS/LOOP_CYCLE_MS))
+	{
+		log->licz_zero = 0;
+		log->stan_.n++; // zmiana znaczika przejscia przez zero
+		log->stan_.Usr = 0; //wartosc srednia wyprostowana
+		log->stan_.Uperf = 0;// wyliczenie ilorazu wartosci sredniej wyprostowanej z czestotliwoscia
+		log->stan_.T = (MAIN_FREQ_PERIOD_MS/LOOP_CYCLE_MS)*10+1;// okres przebiegu w ilosciach probek
+		log->plus.il_p_ = 0;
+		log->minus.il_p_ = 0;
+	}
+
+    log->plus.war_sr_ +=fabs(log->probka_n_); //wyliczanie wartosci sredniej wyprostowanej za okres dla okresu od przejscia z plusa
+    log->minus.war_sr_ +=fabs(log->probka_n_); //wyliczanie wartosci sredniej wyprostowanej za okres dla okresu od przejscia z minusa
+
+    if(przejscie_z_plusa)
+    {
+        wylicz_f(log,&log->plus); // wyliczenie nowej czestotliwosci
+    } else log->plus.il_p_++;
+
+    if(przejscie_z_minusa)
+    {
+        wylicz_f(log,&log->minus); //wyliczenie nowej czestotliwosci
+    } else log->minus.il_p_++;
+
+    log->probka_n_minus1 = log->probka_n_;//zapamietanie poprzedniej probki
+
+	//wskazniki[nast.adr.bufor] = (void *)&stan_;
+
+	if(args->io.avg_t_float_out)
+		*log->avg_t_ptr=log->stan_.Usr;
+
+}

src/e_avg_1t.h

@@ -0,0 +1,61 @@
+/*
+ * e_avg_1t.h
+ *
+ *  Created on: 17-05-2016
+ *      Author: Krzysztof Jakubczyk
+ */
+
+#ifndef E_AVG_1T_H_
+#define E_AVG_1T_H_
+
+#include "tdefs.h"
+
+struct e_avg_1t_dane_wew
+{
+	float war_sr_; ///< wartosc srednia wyprostowana
+    u16 il_p_; ///< ilosc pelnych probek w okresie pomiarowym
+    float reszta_; ///< odcinek sinusa z poczatku (niepelna probka)
+};
+
+struct e_avg_1t_Wyjscie
+{
+    float Usr; ///< wartosc srednia wyprostowana
+    float Uperf; ///< iloraz wartosci sredniej wyprostowanej i czestotliwosci
+    float T; ///< Okres przebiegu podany jako krotnosc okresu probkowania
+    u16 n; ///< licznik kolejnych przejsc przez 0
+};
+
+struct e_avg_1t_logic
+{
+
+    float probka_n_minus1; // pamiec poprzedniej probki
+    float probka_n_; // probka biezaca
+	short licz_zero;
+    struct e_avg_1t_dane_wew plus; //zmienne pomocnicze dla obliczen okresu od plusa
+    struct e_avg_1t_dane_wew minus; //zmienne pomocnicze dla obliczen okresu od minusa
+    struct e_avg_1t_Wyjscie stan_;
+	float *probka_ptr;
+	float *avg_t_ptr;
+};
+
+struct e_avg_1t_io
+{
+	u32 probka_float_in;
+	u32 avg_t_float_out;
+}__attribute__((__packed__));
+
+struct e_avg_1t_params
+{
+}__attribute__((__packed__));
+
+struct e_avg_1t_args
+{
+	struct e_avg_1t_io io;
+	struct e_avg_1t_params params;
+//	u16 crc;
+}__attribute__((__packed__));
+
+extern void e_avg_1t(void *args, void *logic);
+extern int e_avg_1t_initlog(void *arguments, void *logic);
+
+#endif /* E_AVG_1T_H_ */

src/e_avg_dt.c

@@ -0,0 +1,139 @@
+/*
+ * e_avg_dt.c
+ *
+ *  Created on: 31-05-2016
+ *      Author: Krzysztof Jakubczyk
+ */
+
+#include "tdefs.h"
+#include "misc.h"
+#include "config.h"
+
+#include "e_avg_dt.h"
+#include "analog_in.h"
+#include <math.h>
+#include <string.h>
+
+int e_avg_dt_initlog(void *arguments, void *logic)
+{
+	struct e_avg_dt_args *args = (struct e_avg_dt_args *)arguments;
+	struct e_avg_dt_logic *log = (struct e_avg_dt_logic *)logic;
+	struct analog_in_params *an_params;
+	u32 *an_params_ptr;
+	u32 *buf_ptr;
+
+	an_params_ptr = (u32 *)(log_manager.nets_data + (args->io.param_an_ptr_in >> 3));
+	if((u8*)an_params_ptr > (log_manager.nets_data+sizeof(log_manager.nets_data) - sizeof(void *)))
+		return -1;
+
+	if(!*an_params_ptr) // param in not connected or wrong elements order (analog_in should be run before)
+		return -1;
+
+	an_params=(struct analog_in_params *)*an_params_ptr;
+
+	buf_ptr = (u32 *)(log_manager.nets_data + (args->io.buf_u16_ptr_in >> 3));
+	if((u8*)buf_ptr > (log_manager.nets_data+sizeof(log_manager.nets_data) - sizeof(void *)))
+		return -1;
+
+	if(!*buf_ptr) // param in not connected or wrong elements order (analog_in should be run before)
+		return -1;
+
+	log->buf_ptr=(u16*)*buf_ptr;
+
+	log->avg_dt_ptr = (float *)(log_manager.nets_data + (args->io.avg_dt_float_out >> 3));
+	if((u8 *)log->avg_dt_ptr > (log_manager.nets_data+sizeof(log_manager.nets_data) - sizeof(float)))
+		return -1;
+
+    memset(&log->bufor, 0x00, sizeof(log->bufor)); // zerowanie bufora pamieci srednich wartosci za polokresu
+    log->n = (short)(args->params.dt * (SAMPLES_PER_MS*1000)); // przeliczenie milisekund na ilosc probek
+	log->mnoznik = an_params->multiplier/log->n;
+    log->n10 = (short)(args->params.dt * (1000/LOOP_CYCLE_MS) / (MAIN_FREQ_PERIOD_MS/2)); // ilosc polokresow usredniania
+	log->mnoznik10 = an_params->multiplier / log->n10 / (SAMPLES_PER_MS*10);
+    log->licznik_polokresow = 0;
+    log->licznik_probek = 0;
+	log->zakres = 1;
+	if (log->n > (SAMPLES_PER_MS*MAIN_FREQ_PERIOD_MS*2))
+		log->zakres = 0;
+
+	*log->avg_dt_ptr = 0;
+	log->offset = 32767 + an_params->offset;
+	log->offset10 = log->offset * log->n10 * (SAMPLES_PER_MS*10);
+
+	return 0;
+}
+
+void e_avg_dt(void *arguments, void *logic)
+{
+	struct e_avg_dt_args *args = (struct e_avg_dt_args *)arguments;
+	struct e_avg_dt_logic *log = (struct e_avg_dt_logic *)logic;
+
+	float wynik;
+	float pr;
+	int i;
+
+	if(log->zakres) //jesli nastawa mniejsza od wielkosci bufora probek - srednia co i probka
+    {
+        wynik = 0;
+    	log->licznik_probek = bus_an_cur_sample_num;
+        for (i=0;i<log->n;i++)
+        {
+    		pr = (float)log->buf_ptr[log->licznik_probek] - log->offset;
+            wynik += fabs(pr);//(float)log->buf_ptr[log->licznik_probek];
+            log->licznik_probek--;
+            if(log->licznik_probek<0)
+            	log->licznik_probek +=(SAMPLES_PER_MS*2*MAIN_FREQ_PERIOD_MS);
+        }
+
+        //wynik -= log->offset;
+        wynik *= log->mnoznik;
+
+        if(args->io.avg_dt_float_out)
+        	*log->avg_dt_ptr=wynik;
+    }
+}
+
+void e_avg_dt_100hz(void *arguments, void *logic)
+{
+	struct e_avg_dt_args *args = (struct e_avg_dt_args *)arguments;
+	struct e_avg_dt_logic *log = (struct e_avg_dt_logic *)logic;
+
+	float wynik;
+	float pr;
+	int i;
+
+	if (!log->zakres)
+	{ // jezeli nastawa wieksza od bufora probek - srednia co polokresu
+    	log->licznik_probek = bus_an_cur_sample_num;
+		wynik = 0;
+        for (i=0;i<(SAMPLES_PER_MS*10);i++) // wyliczenie sredniej za ostatnie polokresu
+        {
+    		pr = (float)log->buf_ptr[log->licznik_probek] - log->offset;
+            wynik += fabs(pr);
+            log->licznik_probek--;
+            if(log->licznik_probek<0)
+            	log->licznik_probek +=(SAMPLES_PER_MS*2*MAIN_FREQ_PERIOD_MS);
+        }
+
+        if(log->licznik_polokresow<20)
+        	log->bufor[log->licznik_polokresow] = wynik;
+
+		wynik = 0;
+        // wyliczenie sredniej za czas nastawiony
+        for (i=0;i<log->n10;i++ )
+        {
+            wynik += log->bufor[i];
+        }
+		//wynik -= log->offset10;
+		wynik *= log->mnoznik10;
+        //
+
+        log->licznik_polokresow++;
+        if(log->licznik_polokresow>log->n10) // aktualizacja wskaznika bufora
+        {
+            log->licznik_polokresow = 0;
+        }
+
+        if(args->io.avg_dt_float_out)
+    		*log->avg_dt_ptr=wynik;
+    }
+}

src/e_avg_dt.h

@@ -0,0 +1,52 @@
+/*
+ * e_avg_1t.h
+ *
+ *  Created on: 01-06-2016
+ *      Author: Krzysztof Jakubczyk
+ */
+
+#ifndef E_AVG_DT_H_
+#define E_AVG_DT_H_
+
+#include "tdefs.h"
+
+struct e_avg_dt_logic
+{
+	u16 *buf_ptr;
+	float *avg_dt_ptr;
+	float mnoznik;
+	float mnoznik10;
+	float offset;
+	float offset10;
+	float bufor[20];
+	short n;
+	short n10;
+    short licznik_probek; //licznik petli - zmienna pomocnicza
+    short licznik_polokresow; //licznik polokresow - zmienna pomocnicza
+    u8 zakres;
+};
+
+struct e_avg_dt_io
+{
+	u32 buf_u16_ptr_in;
+	u32 param_an_ptr_in;
+	u32 avg_dt_float_out;
+}__attribute__((__packed__));
+
+struct e_avg_dt_params
+{
+	double dt;
+}__attribute__((__packed__));
+
+struct e_avg_dt_args
+{
+	struct e_avg_dt_io io;
+	struct e_avg_dt_params params;
+//	u16 crc;
+}__attribute__((__packed__));
+
+extern void e_avg_dt(void *args, void *logic);
+extern void e_avg_dt_100hz(void *args, void *logic);
+extern int e_avg_dt_initlog(void *arguments, void *logic);
+
+#endif /* E_AVG_DT_H_ */

src/e_cu.c

@@ -0,0 +1,221 @@
+/*
+ * e_cu.c
+ *
+ *  Created on: 24-06-2016
+ *      Author: Krzysztof Jakubczyk
+ *
+ *      Wylicza calke oznaczona napiecia w nastawionym oknie czasowym
+ *
+ *
+ */
+
+#include "tdefs.h"
+#include "misc.h"
+
+#include "e_cu.h"
+#include "e_mem1.h"
+#include <math.h>
+
+int e_cu_initlog(void *arguments, void *logic)
+{
+	struct e_cu_args *args = (struct e_cu_args *)arguments;
+	struct e_cu_logic *log = (struct e_cu_logic *)logic;
+
+	u32 *buf_ptr;
+
+	log->esk_ptr = (float *)(log_manager.nets_data + (args->io.esk_float_out >> 3));
+	if((u8 *)log->esk_ptr > (log_manager.nets_data+sizeof(log_manager.nets_data) - sizeof(float)))
+		return -1;
+
+	buf_ptr = (u32 *)(log_manager.nets_data + (args->io.buf_ptr_in >> 3));
+	if((u8*)buf_ptr > (log_manager.nets_data+sizeof(log_manager.nets_data) - sizeof(void *)))
+		return -1;
+
+	log->we = (struct e_mem1_wyjscie *)*buf_ptr;
+
+	log->ok_ptr = log_manager.nets_data + (args->io.ok_out >> 3);
+	log->ok_bit_no = args->io.ok_out & 0x07;
+
+	if(log->ok_ptr >= (log_manager.nets_data+sizeof(log_manager.nets_data)))
+		return -1;
+
+    if ((int16_t)(args->params.czas_ - 16) % 2)
+	{
+	    log->zakres_ = od16do30_nieparzyste;
+	} else
+	{
+	    log->zakres_ = od16do30_parzyste;
+	}
+
+    // wyliczanie polozenia wlasciwych wartosci w pamieci
+    log->ofset_ = (int16_t)((args->params.czas_ -16) / 0.4);
+
+    if(args->params.czas_ < 16)
+    {
+        log->zakres_ = od8do16;
+        log->ofset_ = (int16_t)((args->params.czas_ - 8) / 0.2);
+    }
+
+    if(args->params.czas_ < 8)
+    {
+        log->zakres_ = od4do8;
+        log->ofset_ = (int16_t)((args->params.czas_ - 4) / 0.1);
+    }
+
+    if(args->params.czas_ < 4)
+    {
+        log->zakres_ = mniej4;
+        log->ofset_ = (int16_t)(args->params.czas_ / 0.05);
+    }
+
+	log->czas = (int16_t)(100 * args->params.czas_);
+	log->Ubl_ = args->params.Ubl_;
+
+	if(args->params.bity & 0x0001)
+		log->Uwe =  1;
+	else
+		log->Uwe = 0.57735; //jeden przez pierwiastek z 3
+    //
+
+	return 0;
+}
+
+void e_cu_20hz(void *arguments, void *logic)
+{
+	struct e_cu_logic *log = (struct e_cu_logic *)logic;
+	struct e_mem1_wyjscie *w = log->we;
+
+    short temp;
+    float temp2,temp3;
+    int i;
+	u8 OK;
+
+    temp2 = 0;
+    temp3 = 0;
+
+	if (w->czas_>=log->czas) OK = 1; else OK = 0;
+
+    switch(log->zakres_)// wyliczanie w zaleznosci od zakresu nastawy czasu
+    {
+        case mniej4:
+            temp = w->idx_50ms_ - log->ofset_; // wyliczenie indeksu tablicy dla danej chwili czasu
+            if(temp<0) temp += 80; // uwzglednienie "przekrecania" bufora"
+            //wyliczenie calki za czas nastawiony
+            while(temp!=w->idx_50ms_)
+            {
+                temp++;
+                if(temp>79) temp = 0;
+                temp2 += w->srednia_50ms_[temp];
+				if (w->srednia_50ms_[temp] < log->Ubl_) OK = 0;
+            }
+            temp2 /= log->ofset_;
+            //
+            break;
+        case od4do8:
+            temp = w->idx_100ms_ - log->ofset_;// wyliczenie indeksu tablicy dla danej chwili czasu
+            if(temp<0) temp += 40;// uwzglednienie "przekrecania" bufora"
+            for (i=0;i<80;i++)
+			{
+				temp3 += w->srednia_50ms_[i];//wyliczanie calki za czas od 0-4s;
+				if (w->srednia_50ms_[temp] < log->Ubl_) OK = 0;
+			}
+            temp2 = temp3 / 2;
+            //doliczenie calki za czesc czasu z zakresu powyzej 4s
+            temp3 = 0;
+            while(temp!=w->idx_100ms_)
+            {
+                temp++;
+                if(temp>39) temp = 0;
+                temp3 += w->srednia_100ms_[temp];
+				if (w->srednia_100ms_[temp] < log->Ubl_) OK = 0;
+            }
+            temp2 += temp3;
+            temp2 /= 40 + log->ofset_; // calka za caly czas okna pomiarowego
+            //
+            break;
+        case od8do16:
+            temp = w->idx_200ms_ - log->ofset_;// wyliczenie indeksu tablicy dla danej chwili czasu
+            if(temp<0) temp += 40;// uwzglednienie "przekrecania" bufora"
+            for (i=0;i<80;i++)
+			{
+				temp3 += w->srednia_50ms_[i];//wyliczanie calki za czas od 0-4s;
+				if (w->srednia_50ms_[temp] < log->Ubl_) OK = 0;
+			}
+            temp2 = temp3 / 4;
+            temp3 = 0;
+            for (i=0;i<40;i++)
+			{
+				temp3 += w->srednia_100ms_[i];//wyliczanie calki za czas od 4-8s;
+				if (w->srednia_100ms_[temp] < log->Ubl_) OK = 0;
+			}
+            temp2 += temp3 / 2;
+            //doliczenie calki za czesc czasu z zakresu powyzej 8s
+            temp3 = 0;
+            while(temp!=w->idx_200ms_)
+            {
+                temp++;
+                if(temp>39) temp = 0;
+                temp3 += w->srednia_200ms_[temp];
+				if (w->srednia_200ms_[temp] < log->Ubl_) OK = 0;
+            }
+            temp2 += temp3;
+            temp2 /= 40 + log->ofset_; // calka za caly czas okna pomiarowego
+            //
+            break;
+        case od16do30_parzyste:
+        case od16do30_nieparzyste:
+            temp = w->idx_400ms_ - log->ofset_;// wyliczenie indeksu tablicy dla danej chwili czasu
+            if(temp<0) temp += 36;// uwzglednienie "przekrecania" bufora"
+            for (i=0;i<80;i++)
+			{
+				temp3 += w->srednia_50ms_[i];//wyliczanie calki za czas od 0-4s;
+				if (w->srednia_50ms_[temp] < log->Ubl_) OK = 0;
+			}
+            temp2 = temp3 / 8;
+            temp3 = 0;
+            for (i=0;i<40;i++)
+			{
+				temp3 += w->srednia_100ms_[i];//wyliczanie calki za czas od 4-8s;
+				if (w->srednia_100ms_[temp] < log->Ubl_) OK = 0;
+			}
+            temp2 += temp3 / 4;
+            temp3 = 0;
+            for (i=0;i<40;i++)
+			{
+				temp3 += w->srednia_200ms_[i];//wyliczanie calki za czas od 8-16s;
+				if (w->srednia_200ms_[temp] < log->Ubl_) OK = 0;
+			}
+            temp2 += temp3 / 2;
+            //doliczenie calki za czesc czasu z zakresu powyzej 16s
+            temp3 = 0;
+            while(temp!=w->idx_400ms_)
+            {
+                temp++;
+                if(temp>35) temp = 0;
+                temp3 += w->srednia_400ms_[temp];
+				if (w->srednia_400ms_[temp] < log->Ubl_) OK = 0;
+            }
+			if (log->zakres_ == od16do30_nieparzyste)
+			{
+				temp3 += w->srednia_400ms_[temp] / 2;
+            	temp2 += temp3;
+            	temp2 /= (float)(0.5 + 40 + log->ofset_); // calka za caly czas okna pomiarowego
+			} else {
+            	temp2 += temp3;
+            	temp2 /= 40 + log->ofset_; // calka za caly czas okna pomiarowego
+			}
+            //
+            break;
+        }
+
+	if (OK)
+	{
+		*log->esk_ptr = temp2 - log->Uwe;//przepisanie wyliczonej wartosci na wyjscie
+		*log->ok_ptr|=(1<<log->ok_bit_no);
+	}
+	else
+	{
+		*log->esk_ptr = 0;
+		*log->ok_ptr&=~(1<<log->ok_bit_no);
+	}
+}

src/e_cu.h

@@ -0,0 +1,62 @@
+/*
+ * e_cu.h
+ *
+ *  Created on: 24-06-2016
+ *      Author: Krzysztof Jakubczyk
+ */
+
+#ifndef E_CU_IN_H_
+#define E_CU_IN_H_
+
+#include "tdefs.h"
+#include "e_mem1.h"
+
+enum e_cu_zakres
+{
+        mniej4 = 0,
+        od4do8,
+        od8do16,
+        od16do30_parzyste,
+		od16do30_nieparzyste
+};
+
+struct e_cu_logic
+{
+	float *esk_ptr;
+	struct e_mem1_wyjscie *we;
+	u8 *ok_ptr;
+	u8 ok_bit_no;
+
+    enum e_cu_zakres zakres_; ///< zakres bufora pamieci
+	short czas;	///< ilosc petli 10ms w oknie calkowania
+    short ofset_; ///< przesuniecie danego bufora pamieci
+    float Ubl_; ///< wartosc napiecia blokady w krotnosciach napiecia znamionowego
+	float Uwe; ///< stala odpowiadajaca napieciu (fazowe/miedzyfazowe)
+};
+
+struct e_cu_io
+{
+	u32 buf_ptr_in;
+	u32 esk_float_out;
+	u32 ok_out;
+}__attribute__((__packed__));
+
+struct e_cu_params
+{
+	u32 bity;
+	double czas_;
+	double Ubl_;
+}__attribute__((__packed__));
+
+struct e_cu_args
+{
+	struct e_cu_io io;
+	struct e_cu_params params;
+//	u16 crc;
+}__attribute__((__packed__));
+
+extern void e_cu(void *args, void *logic);
+extern void e_cu_20hz(void *args, void *logic);
+extern int e_cu_initlog(void *arguments, void *logic);
+
+#endif /* E_CU_H_ */

src/e_df_3f.c

@@ -0,0 +1,306 @@
+/*
+ * e_df_3f.c
+ *
+ *  Created on: 30-06-2016
+ *      Author: Krzysztof Jakubczyk
+ */
+
+#include "tdefs.h"
+#include "misc.h"
+
+#include "e_df_3f.h"
+#include "analog_in.h"
+#include <math.h>
+
+int e_df_3f_initlog(void *arguments, void *logic)
+{
+	struct e_df_3f_args *args = (struct e_df_3f_args *)arguments;
+	struct e_df_3f_logic *log = (struct e_df_3f_logic *)logic;
+
+	u32 *f_ptr;
+
+	f_ptr = (u32 *)(log_manager.nets_data + (args->io.f1_ptr_in >> 3));
+	if((u8 *)f_ptr > (log_manager.nets_data+sizeof(log_manager.nets_data) - sizeof(void *)))
+		return -1;
+	log->f1=(struct e_f_wyjscie *)*f_ptr;
+
+	if(!*f_ptr)
+		return -1;
+
+	f_ptr = (u32 *)(log_manager.nets_data + (args->io.f2_ptr_in >> 3));
+	if((u8 *)f_ptr > (log_manager.nets_data+sizeof(log_manager.nets_data) - sizeof(void *)))
+		return -1;
+	log->f2=(struct e_f_wyjscie *)*f_ptr;
+
+	if(!*f_ptr)
+		return -1;
+
+	f_ptr = (u32 *)(log_manager.nets_data + (args->io.f3_ptr_in >> 3));
+	if((u8 *)f_ptr > (log_manager.nets_data+sizeof(log_manager.nets_data) - sizeof(void *)))
+		return -1;
+	log->f3=(struct e_f_wyjscie *)*f_ptr;
+
+	if(!*f_ptr)
+		return -1;
+
+	log->df_ptr = (float *)(log_manager.nets_data + (args->io.df_float_out >> 3));
+	if((u8 *)log->df_ptr > (log_manager.nets_data+sizeof(log_manager.nets_data) - sizeof(float)))
+		return -1;
+
+	log->ok_ptr = log_manager.nets_data + (args->io.ok_out >> 3);
+	log->ok_bit_no = args->io.ok_out & 0x07;
+
+	if(log->ok_ptr >= (log_manager.nets_data+sizeof(log_manager.nets_data)))
+		return -1;
+
+	return 0;
+}
+
+struct e_df_3f_wyjscie wylicz_df(struct e_f_wyjscie *f)
+{
+    int16_t idxp;
+    float df;
+    float dt;
+    struct e_df_3f_wyjscie temp;
+    int16_t idx = f->idx_;
+    uint16_t temp_OK;
+    temp.OK_ = 0;
+
+    if (f->OK_[f->idx_]) // jesli ostatni pomiar czestotliwosci poprawny
+    {
+        //wyznaczenie indeksu wartosci z poprzedniej iteracji dla okna 1 okres
+        idxp = f->idx_ - 2;
+        if(idxp<0) idxp +=300;
+        //
+        if (f->OK_[idxp]) // jesli pomiar czestotliwosci poprawny na koncu okna pomiarowego
+        {
+            //wyliczenie roznicy czestotliwosci dla okna 1 okres
+            df = f->f_[f->idx_] - f->f_[idxp];
+            //sprawdzenie wielkosci wyniku, jezeli dostatecznie duzy to wyliczanie pochodnej
+            // jezeli za maly to wyliczenie z wiekszego okna
+            if(fabs(df)>0.08)
+            {
+                if (f->OK_[f->idx_ - 1])
+                {
+                    temp.df_ = df * f->f_[f->idx_];
+                } else {
+                    if (f->OK_[f->idx_] > f->OK_[idxp])
+                    {
+                        dt = (float)(f->OK_[f->idx_] - f->OK_[idxp]) * 0.001f;
+                    } else {
+                        dt = (float)((0xFFFF - f->OK_[idxp]) + f->OK_[f->idx_] + 1) * 0.001f;
+                    }
+                    temp.df_ = df / dt;
+               }
+                temp.OK_ = 1;
+            }
+        }
+
+
+        if (!temp.OK_)
+        {
+            //wyznaczenie indeksu wartosci z poprzedniej iteracji dla okna 2 okresy
+            idxp = f->idx_ - 4;
+            if(idxp<0) idxp +=300;
+            //
+            if (f->OK_[idxp]) // jesli pomiar czestotliwosci poprawny na koncu okna pomiarowego
+            {
+
+                //wyliczenie roznicy czestotliwosci dla okna 2 okresy
+                df = f->f_[f->idx_] - f->f_[idxp];
+                //sprawdzenie wielkosci wyniku, jezeli dostatecznie duzy to wyliczanie pochodnej
+                // jezeli za maly to wyliczenie z wiekszego okna
+                if(fabs(df)>0.08)
+                {
+                    idx = f->idx_;
+                    temp_OK = 1;
+                    while(idx!=idxp) // sprawdzenie poprawnosci pomiarow w zakresie sprawdzanej czestotliwosci
+                    {
+                        idx--;
+                        if(idx<0) idx +=300;
+                        if (!f->OK_[idx]) temp_OK = 0;
+                    }
+
+                    if (temp_OK)
+                    {
+                        temp.df_ = (float)(0.25 * df * (f->f_[f->idx_] + f->f_[idxp]));
+                    } else {
+                        if (f->OK_[f->idx_] > f->OK_[idxp])
+                        {
+                            dt = (float)(f->OK_[f->idx_] - f->OK_[idxp]) * 0.001f;
+                        } else {
+                            dt = (float)((0xFFFF - f->OK_[idxp]) + f->OK_[f->idx_] + 1) * 0.001f;
+                        }
+                        temp.df_ = df / dt;
+                   }
+                    temp.OK_ = 1;
+                }
+            }
+        }
+
+
+        if (!temp.OK_)
+        {
+            //wyznaczenie indeksu wartosci z poprzedniej iteracji dla okna 4 okresy
+            idxp = f->idx_ - 8;
+            if(idxp<0) idxp +=300;
+            //
+            if (f->OK_[idxp]) // jesli pomiar czestotliwosci poprawny na koncu okna pomiarowego
+            {
+
+                //wyliczenie roznicy czestotliwosci dla okna 4 okresy
+                df = f->f_[f->idx_] - f->f_[idxp];
+                //sprawdzenie wielkosci wyniku, jezeli dostatecznie duzy to wyliczanie pochodnej
+                // jezeli za maly to wyliczenie z wiekszego okna
+                if(fabs(df)>0.08)
+                {
+                    idx = f->idx_;
+                    temp_OK = 1;
+                    while(idx!=idxp) // sprawdzenie poprawnosci pomiarow w zakresie sprawdzanej czestotliwosci
+                    {
+                        idx--;
+                        if(idx<0) idx +=300;
+                        if (!f->OK_[idx]) temp_OK = 0;
+                    }
+
+                    if (temp_OK)
+                    {
+                        temp.df_ = (float)(0.125 * df * (f->f_[f->idx_] + f->f_[idxp]));
+                    } else {
+                        if (f->OK_[f->idx_] > f->OK_[idxp])
+                        {
+                            dt = (float)(f->OK_[f->idx_] - f->OK_[idxp]) * 0.001f;
+                        } else {
+                            dt = (float)((0xFFFF - f->OK_[idxp]) + f->OK_[f->idx_] + 1) * 0.001f;
+                        }
+                        temp.df_ = df / dt;
+                   }
+                    temp.OK_ = 1;
+                }
+            }
+        }
+
+
+
+
+        if (!temp.OK_)
+        {
+            //wyznaczenie indeksu wartosci z poprzedniej iteracji dla okna 7 okresow
+            idxp = f->idx_ - 14;
+            if(idxp<0) idxp +=300;
+            //
+            if (f->OK_[idxp]) // jesli pomiar czestotliwosci poprawny na koncu okna pomiarowego
+            {
+
+                //wyliczenie roznicy czestotliwosci dla okna 7 okresow
+                df = f->f_[f->idx_] - f->f_[idxp];
+                //sprawdzenie wielkosci wyniku, jezeli dostatecznie duzy to wyliczanie pochodnej
+                // jezeli za maly to wyliczenie z wiekszego okna
+                if(fabs(df)>0.08)
+                {
+                    idx = f->idx_;
+                    temp_OK = 1;
+                    while(idx!=idxp) // sprawdzenie poprawnosci pomiarow w zakresie sprawdzanej czestotliwosci
+                    {
+                        idx--;
+                        if(idx<0) idx +=300;
+                        if (!f->OK_[idx]) temp_OK = 0;
+                    }
+
+                    if (temp_OK)
+                    {
+                        temp.df_ = (float)(0.07143 * df * (f->f_[f->idx_] + f->f_[idxp]));
+                    } else {
+                        if (f->OK_[f->idx_] > f->OK_[idxp])
+                        {
+                            dt = (float)(f->OK_[f->idx_] - f->OK_[idxp]) * 0.001f;
+                        } else {
+                            dt = (float)((0xFFFF - f->OK_[idxp]) + f->OK_[f->idx_] + 1) * 0.001f;
+                        }
+                        temp.df_ = df / dt;
+                   }
+                    temp.OK_ = 1;
+                }
+            }
+        }
+
+
+        if (!temp.OK_)
+        {
+            //wyznaczenie indeksu wartosci z poprzedniej iteracji dla okna 10 okresy
+            idxp = f->idx_ - 20;
+            if(idxp<0) idxp +=300;
+            //
+            if (f->OK_[idxp]) // jesli pomiar czestotliwosci poprawny na koncu okna pomiarowego
+            {
+
+                //wyliczenie roznicy czestotliwosci dla okna 10 okresow
+                df = f->f_[f->idx_] - f->f_[idxp];
+
+                // wyliczenie pochodnej dla okna 10 okresow
+                idx = f->idx_;
+                temp_OK = 1;
+                while(idx!=idxp) // sprawdzenie poprawnosci pomiarow w zakresie sprawdzanej czestotliwosci
+                {
+                    idx--;
+                    if(idx<0) idx +=300;
+                    if (!f->OK_[idx]) temp_OK = 0;
+                }
+
+                if (temp_OK)
+                {
+                    temp.df_ = (float)(0.05 * df * (f->f_[f->idx_] + f->f_[idxp]));
+                } else {
+                    if (f->OK_[f->idx_] > f->OK_[idxp])
+                    {
+                        dt = (float)(f->OK_[f->idx_] - f->OK_[idxp]) * 0.001f;
+                    } else {
+                        dt = (float)((0xFFFF - f->OK_[idxp]) + f->OK_[f->idx_] + 1) * 0.001f;
+                    }
+                    temp.df_ = df / dt;
+                }
+                temp.OK_ = 1;
+            }
+        }
+    }
+
+    return(temp);
+}
+
+void e_df_3f_100hz(void *arguments, void *logic)
+{
+	struct e_df_3f_logic *log = (struct e_df_3f_logic *)logic;
+
+    float temp = 0;
+    int16_t temp1 = 0;
+    struct e_df_3f_wyjscie temp2;
+
+	temp2 = wylicz_df(log->f1);
+    if(temp2.OK_) //jesli pomiar w kanale 1 sprawny
+    {
+        temp += temp2.df_;
+        temp1 +=1;
+    }
+    temp2 = wylicz_df(log->f2);
+    if(temp2.OK_) //jesli pomiar w kanale 2 sprawny
+    {
+        temp += temp2.df_;
+        temp1 +=1;
+    }
+    temp2 = wylicz_df(log->f3);
+    if(temp2.OK_) //jesli pomiar w kanale 3 sprawny
+    {
+        temp += temp2.df_;
+        temp1 +=1;
+    }
+    if(temp1)//jesli co najmniej jeden pomiar sprawny
+    {
+    	*log->df_ptr=temp/temp1;
+    	*log->ok_ptr|=(1<<log->ok_bit_no);
+    } else {
+    	*log->df_ptr=temp/temp1;
+    	*log->ok_ptr&=~(1<<log->ok_bit_no);
+    	//pomiar niesprawny
+    }
+}
+

src/e_df_3f.h

@@ -0,0 +1,55 @@
+/*
+ * e_df_3f.h
+ *
+ *  Created on: 29-06-2016
+ *      Author: Krzysztof Jakubczyk
+ */
+
+#ifndef E_DF_3F_H_
+#define E_DF_3F_H_
+
+#include "tdefs.h"
+#include "e_f.h"
+
+struct e_df_3f_logic
+{
+	u8 *ok_ptr;
+	u8 ok_bit_no;
+	float *df_ptr;
+
+	struct e_f_wyjscie *f1;
+	struct e_f_wyjscie *f2;
+	struct e_f_wyjscie *f3;
+};
+
+struct e_df_3f_wyjscie
+{
+	float df_;
+	u8 OK_;
+};
+
+struct e_df_3f_io
+{
+	u32 f1_ptr_in;
+	u32 f2_ptr_in;
+	u32 f3_ptr_in;
+
+	u32 df_float_out;
+	u32 ok_out;
+}__attribute__((__packed__));
+
+struct e_df_3f_params
+{
+}__attribute__((__packed__));
+
+struct e_df_3f_args
+{
+	struct e_df_3f_io io;
+	struct e_df_3f_params params;
+//	u16 crc;
+}__attribute__((__packed__));
+
+extern void e_df_3f_100hz(void *args, void *logic);
+extern int e_df_3f_initlog(void *arguments, void *logic);
+
+#endif /* E_DF_3F_H_ */

src/e_df_dt.c

@@ -0,0 +1,100 @@
+/*
+ * e_df_dt.c
+ *
+ *  Created on: 05-07-2016
+ *      Author: Krzysztof Jakubczyk
+ */
+
+#include "tdefs.h"
+#include "misc.h"
+
+#include "e_df_dt.h"
+#include "analog_in.h"
+#include <math.h>
+
+int e_df_dt_initlog(void *arguments, void *logic)
+{
+	struct e_df_dt_args *args = (struct e_df_dt_args *)arguments;
+	struct e_df_dt_logic *log = (struct e_df_dt_logic *)logic;
+
+	u32 *f_ptr;
+
+	f_ptr = (u32 *)(log_manager.nets_data + (args->io.f_ptr_in >> 3));
+	if((u8 *)f_ptr > (log_manager.nets_data+sizeof(log_manager.nets_data) - sizeof(void *)))
+		return -1;
+	log->f=(struct e_f_wyjscie *)*f_ptr;
+
+	if(!*f_ptr)
+		return -1;
+
+	log->df_ptr = (float *)(log_manager.nets_data + (args->io.df_float_out >> 3));
+	if((u8 *)log->df_ptr > (log_manager.nets_data+sizeof(log_manager.nets_data) - sizeof(float)))
+		return -1;
+
+	log->ok_ptr = log_manager.nets_data + (args->io.ok_out >> 3);
+	log->ok_bit_no = args->io.ok_out & 0x07;
+
+	if(log->ok_ptr >= (log_manager.nets_data+sizeof(log_manager.nets_data)))
+		return -1;
+
+	log->DT_ = 1000 * args->params.DT_;
+
+	return 0;
+}
+
+void e_df_dt_100hz(void *arguments, void *logic)
+{
+	struct e_df_dt_logic *log = (struct e_df_dt_logic *)logic;
+
+	struct e_f_wyjscie *w = log->f;
+ 	uint16_t i;
+	uint16_t nr_pp;
+    int16_t idxp = w->idx_; // index polozenia drugiej wartosci roznicy (cofniecie o czas T)
+	uint16_t OK_ = w->OK_[idxp];
+	float f = w->f_[idxp];
+	float DT;
+
+    if(OK_) // jezeli pomiar czestotliwosci OK to wyliczenie Df/DT
+    {
+
+		//szukanie "drugiego konca" okresu danych
+		if (OK_ > log->DT_)
+        {
+			nr_pp = OK_ - log->DT_;
+			for (i=0;i<300;i++)
+			{
+				idxp--;
+				if (idxp<0) idxp +=300;
+				if ((w->OK_[idxp]<=nr_pp) && w->OK_[idxp])
+				{
+					DT = (float) (nr_pp - w->OK_[idxp] + log->DT_) * 0.001f;
+					*log->df_ptr =  (f - w->f_[idxp]) / DT;
+					*log->ok_ptr|=(1<<log->ok_bit_no);
+					break;
+				}
+				*log->ok_ptr&=~(1<<log->ok_bit_no);
+			}
+        } else {
+			nr_pp = (0xFFFF - OK_) + log->DT_ + 1;
+			for (i=0;i<300;i++)
+			{
+				idxp--;
+				if (idxp<0) idxp +=300;
+				if ((w->OK_[idxp]<=nr_pp) && (w->OK_[idxp] > 0x7FFF))
+				{
+					DT = (float)((float)nr_pp - (float)w->OK_[idxp] + *log->df_ptr) * 0.001f;
+					*log->df_ptr = (f - w->f_[idxp]) / DT;
+					*log->ok_ptr|=(1<<log->ok_bit_no);
+					break;
+				}
+				*log->ok_ptr&=~(1<<log->ok_bit_no);
+			}
+        }
+   		//
+
+    } else {
+		*log->ok_ptr&=~(1<<log->ok_bit_no);
+		*log->df_ptr = 0;
+	}
+}
+