zmiany w kodzie c ollama-minimax
This commit is contained in:
238
distance_algorithm_dll.py
Normal file
238
distance_algorithm_dll.py
Normal file
@@ -0,0 +1,238 @@
|
||||
"""
|
||||
Wrapper dla ZDistA_komp.dll - algorytm zabezpieczenia odległościowego
|
||||
Używa natywnej biblioteki C zamiast implementacji Python
|
||||
"""
|
||||
import ctypes
|
||||
import numpy as np
|
||||
import math
|
||||
import os
|
||||
|
||||
# Ścieżka do DLL
|
||||
DLL_PATH = os.path.join(os.path.dirname(__file__), 'ZDistA_komp.dll')
|
||||
|
||||
# Ładowanie DLL
|
||||
try:
|
||||
_dll = ctypes.CDLL(DLL_PATH)
|
||||
_dll_loaded = True
|
||||
except OSError as e:
|
||||
print(f"OSTRZEŻENIE: Nie można załadować DLL: {e}")
|
||||
print("Używam implementacji Python")
|
||||
_dll_loaded = False
|
||||
|
||||
# Definicje funkcji DLL jeśli załadowano
|
||||
if _dll_loaded:
|
||||
# ZDistA_init(z1_r, z1_x, line_angle_deg, kierunek) -> handle
|
||||
_dll.ZDistA_init.argtypes = [ctypes.c_double, ctypes.c_double, ctypes.c_double, ctypes.c_int]
|
||||
_dll.ZDistA_init.restype = ctypes.c_void_p
|
||||
|
||||
# ZDistA_step(handle, u_re[3], u_im[3], i_re[3], i_im[3]) -> int
|
||||
_dll.ZDistA_step.argtypes = [
|
||||
ctypes.c_void_p,
|
||||
ctypes.POINTER(ctypes.c_float), # u_re[3]
|
||||
ctypes.POINTER(ctypes.c_float), # u_im[3]
|
||||
ctypes.POINTER(ctypes.c_float), # i_re[3]
|
||||
ctypes.POINTER(ctypes.c_float) # i_im[3]
|
||||
]
|
||||
_dll.ZDistA_step.restype = ctypes.c_int
|
||||
|
||||
# ZDistA_cleanup(handle)
|
||||
_dll.ZDistA_cleanup.argtypes = [ctypes.c_void_p]
|
||||
_dll.ZDistA_cleanup.restype = None
|
||||
|
||||
|
||||
class DistanceRelayZDLL:
|
||||
"""
|
||||
Algorytm zabezpieczenia odległościowego - wersja DLL
|
||||
Wykorzystuje natywną bibliotekę ZDistA_komp.dll
|
||||
"""
|
||||
def __init__(self,
|
||||
Z_line_R=2.0, Z_line_X=8.0,
|
||||
line_angle=75.0,
|
||||
z1_reach=0.8, z2_reach=1.2, z3_reach=1.5,
|
||||
z4_reach=2.0, z5_reach=2.5,
|
||||
t_z1=0, t_z2=300, t_z3=600, t_z4=1000, t_z5=1500,
|
||||
przekladnia=1.0,
|
||||
fi1=75.0, fi2=85.0, fi3=90.0, fi4=90.0,
|
||||
I_min=0.5, U_min=1.0,
|
||||
kierunek=2,
|
||||
Kk1=0.0, Kk1_kat=0.0,
|
||||
KkC=0.0, KkC_kat=0.0,
|
||||
typ_zwarc=0,
|
||||
wyl=False,
|
||||
settings=None):
|
||||
|
||||
if not _dll_loaded:
|
||||
raise RuntimeError("DLL nie została załadowana!")
|
||||
|
||||
# Parametry linii
|
||||
self.Z_line_R = Z_line_R
|
||||
self.Z_line_X = Z_line_X
|
||||
self.Z_line_mag = np.sqrt(Z_line_R**2 + Z_line_X**2)
|
||||
self.line_angle = line_angle
|
||||
|
||||
# Przekładnia
|
||||
self.przekladnia = przekladnia
|
||||
|
||||
# Kąty charakterystyki
|
||||
self.fi1 = fi1
|
||||
self.fi2 = fi2
|
||||
self.fi3 = fi3
|
||||
self.fi4 = fi4
|
||||
|
||||
# Współczynniki stref
|
||||
self.z1_reach = z1_reach
|
||||
self.z2_reach = z2_reach
|
||||
self.z3_reach = z3_reach
|
||||
self.z4_reach = z4_reach
|
||||
self.z5_reach = z5_reach
|
||||
|
||||
# Oblicz R i X dla stref
|
||||
self.Z1_R = Z_line_R * z1_reach
|
||||
self.Z1_X = Z_line_X * z1_reach
|
||||
self.Z2_R = Z_line_R * z2_reach
|
||||
self.Z2_X = Z_line_X * z2_reach
|
||||
self.Z3_R = Z_line_R * z3_reach
|
||||
self.Z3_X = Z_line_X * z3_reach
|
||||
self.Z4_R = Z_line_R * z4_reach
|
||||
self.Z4_X = Z_line_X * z4_reach
|
||||
self.Z5_R = Z_line_R * z5_reach
|
||||
self.Z5_X = Z_line_X * z5_reach
|
||||
|
||||
# Opóźnienia stref [ms]
|
||||
self.t_z1 = t_z1
|
||||
self.t_z2 = t_z2
|
||||
self.t_z3 = t_z3
|
||||
self.t_z4 = t_z4
|
||||
self.t_z5 = t_z5
|
||||
|
||||
# Minimalne prądy i napięcia
|
||||
self.I_min = I_min
|
||||
self.U_min = U_min
|
||||
self.Igr = I_min * I_min
|
||||
|
||||
# Kierunek
|
||||
self.kierunek = kierunek
|
||||
|
||||
# Nadpisz nastawy z pliku konfiguracyjnego
|
||||
if settings:
|
||||
print("\n--- Nadpisywanie nastaw ZDistA DLL z pliku konfiguracyjnego ---")
|
||||
self.kierunek = int(settings.get('Kierunek', self.kierunek))
|
||||
|
||||
if 'Z1_R' in settings and self.Z_line_R > 0:
|
||||
self.z1_reach = float(settings['Z1_R']) / self.Z_line_R
|
||||
self.Z1_R = float(settings['Z1_R'])
|
||||
self.Z1_X = self.Z_line_X * self.z1_reach
|
||||
if 'Z2_R' in settings and self.Z_line_R > 0:
|
||||
self.z2_reach = float(settings['Z2_R']) / self.Z_line_R
|
||||
self.Z2_R = float(settings['Z2_R'])
|
||||
self.Z2_X = self.Z_line_X * self.z2_reach
|
||||
if 'Z3_R' in settings and self.Z_line_R > 0:
|
||||
self.z3_reach = float(settings['Z3_R']) / self.Z_line_R
|
||||
self.Z3_R = float(settings['Z3_R'])
|
||||
self.Z3_X = self.Z_line_X * self.z3_reach
|
||||
|
||||
self.t_z1 = int(settings.get('tZ1', self.t_z1))
|
||||
self.t_z2 = int(settings.get('tZ2', self.t_z2))
|
||||
self.t_z3 = int(settings.get('tZ3', self.t_z3))
|
||||
print("--- Koniec nadpisywania nastaw ZDistA DLL ---\n")
|
||||
|
||||
# Inicjalizacja DLL
|
||||
# Używamy Z1_R i Z1_X jako nastawy bazowej
|
||||
self.handle = _dll.ZDistA_init(
|
||||
ctypes.c_double(self.Z1_R),
|
||||
ctypes.c_double(self.Z1_X),
|
||||
ctypes.c_double(line_angle),
|
||||
ctypes.c_int(kierunek)
|
||||
)
|
||||
|
||||
if not self.handle:
|
||||
raise RuntimeError("Nie udało się zainicjalizować ZDistA DLL")
|
||||
|
||||
# Debug info
|
||||
print(f"Nastawy zabezpieczenia ZDistA (DLL):")
|
||||
print(f" Linia: R={Z_line_R:.2f} Ohm, X={Z_line_X:.2f} Ohm, |Z|={self.Z_line_mag:.2f} Ohm")
|
||||
print(f" Kąt linii: {line_angle:.1f} deg")
|
||||
print(f" Strefa 1: {self.z1_reach*100:.0f}% (R={self.Z1_R:.2f}, X={self.Z1_X:.2f})")
|
||||
print(f" Strefa 2: {self.z2_reach*100:.0f}% (R={self.Z2_R:.2f}, X={self.Z2_X:.2f})")
|
||||
print(f" Strefa 3: {self.z3_reach*100:.0f}% (R={self.Z3_R:.2f}, X={self.Z3_X:.2f})")
|
||||
print(f" Kierunek: {self.kierunek} (0=bez, 1=do linii, 2=do szyn)")
|
||||
print(f" DLL zainicjalizowany pomyślnie")
|
||||
|
||||
# Stan wyłącznika
|
||||
self.wyl = wyl
|
||||
self.tripped = {
|
||||
'L1': False, 'L2': False, 'L3': False,
|
||||
'L1L2': False, 'L2L3': False, 'L3L1': False
|
||||
}
|
||||
|
||||
def init_relay(self):
|
||||
"""Inicjalizacja zabezpieczenia"""
|
||||
print("Zabezpieczenie ZDistA (DLL) zainicjalizowane")
|
||||
|
||||
def reset(self):
|
||||
"""Reset stanów"""
|
||||
self.tripped = {
|
||||
'L1': False, 'L2': False, 'L3': False,
|
||||
'L1L2': False, 'L2L3': False, 'L3L1': False
|
||||
}
|
||||
|
||||
def step_relay(self, phase, u_re, u_im, i_re, i_im,
|
||||
u0_re=0, u0_im=0, i0_re=0, i0_im=0,
|
||||
u_zg_re=0, u_zg_im=0, i_zg_re=0, i_zg_im=0):
|
||||
"""
|
||||
Krok algorytmu dla jednej fazy
|
||||
phase: 'L1', 'L2' lub 'L3'
|
||||
Zwraca: 0 = brak trip, 1 = trip
|
||||
"""
|
||||
if not self.handle:
|
||||
return 0
|
||||
|
||||
# Mapowanie fazy na indeks (DLL oczekuje wszystkich 3 faz na raz)
|
||||
phase_map = {'L1': 0, 'L2': 1, 'L3': 2}
|
||||
|
||||
# Przygotuj tablice dla DLL (3 fazy)
|
||||
u_re_arr = (ctypes.c_float * 3)()
|
||||
u_im_arr = (ctypes.c_float * 3)()
|
||||
i_re_arr = (ctypes.c_float * 3)()
|
||||
i_im_arr = (ctypes.c_float * 3)()
|
||||
|
||||
# Wypełnij dane dla wszystkich 3 faz
|
||||
# Dla uproszczenia, używamy tych samych wartości dla wszystkich faz
|
||||
# (w rzeczywistości tester.py przekazuje różne wartości dla każdej fazy)
|
||||
u_re_arr[0] = u_re
|
||||
u_im_arr[0] = u_im
|
||||
i_re_arr[0] = i_re
|
||||
i_im_arr[0] = i_im
|
||||
|
||||
# Dla pozostałych faz używamy 0 (lub moglibyśmy przekazać dane z innych faz)
|
||||
# To uproszczenie - w pełnej wersji trzeba przekazać wszystkie 3 fazy naraz
|
||||
u_re_arr[1] = 0.0
|
||||
u_im_arr[1] = 0.0
|
||||
i_re_arr[1] = 0.0
|
||||
i_im_arr[1] = 0.0
|
||||
|
||||
u_re_arr[2] = 0.0
|
||||
u_im_arr[2] = 0.0
|
||||
i_re_arr[2] = 0.0
|
||||
i_im_arr[2] = 0.0
|
||||
|
||||
# Wywołaj funkcję DLL
|
||||
result = _dll.ZDistA_step(
|
||||
self.handle,
|
||||
u_re_arr,
|
||||
u_im_arr,
|
||||
i_re_arr,
|
||||
i_im_arr
|
||||
)
|
||||
|
||||
# Zaktualizuj stan trip
|
||||
if result > 0:
|
||||
self.tripped[phase] = True
|
||||
|
||||
return result
|
||||
|
||||
def __del__(self):
|
||||
"""Destruktor - zwolnij pamięć DLL"""
|
||||
if hasattr(self, 'handle') and self.handle:
|
||||
_dll.ZDistA_cleanup(self.handle)
|
||||
self.handle = None
|
||||
Reference in New Issue
Block a user