diff --git a/BTA_dome_modbus/Makefile b/BTA_dome_modbus/Makefile
new file mode 100644
index 0000000..e749ad3
--- /dev/null
+++ b/BTA_dome_modbus/Makefile
@@ -0,0 +1,79 @@
+# run `make DEF=...` to add extra defines
+CLIENT := dome_client
+SERVER := dome_server
+LDFLAGS += -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--discard-all
+LDFLAGS += -lusefull_macros -lssl -lcrypto
+DEFINES := $(DEF) -D_GNU_SOURCE -D_XOPEN_SOURCE=1111
+SOBJDIR := mkserver
+COBJDIR := mkclient
+CFLAGS += -O2 -Wall -Wextra -Wno-trampolines -pthread
+COMMSRCS := sslsock.c daemon.c cmdlnopts.c main.c
+SSRC := server.c $(COMMSRCS)
+CSRC := client.c bta_shdata.c $(COMMSRCS)
+SOBJS := $(addprefix $(SOBJDIR)/, $(SSRC:%.c=%.o))
+COBJS := $(addprefix $(COBJDIR)/, $(CSRC:%.c=%.o))
+SDEPS := $(SOBJS:.o=.d)
+CDEPS := $(COBJS:.o=.d)
+CC = gcc
+
+TARGFILE := build.target
+
+ifeq ($(shell test -e $(TARGFILE) && echo -n yes),yes)
+	TARGET := $(file < $(TARGFILE))
+else
+	TARGET := RELEASE
+endif
+
+ifeq ($(TARGET), DEBUG)
+	.DEFAULT_GOAL := debug
+endif
+
+release: CFLAGS += -flto
+release: LDFLAGS += -flto
+release: $(TARGFILE) $(CLIENT) $(SERVER)
+
+debug: CFLAGS += -DEBUG -Werror
+debug: TARGET := DEBUG
+debug: $(TARGFILE) $(CLIENT) $(SERVER)
+
+$(TARGFILE): 
+	@echo -e "\tTARGET: $(TARGET)\n"
+	@echo "$(TARGET)" > $(TARGFILE)
+
+$(CLIENT) : DEFINES += -DCLIENT
+$(CLIENT) : $(COBJDIR) $(COBJS)
+	@echo -e "\tLD $(CLIENT)"
+	$(CC) $(LDFLAGS) $(COBJS) -o $(CLIENT)
+
+
+$(SERVER) : DEFINES += -DSERVER
+$(SERVER) : $(SOBJDIR) $(SOBJS)
+	@echo -e "\tLD $(SERVER)"
+	$(CC) $(LDFLAGS) $(SOBJS) -o $(SERVER)
+
+$(SOBJDIR):
+	@mkdir $(SOBJDIR)
+
+$(COBJDIR):
+	@mkdir $(COBJDIR)
+
+ifneq ($(MAKECMDGOALS),clean)
+-include $(DEPS)
+endif
+
+$(COBJDIR)/%.o: %.c
+	@echo -e "\tCC $<"
+	$(CC) -MD -c $(LDFLAGS) $(CFLAGS) $(DEFINES) -o $@ $<
+
+$(SOBJDIR)/%.o: %.c
+	@echo -e "\t\tCC $<"
+	$(CC) -MD -c $(LDFLAGS) $(CFLAGS) $(DEFINES) -o $@ $<
+
+clean:
+	@echo -e "\t\tCLEAN"
+	@rm -rf $(SOBJDIR) $(COBJDIR) $(TARGFILE) 2>/dev/null || true
+
+xclean: clean
+	@rm -f $(PROGRAM)
+
+.PHONY: clean xclean
diff --git a/BTA_dome_modbus/bta_shdata.c b/BTA_dome_modbus/bta_shdata.c
new file mode 100644
index 0000000..bd6ec4f
--- /dev/null
+++ b/BTA_dome_modbus/bta_shdata.c
@@ -0,0 +1,356 @@
+// (C) V.S. Shergin, SAO RAS
+#include <err.h>
+#include "bta_shdata.h"
+
+#pragma pack(push, 4)
+// Main command channel (level 5)
+struct CMD_Queue mcmd = {{"Mcmd"}, 0200,0,-1,0};
+// Operator command channel (level 4)
+struct CMD_Queue ocmd = {{"Ocmd"}, 0200,0,-1,0};
+// User command channel (level 2/3)
+struct CMD_Queue ucmd = {{"Ucmd"}, 0200,0,-1,0};
+
+#define MSGLEN  (80)
+static char msg[MSGLEN];
+#define WARN(...) warn(__VA_ARGS__)
+#define PERR(...)  do{snprintf(msg, MSGLEN, __VA_ARGS__); perror(msg);} while(0)
+#ifdef EBUG
+    #define FNAME() fprintf(stderr, "\n%s (%s, line %d)\n", __func__, __FILE__, __LINE__)
+    #define DBG(...) do{fprintf(stderr, "%s (%s, line %d): ", __func__, __FILE__, __LINE__); \
+                    fprintf(stderr, __VA_ARGS__);           \
+                    fprintf(stderr, "\n");} while(0)
+#else
+    #define FNAME()  do{}while(0)
+    #define DBG(...) do{}while(0)
+#endif //EBUG
+
+
+#ifndef BTA_MODULE
+volatile struct BTA_Data *sdt;
+volatile struct BTA_Local *sdtl;
+
+volatile struct SHM_Block sdat = {
+    {"Sdat"},
+    sizeof(struct BTA_Data),
+    2048,0444,
+    SHM_RDONLY,
+    bta_data_init,
+    bta_data_check,
+    bta_data_close,
+    ClientSide,-1,NULL
+};
+
+int snd_id = -1;        // client sender ID
+int cmd_src_pid = 0;    // next command source PID
+uint32_t cmd_src_ip = 0;// next command source IP
+
+/**
+ * Init data
+ */
+void bta_data_init() {
+    sdt = (struct BTA_Data *)sdat.addr;
+    sdtl = (struct BTA_Local *)(sdat.addr+sizeof(struct BTA_Data));
+    if(sdat.side == ClientSide) {
+        if(sdt->magic != sdat.key.code) {
+            WARN("Wrong shared data (maybe server turned off)");
+        }
+        if(sdt->version == 0) {
+            WARN("Null shared data version (maybe server turned off)");
+        }
+        else if(sdt->version != BTA_Data_Ver) {
+            WARN("Wrong shared data version: I'am - %d, but server - %d ...",
+                BTA_Data_Ver, sdt->version );
+        }
+        if(sdt->size != sdat.size) {
+            if(sdt->size > sdat.size) {
+                WARN("Wrong shared area size: I needs - %d, but server - %d ...",
+                    sdat.size, sdt->size );
+            } else {
+                WARN("Attention! Too little shared data structure!");
+                WARN("I needs - %d, but server gives only %d ...",
+                    sdat.size, sdt->size );
+                WARN("May be server's version too old!?");
+            }
+        }
+        return;
+    }
+    /* ServerSide */
+    if(sdt->magic == sdat.key.code  &&
+        sdt->version == BTA_Data_Ver &&
+        sdt->size == sdat.size)
+        return;
+    memset(sdat.addr, 0, sdat.maxsize);
+    sdt->magic = sdat.key.code;
+    sdt->version = BTA_Data_Ver;
+    sdt->size = sdat.size;
+    Tel_Hardware = Hard_On;
+    Pos_Corr = PC_On;
+    TrkOk_Mode = UseDiffVel | UseDiffAZ ;
+    inp_B = 591.;
+    Pressure  = 595.;
+    PEP_code_A = 0x002aaa;
+    PEP_code_Z = 0x002aaa;
+    PEP_code_P = 0x002aaa;
+    PEP_code_F = 0x002aaa;
+    PEP_code_D = 0x002aaa;
+    DomeSEW_N = 1;
+}
+
+int  bta_data_check() {
+    return( (sdt->magic == sdat.key.code) && (sdt->version == BTA_Data_Ver) );
+}
+
+void bta_data_close() {
+    if(sdat.side == ServerSide) {
+        sdt->magic = 0;
+        sdt->version = 0;
+    }
+}
+
+/**
+ * Allocate shared memory segment
+ */
+int get_shm_block(volatile struct SHM_Block *sb, int server) {
+    int getsize = (server)? sb->maxsize : sb->size;
+    // first try to find existing one
+    sb->id = shmget(sb->key.code, getsize, sb->mode);
+    if(sb->id < 0 && errno == ENOENT && server){
+        // if no - try to create a new one
+        int cresize = sb->maxsize;
+        if(sb->size > cresize){
+            WARN("Wrong shm maxsize(%d) < realsize(%d)",sb->maxsize,sb->size);
+            cresize = sb->size;
+        }
+        sb->id = shmget(sb->key.code, cresize, IPC_CREAT|IPC_EXCL|sb->mode);
+    }
+    if(sb->id < 0){
+        if(server)
+            PERR("Can't create shared memory segment '%s'",sb->key.name);
+        else
+            PERR("Can't find shared segment '%s' (maybe no server process) ",sb->key.name);
+        return 0;
+    }
+    // attach it to our memory space
+    sb->addr = (unsigned char *) shmat(sb->id, NULL, sb->atflag);
+    if((long)sb->addr == -1){
+        PERR("Can't attach shared memory segment '%s'",sb->key.name);
+        return 0;
+    }
+    if(server && (shmctl(sb->id, SHM_LOCK, NULL) < 0)){
+        PERR("Can't prevents swapping of shared memory segment '%s'",sb->key.name);
+        return 0;
+    }
+    DBG("Create & attach shared memory segment '%s' %dbytes", sb->key.name, sb->size);
+    sb->side = server;
+    if(sb->init != NULL)
+        sb->init();
+    return 1;
+}
+
+int close_shm_block(volatile struct SHM_Block *sb){
+    int ret;
+    if(sb->close != NULL)
+        sb->close();
+    if(sb->side == ServerSide) {
+    //      ret = shmctl(sb->id, SHM_UNLOCK, NULL);
+        ret = shmctl(sb->id, IPC_RMID, NULL);
+    }
+    ret = shmdt (sb->addr);
+    return(ret);
+}
+
+/**
+ * Create|Find command queue
+ */
+void get_cmd_queue(struct CMD_Queue *cq, int server){
+    if (!server && cq->id >= 0) { //if already in use set current
+        snd_id = cq->id;
+        return;
+    }
+    // first try to find existing one
+    cq->id = msgget(cq->key.code, cq->mode);
+    // if no - try to create a new one
+    if(cq->id<0 && errno == ENOENT && server)
+        cq->id = msgget(cq->key.code, IPC_CREAT|IPC_EXCL|cq->mode);
+    if(cq->id<0){
+        if(server)
+            PERR("Can't create comand queue '%s'",cq->key.name);
+        else
+            PERR("Can't find comand queue '%s' (maybe no server process) ",cq->key.name);
+        return;
+    }
+    cq->side = server;
+    if(server){
+        char buf[120];  /* выбросить все команды из очереди */
+        while(msgrcv(cq->id, (struct msgbuf *)buf, 112, 0, IPC_NOWAIT) > 0);
+    }else
+        snd_id = cq->id;
+    cq->acckey = 0;
+}
+
+#endif // BTA_MODULE
+
+
+int check_shm_block(volatile struct SHM_Block *sb) {
+    if(sb->check)
+        return(sb->check());
+    else return(0);
+}
+
+/**
+ * Set access key in current channel
+ */
+void set_acckey(uint32_t newkey){
+    if(snd_id < 0) return;
+    if(ucmd.id == snd_id)      ucmd.acckey = newkey;
+    else if(ocmd.id == snd_id) ocmd.acckey = newkey;
+    else if(mcmd.id == snd_id) mcmd.acckey = newkey;
+}
+
+/**
+ * Setup source data for one following command if default values
+ * (IP == 0 - local, PID = current) not suits
+ */
+void set_cmd_src(uint32_t ip, int pid) {
+    cmd_src_pid = pid;
+    cmd_src_ip = ip;
+}
+
+#pragma pack(push, 4)
+/**
+ * Send client commands to server
+ */
+void send_cmd(int cmd_code, char *buf, int size) {
+    struct my_msgbuf mbuf;
+    if(snd_id < 0) return;
+    if(size > 100) size = 100;
+    if(cmd_code > 0)
+        mbuf.mtype = cmd_code;
+    else
+        return;
+    if(ucmd.id == snd_id)      mbuf.acckey = ucmd.acckey;
+    else if(ocmd.id == snd_id) mbuf.acckey = ocmd.acckey;
+    else if(mcmd.id == snd_id) mbuf.acckey = mcmd.acckey;
+
+    mbuf.src_pid = cmd_src_pid ? cmd_src_pid : getpid();
+    mbuf.src_ip = cmd_src_ip;
+    cmd_src_pid = cmd_src_ip = 0;
+
+    if(size > 0)
+        memcpy(mbuf.mtext, buf, size);
+    else {
+        mbuf.mtext[0] = 0;
+        size = 1;
+    }
+    msgsnd(snd_id, (struct msgbuf *)&mbuf, size+12, IPC_NOWAIT);
+}
+
+void send_cmd_noarg(int cmd_code) {
+    send_cmd(cmd_code, NULL, 0);
+}
+void send_cmd_str(int cmd_code, char *arg) {
+    send_cmd(cmd_code, arg, strlen(arg)+1);
+}
+void send_cmd_i1(int cmd_code, int32_t arg1) {
+    send_cmd(cmd_code, (char *)&arg1, sizeof(int32_t));
+}
+void send_cmd_i2(int cmd_code, int32_t arg1, int32_t arg2) {
+    int32_t ibuf[2];
+    ibuf[0] = arg1;
+    ibuf[1] = arg2;
+    send_cmd(cmd_code, (char *)ibuf, 2*sizeof(int32_t));
+}
+void send_cmd_i3(int cmd_code, int32_t arg1, int32_t arg2, int32_t arg3) {
+    int32_t ibuf[3];
+    ibuf[0] = arg1;
+    ibuf[1] = arg2;
+    ibuf[2] = arg3;
+    send_cmd(cmd_code, (char *)ibuf, 3*sizeof(int32_t));
+}
+void send_cmd_i4(int cmd_code, int32_t arg1, int32_t arg2, int32_t arg3, int32_t arg4) {
+    int32_t ibuf[4];
+    ibuf[0] = arg1;
+    ibuf[1] = arg2;
+    ibuf[2] = arg3;
+    ibuf[3] = arg4;
+    send_cmd(cmd_code, (char *)ibuf, 4*sizeof(int32_t));
+}
+void send_cmd_d1(int32_t cmd_code, double arg1) {
+    send_cmd(cmd_code, (char *)&arg1, sizeof(double));
+}
+void send_cmd_d2(int cmd_code, double arg1, double arg2) {
+    double dbuf[2];
+    dbuf[0] = arg1;
+    dbuf[1] = arg2;
+    send_cmd(cmd_code, (char *)dbuf, 2*sizeof(double));
+}
+void send_cmd_i1d1(int cmd_code, int32_t arg1, double arg2) {
+    struct {
+        int32_t ival;
+        double dval;
+    } buf;
+    buf.ival = arg1;
+    buf.dval = arg2;
+    send_cmd(cmd_code, (char *)&buf, sizeof(buf));
+}
+void send_cmd_i2d1(int cmd_code, int32_t arg1, int32_t arg2, double arg3) {
+    struct {
+        int32_t ival[2];
+        double dval;
+    } buf;
+    buf.ival[0] = arg1;
+    buf.ival[1] = arg2;
+    buf.dval = arg3;
+    send_cmd(cmd_code, (char *)&buf, sizeof(buf));
+}
+void send_cmd_i3d1(int cmd_code, int32_t arg1, int32_t arg2, int32_t arg3, double arg4) {
+    struct {
+        int32_t ival[3];
+        double dval;
+    } buf;
+    buf.ival[0] = arg1;
+    buf.ival[1] = arg2;
+    buf.ival[2] = arg3;
+    buf.dval = arg4;
+    send_cmd(cmd_code, (char *)&buf, sizeof(buf));
+}
+
+void encode_lev_passwd(char *passwd, int nlev, uint32_t *keylev, uint32_t *codlev){
+    char salt[4];
+    char *encr;
+    union {
+        uint32_t ui;
+        char c[4];
+    } key, cod;
+    sprintf(salt,"L%1d",nlev);
+    encr = (char *)crypt(passwd, salt);
+    cod.c[0] = encr[2];
+    key.c[0] = encr[3];
+    cod.c[1] = encr[4];
+    key.c[1] = encr[5];
+    cod.c[2] = encr[6];
+    key.c[2] = encr[7];
+    cod.c[3] = encr[8];
+    key.c[3] = encr[9];
+    *keylev = key.ui;
+    *codlev = cod.ui;
+}
+
+int find_lev_passwd(char *passwd, uint32_t *keylev, uint32_t *codlev){
+    int nlev;
+    for(nlev = 5; nlev > 0; --nlev){
+        encode_lev_passwd(passwd, nlev, keylev, codlev);
+        if(*codlev == code_Lev(nlev)) break;
+    }
+    return(nlev);
+}
+
+int check_lev_passwd(char *passwd){
+    uint32_t keylev,codlev;
+    int nlev;
+    nlev = find_lev_passwd(passwd, &keylev, &codlev);
+    if(nlev > 0) set_acckey(keylev);
+    return(nlev);
+}
+
+#pragma pack(pop)
diff --git a/BTA_dome_modbus/bta_shdata.h b/BTA_dome_modbus/bta_shdata.h
new file mode 100644
index 0000000..8e715d7
--- /dev/null
+++ b/BTA_dome_modbus/bta_shdata.h
@@ -0,0 +1,851 @@
+// (C) V.S. Shergin, SAO RAS
+#pragma once
+#ifndef __BTA_SHDATA_H__
+#define __BTA_SHDATA_H__
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <stdint.h>
+#include <string.h>
+#include <sys/ipc.h>
+#include <sys/shm.h>
+#include <sys/msg.h>
+#include <errno.h>
+
+#pragma pack(push, 4)
+/*
+ * Shared memory block
+ */
+struct SHM_Block {
+    union {
+        char  name[5];       // memory segment identificator
+        key_t code;
+    } key;
+    int32_t size;             // size of memory used
+    int32_t maxsize;          // size when created
+    int32_t mode;             // access mode (rwxrwxrwx)
+    int32_t atflag;           // connection mode (SHM_RDONLY  or 0)
+    void (*init)();           // init function
+    int32_t  (*check)();      // test function
+    void (*close)();          // deinit function
+    int32_t side;             // connection type: client/server
+    int32_t id;               // connection identificator
+    uint8_t *addr;            // connection address
+};
+
+extern volatile struct SHM_Block sdat;
+
+/*
+ * Command queue descriptor
+ */
+struct CMD_Queue {
+    union {
+        char  name[5];    // queue key
+        key_t code;
+    } key;
+    int32_t mode;       // access mode (rwxrwxrwx)
+    int32_t side;       // connection type (Sender/Receiver - server/client)
+    int32_t id;         // connection identificator
+    uint32_t acckey;    // access key (for transmission from client to server)
+};
+
+extern struct CMD_Queue mcmd;
+extern struct CMD_Queue ocmd;
+extern struct CMD_Queue ucmd;
+
+void send_cmd_noarg(int);
+void send_cmd_str(int, char *);
+void send_cmd_i1(int, int32_t);
+void send_cmd_i2(int, int32_t, int32_t);
+void send_cmd_i3(int, int32_t, int32_t, int32_t);
+void send_cmd_i4(int, int32_t, int32_t, int32_t, int32_t);
+void send_cmd_d1(int, double);
+void send_cmd_d2(int, double, double);
+void send_cmd_i1d1(int, int32_t, double);
+void send_cmd_i2d1(int, int32_t, int32_t, double);
+void send_cmd_i3d1(int, int32_t, int32_t, int32_t, double);
+
+/*******************************************************************************
+*                             Command list                                     *
+*******************************************************************************/
+/*      name                             code  args          type   */
+// Stop telescope
+#define StopTel                           1
+#define StopTeleskope()   send_cmd_noarg( 1 )
+// High/low speed
+#define StartHS                           2
+#define StartHighSpeed()  send_cmd_noarg( 2 )
+#define StartLS                           3
+#define StartLowSpeed()   send_cmd_noarg( 3 )
+// Timer setup (Ch7_15 or SysTimer)
+#define SetTmr                            4
+#define SetTimerMode(T)   send_cmd_i1   ( 4, (int)(T))
+// Simulation (modeling) mode
+#define SetModMod                         5
+#define SetModelMode(M)   send_cmd_i1   ( 5, (int)(M))
+// Azimuth speed code
+#define SetCodA                           6
+#define SetPKN_A(iA,sA)   send_cmd_i2   ( 6, (int)(iA),(int)(sA))
+// Zenith speed code
+#define SetCodZ                           7
+#define SetPKN_Z(iZ)      send_cmd_i1   ( 7, (int)(iZ))
+// Parangle speed code
+#define SetCodP                           8
+#define SetPKN_P(iP)      send_cmd_i1   ( 8, (int)(iP))
+// Set Az velocity
+#define SetVA                             9
+#define SetSpeedA(vA)     send_cmd_d1   ( 9, (double)(vA))
+// Set Z velocity
+#define SetVZ                            10
+#define SetSpeedZ(vZ)     send_cmd_d1   (10, (double)(vZ))
+// Set P velocity
+#define SetVP                            11
+#define SetSpeedP(vP)     send_cmd_d1   (11, (double)(vP))
+// Set new polar coordinates
+#define SetAD                            12
+#define SetRADec(Alp,Del) send_cmd_d2   (12, (double)(Alp),(double)(Del))
+// Set new azimutal coordinates
+#define SetAZ                            13
+#define SetAzimZ(A,Z)     send_cmd_d2   (13, (double)(A),(double)(Z))
+// Goto new object by polar coords
+#define GoToAD                           14
+#define GoToObject()      send_cmd_noarg(14 )
+// Start steering to object by polar coords
+#define MoveToAD                         15
+#define MoveToObject()    send_cmd_noarg(15 )
+// Go to object by azimutal coords
+#define GoToAZ                           16
+#define GoToAzimZ()       send_cmd_noarg(16 )
+// Set A&Z for simulation
+#define WriteAZ                          17
+#define WriteModelAZ()    send_cmd_noarg(17 )
+// Set P2 mode
+#define SetModP                          18
+#define SetPMode(pmod)    send_cmd_i1   (18, (int)(pmod))
+// Move(+-1)/Stop(0) P2
+#define P2Move                           19
+#define MoveP2(dir)       send_cmd_i1   (19, (int)(dir))
+// Move(+-2,+-1)/Stop(0) focus
+#define FocMove                          20
+#define MoveFocus(speed,time) send_cmd_i1d1(20,(int)(speed),(double)(time))
+// Use/don't use pointing correction system
+#define UsePCorr                         21
+#define SwitchPosCorr(pc_flag) send_cmd_i1 (21, (int)(pc_flag))
+// Tracking flags
+#define SetTrkFlags                      22
+#define SetTrkOkMode(trk_flags) send_cmd_i1 (22, (int)(trk_flags))
+// Set focus (0 - primary, 1 - N1, 2 - N2)
+#define SetTFoc                          23
+#define SetTelFocus(N)    send_cmd_i1  ( 23, (int)(N))
+// Set intrinsic move parameters by RA/Decl
+#define SetVAD                           24
+#define SetVelAD(VAlp,VDel) send_cmd_d2 (24, (double)(VAlp),(double)(VDel))
+// Reverse Azimuth direction when pointing
+#define SetRevA                          25
+#define SetAzRevers(amod) send_cmd_i1   (25, (int)(amod))
+// Set P2 velocity
+#define SetVP2                           26
+#define SetVelP2(vP2) send_cmd_d1       (26, (double)(vP2))
+// Set pointing target
+#define SetTarg                          27
+#define SetSysTarg(Targ) send_cmd_i1    (27, (int)(Targ))
+// Send message to all clients (+write into protocol)
+#define SendMsg                          28
+#define SendMessage(Mesg) send_cmd_str  (28, (char *)(Mesg))
+// RA/Decl user correction
+#define CorrAD                           29
+#define DoADcorr(dAlp,dDel) send_cmd_d2 (29, (double)(dAlp),(double)(dDel))
+// A/Z user correction
+#define CorrAZ                           30
+#define DoAZcorr(dA,dZ)    send_cmd_d2  (30, (double)(dA),(double)(dZ))
+// sec A/Z user correction speed
+#define SetVCAZ                          31
+#define SetVCorr(vA,vZ)   send_cmd_d2   (31, (double)(vA),(double)(vZ))
+// move P2 with given velocity for a given time
+#define P2MoveTo                         32
+#define MoveP2To(vP2,time) send_cmd_d2  (32, (double)(vP2),(double)(time))
+// Go to t/Decl position
+#define GoToTD                           33
+#define GoToSat()        send_cmd_noarg (33 )
+// Move to t/Decl
+#define MoveToTD                         34
+#define MoveToSat()      send_cmd_noarg (34 )
+// Empty command for synchronisation
+#define NullCom                          35
+#define SyncCom()        send_cmd_noarg (35 )
+// Button "Start"
+#define StartTel                         36
+#define StartTeleskope()  send_cmd_noarg(36 )
+// Set telescope mode
+#define SetTMod                          37
+#define SetTelMode(M)     send_cmd_i1  ( 37, (int)(M))
+// Turn telescope on (oil etc)
+#define TelOn                            38
+#define TeleskopeOn()     send_cmd_noarg(38 )
+// Dome mode
+#define SetModD                          39
+#define SetDomeMode(dmod) send_cmd_i1   (39, (int)(dmod))
+// Move(+-3,+-2,+-1)/Stop(0) dome
+#define DomeMove                         40
+#define MoveDome(speed,time) send_cmd_i1d1(40,(int)(speed),(double)(time))
+// Set account password
+#define SetPass                          41
+#define SetPasswd(LPass)   send_cmd_str (41, (char *)(LPass))
+// Set code of access level
+#define SetLevC                          42
+#define SetLevCode(Nlev,Cod) send_cmd_i2(42, (int)(Nlev),(int)(Cod))
+// Set key for access level
+#define SetLevK                          43
+#define SetLevKey(Nlev,Key)  send_cmd_i2(43, (int)(Nlev),(int)(Key))
+// Setup network
+#define SetNet                           44
+#define SetNetAcc(Mask,Addr) send_cmd_i2(44, (int)(Mask),(int)(Addr))
+// Input meteo data
+#define SetMet                           45
+#define SetMeteo(m_id,m_val) send_cmd_i1d1(45,(int)(m_id),(double)(m_val))
+// Cancel meteo data
+#define TurnMetOff                       46
+#define TurnMeteoOff(m_id)   send_cmd_i1 (46, (int)(m_id))
+// Set time correction (IERS DUT1=UT1-UTC)
+#define SetDUT1                          47
+#define SetDtime(dT)         send_cmd_d1 (47, (double)(dT))
+// Set polar motion (IERS polar motion)
+#define SetPM                            48
+#define SetPolMot(Xp,Yp)     send_cmd_d2 (48, (double)(Xp),(double)(Yp))
+// Get SEW parameter
+#define GetSEW                           49
+#define GetSEWparam(Ndrv,Indx,Cnt) send_cmd_i3(49,(int)(Ndrv),(int)(Indx),(int)(Cnt))
+// Set SEW parameter
+#define PutSEW                           50
+#define PutSEWparam(Ndrv,Indx,Key,Val) send_cmd_i4(50,(int)(Ndrv),(int)(Indx),(int)(Key),(int)(Val))
+// Set lock flags
+#define SetLocks                         51
+#define SetLockFlags(f)      send_cmd_i1 (SetLocks, (int)(f))
+// Clear lock flags
+#define ClearLocks                       52
+#define ClearLockFlags(f)    send_cmd_i1 (ClearLocks, (int)(f))
+// Set PEP-RK bits
+#define SetRKbits                        53
+#define AddRKbits(f)         send_cmd_i1 (SetRKbits, (int)(f))
+// Clear PEP-RK bits
+#define ClrRKbits                        54
+#define ClearRKbits(f)       send_cmd_i1 (ClrRKbits, (int)(f))
+// Set SEW dome motor number (for indication)
+#define SetSEWnd                         55
+#define SetDomeDrive(ND)     send_cmd_i1 (SetSEWnd, (int)(ND))
+// Turn SEW controllers of dome on/off
+#define SEWsDome                         56
+#define DomeSEW(OnOff)       send_cmd_i1 (SEWsDome, (int)(OnOff))
+
+
+/*******************************************************************************
+*                         BTA data structure definitions                       *
+*******************************************************************************/
+
+#define ServPID  (sdt->pid) // PID of main program
+// model
+#define UseModel  (sdt->model) // model variants
+enum{
+     NoModel = 0  // OFF
+    ,CheckModel   // control motors by model
+    ,DriveModel   // "blind" management without real sensors
+    ,FullModel    // full model without telescope
+};
+// timer
+#define ClockType (sdt->timer) // which timer to use
+enum{
+     Ch7_15 = 0 // Inner timer with synchronisation by CH7_15
+    ,SysTimer   // System timer (synchronisation unknown)
+    ,ExtSynchro // External synchronisation (bta_time or xntpd)
+};
+// system
+#define Sys_Mode (sdt->system) // main system mode
+enum{
+     SysStop = 0 // Stop
+    ,SysWait     // Wait for start (pointing)
+    ,SysPointAZ  // Pointing by A/Z
+    ,SysPointAD  // Pointing by RA/Decl
+    ,SysTrkStop  // Tracking stop
+    ,SysTrkStart // Start tracking (acceleration to nominal velocity)
+    ,SysTrkMove  // Tracking move to object
+    ,SysTrkSeek  // Tracking in seeking mode
+    ,SysTrkOk    // Tracking OK
+    ,SysTrkCorr  // Correction of tracking position
+    ,SysTest     // Test
+};
+// sys_target
+#define Sys_Target (sdt->sys_target) // system pointing target
+enum{
+     TagPosition = 0 // point by A/Z
+    ,TagObject       // point by RA/Decl
+    ,TagNest         // point to "nest"
+    ,TagZenith       // point to zenith
+    ,TagHorizon      // point to horizon
+    ,TagStatObj      // point to statinary object (t/Decl)
+};
+// tel_focus
+#define Tel_Focus (sdt->tel_focus) // telescope focus type
+enum{
+     Prime = 0
+    ,Nasmyth1
+    ,Nasmyth2
+};
+// PCS
+#define  PosCor_Coeff  (sdt->pc_coeff) // pointing correction system coefficients
+// tel_state
+#define  Tel_State (sdt->tel_state) // telescope state
+#define  Req_State (sdt->req_state) // required state
+enum{
+     Stopping = 0
+    ,Pointing
+    ,Tracking
+};
+// tel_hard_state
+#define  Tel_Hardware (sdt->tel_hard_state) // Power state
+enum{
+     Hard_Off = 0
+    ,Hard_On
+};
+// tel_mode
+#define  Tel_Mode (sdt->tel_mode) // telescope mode
+enum{
+     Automatic = 0 // Automatic (normal) mode
+    ,Manual    = 1 // manual mode
+    ,ZenHor    = 2 // work when Z<5 || Z>80
+    ,A_Move    = 4 // hand move by A
+    ,Z_Move    = 8 // hand move by Z
+    ,Balance  =0x10// balancing
+};
+// az_mode
+#define Az_Mode (sdt->az_mode) // azimuth reverce
+enum{
+     Rev_Off = 0  // move by nearest way
+    ,Rev_On       // move by longest way
+};
+// p2_state
+#define P2_State (sdt->p2_state) // P2 motor state
+#define  P2_Mode (sdt->p2_req_mode)
+enum{
+     P2_Off = 0    // Stop
+    ,P2_On         // Guiding
+    ,P2_Plus       // Move to +
+    ,P2_Minus = -2 // Move to -
+};
+// focus_state
+#define Foc_State (sdt->focus_state) // focus motor state
+enum{
+     Foc_Hminus = -2// fast "-" move
+    ,Foc_Lminus     // slow "-" move
+    ,Foc_Off        // Off
+    ,Foc_Lplus      // slow "+" move
+    ,Foc_Hplus      // fast "+" move
+};
+// dome_state
+#define Dome_State (sdt->dome_state) // dome motors state
+enum{
+     D_Hminus = -3 // speeds: low, medium, high
+    ,D_Mminus
+    ,D_Lminus
+    ,D_Off         // off
+    ,D_Lplus
+    ,D_Mplus
+    ,D_Hplus
+    ,D_On = 7      // auto
+};
+// pcor_mode
+#define Pos_Corr (sdt->pcor_mode) // pointing correction mode
+enum{
+     PC_Off = 0
+    ,PC_On
+};
+// trkok_mode
+#define TrkOk_Mode (sdt->trkok_mode) // tracking mode
+enum{
+     UseDiffVel = 1 // Isodrome (correction by real motors speed)
+    ,UseDiffAZ  = 2 // Tracking by coordinate difference
+    ,UseDFlt    = 4 // Turn on digital filter
+};
+// input RA/Decl values
+#define  InpAlpha  (sdt->i_alpha)
+#define  InpDelta  (sdt->i_delta)
+// current source RA/Decl values
+#define  SrcAlpha  (sdt->s_alpha)
+#define  SrcDelta  (sdt->s_delta)
+// intrinsic object velocity
+#define  VelAlpha  (sdt->v_alpha)
+#define  VelDelta  (sdt->v_delta)
+// input A/Z values
+#define  InpAzim   (sdt->i_azim)
+#define  InpZdist  (sdt->i_zdist)
+// calculated values
+#define  CurAlpha  (sdt->c_alpha)
+#define  CurDelta  (sdt->c_delta)
+// current values (from sensors)
+#define  tag_A  (sdt->tag_a)
+#define  tag_Z  (sdt->tag_z)
+#define  tag_P  (sdt->tag_p)
+ // calculated corrections
+#define  pos_cor_A  (sdt->pcor_a)
+#define  pos_cor_Z  (sdt->pcor_z)
+#define  refract_Z  (sdt->refr_z)
+// reverse calculation corr.
+#define  tel_cor_A  (sdt->tcor_a)
+#define  tel_cor_Z  (sdt->tcor_z)
+#define  tel_ref_Z  (sdt->tref_z)
+// coords difference
+#define  Diff_A  (sdt->diff_a)
+#define  Diff_Z  (sdt->diff_z)
+#define  Diff_P  (sdt->diff_p)
+// base object velocity
+#define  vel_objA (sdt->vbasea)
+#define  vel_objZ (sdt->vbasez)
+#define  vel_objP (sdt->vbasep)
+// correction by real speed
+#define diff_vA  (sdt->diffva)
+#define diff_vZ  (sdt->diffvz)
+#define diff_vP  (sdt->diffvp)
+// motor speed
+#define  speedA  (sdt->speeda)
+#define  speedZ  (sdt->speedz)
+#define  speedP  (sdt->speedp)
+// last precipitation time
+#define  Precip_time (sdt->m_time_precip)
+// reserved
+#define  Reserve (sdt->reserve)
+// real motor speed (''/sec)
+#define  req_speedA (sdt->rspeeda)
+#define  req_speedZ (sdt->rspeedz)
+#define  req_speedP (sdt->rspeedp)
+// model speed
+#define  mod_vel_A  (sdt->simvela)
+#define  mod_vel_Z  (sdt->simvelz)
+#define  mod_vel_P  (sdt->simvelp)
+#define  mod_vel_F  (sdt->simvelf)
+#define  mod_vel_D  (sdt->simvelf)
+// telescope & hand correction state
+/*
+ * 0x8000 - ������ �������������
+ * 0x4000 - ��������� ���.
+ * 0x2000 - ����� �������
+ * 0x1000 - ��������� P2 ���.
+ * 0x01F0 - ��.����. 0.2 0.4 1.0 2.0 5.0("/���)
+ * 0x000F - ����.����. +Z -Z +A -A
+ */
+#define  code_KOST (sdt->kost)
+// different time (UTC, stellar, local)
+#define  M_time  (sdt->m_time)
+#define  S_time  (sdt->s_time)
+#define  L_time  (sdt->l_time)
+// PPNDD sensor (rough) code
+#define  ppndd_A  (sdt->ppndd_a)
+#define  ppndd_Z  (sdt->ppndd_z)
+#define  ppndd_P  (sdt->ppndd_p)
+#define  ppndd_B  (sdt->ppndd_b)  // atm. pressure
+// DUP sensor (precise) code (Gray code)
+#define  dup_A  (sdt->dup_a)
+#define  dup_Z  (sdt->dup_z)
+#define  dup_P  (sdt->dup_p)
+#define  dup_F  (sdt->dup_f)
+#define  dup_D  (sdt->dup_d)
+// binary 14-digit precise code
+#define  low_A  (sdt->low_a)
+#define  low_Z  (sdt->low_z)
+#define  low_P  (sdt->low_p)
+#define  low_F  (sdt->low_f)
+#define  low_D  (sdt->low_d)
+// binary 23-digit rough code
+#define  code_A  (sdt->code_a)
+#define  code_Z  (sdt->code_z)
+#define  code_P  (sdt->code_p)
+#define  code_B  (sdt->code_b)
+#define  code_F  (sdt->code_f)
+#define  code_D  (sdt->code_d)
+// ADC PCL818 (8-channel) codes
+#define  ADC(N) (sdt->adc[(N)])
+#define  code_T1 ADC(0)        // External temperature code
+#define  code_T2 ADC(1)        // In-dome temperature code
+#define  code_T3 ADC(2)        // Mirror temperature code
+#define  code_Wnd ADC(3)       // Wind speed code
+// calculated values
+#define  val_A  (sdt->val_a)    // A, ''
+#define  val_Z  (sdt->val_z)    // Z, ''
+#define  val_P  (sdt->val_p)    // P, ''
+#define  val_B  (sdt->val_b)    // atm. pressure, mm.hg.
+#define  val_F  (sdt->val_f)    // focus, mm
+#define  val_D  (sdt->val_d)    // Dome Az, ''
+#define  val_T1 (sdt->val_t1)   // ext. T, degrC
+#define  val_T2 (sdt->val_t2)   // in-dome T, degrC
+#define  val_T3 (sdt->val_t3)   // mirror T, degrC
+#define  val_Wnd (sdt->val_wnd) // wind speed, m/s
+// RA/Decl calculated by A/Z
+#define  val_Alp  (sdt->val_alp)
+#define  val_Del  (sdt->val_del)
+// measured speed
+#define  vel_A  (sdt->vel_a)
+#define  vel_Z  (sdt->vel_z)
+#define  vel_P  (sdt->vel_p)
+#define  vel_F  (sdt->vel_f)
+#define  vel_D  (sdt->vel_d)
+// system messages queue
+#define MesgNum 3
+#define MesgLen 39
+// message type
+enum{
+     MesgEmpty = 0
+    ,MesgInfor
+    ,MesgWarn
+    ,MesgFault
+    ,MesgLog
+};
+#define Sys_Mesg(N) (sdt->sys_msg_buf[N])
+// access levels
+#define  code_Lev1   (sdt->code_lev[0]) // remote observer - only information
+#define  code_Lev2   (sdt->code_lev[1]) // local observer - input coordinates
+#define  code_Lev3   (sdt->code_lev[2]) // main observer - correction by A/Z, P2/F management
+#define  code_Lev4   (sdt->code_lev[3]) // operator - start/stop telescope, testing
+#define  code_Lev5   (sdt->code_lev[4]) // main operator - full access
+#define  code_Lev(x) (sdt->code_lev[(x-1)])
+// network settings
+#define  NetMask    (sdt->netmask)  // subnet mask (usually 255.255.255.0)
+#define  NetWork    (sdt->netaddr)  // subnet address (for ex.: 192.168.3.0)
+#define  ACSMask    (sdt->acsmask)  // ACS network mask (for ex.: 255.255.255.0)
+#define  ACSNet     (sdt->acsaddr)  // ACS subnet address (for ex.: 192.168.13.0)
+// meteo data
+#define  MeteoMode (sdt->meteo_stat)
+enum{
+     INPUT_B   = 1    // pressure
+    ,INPUT_T1  = 2    // external T
+    ,INPUT_T2  = 4    // in-dome T
+    ,INPUT_T3  = 8    // mirror T
+    ,INPUT_WND = 0x10 // wind speed
+    ,INPUT_HMD = 0x20 // humidity
+};
+#define  SENSOR_B   (INPUT_B  <<8)  // external data flags
+#define  SENSOR_T1  (INPUT_T1 <<8)
+#define  SENSOR_T2  (INPUT_T2 <<8)
+#define  SENSOR_T3  (INPUT_T3 <<8)
+#define  SENSOR_WND (INPUT_WND<<8)
+#define  SENSOR_HMD (INPUT_HMD<<8)
+#define  ADC_B      (INPUT_B  <<16)  // reading from ADC flags
+#define  ADC_T1     (INPUT_T1 <<16)
+#define  ADC_T2     (INPUT_T2 <<16)
+#define  ADC_T3     (INPUT_T3 <<16)
+#define  ADC_WND    (INPUT_WND<<16)
+#define  ADC_HMD    (INPUT_HMD<<16)
+#define  NET_B      (INPUT_B  <<24)  // got by network flags
+#define  NET_T1     (INPUT_T1 <<24)
+#define  NET_WND    (INPUT_WND<<24)
+#define  NET_HMD    (INPUT_HMD<<24)
+// input meteo values
+#define  inp_B  (sdt->inp_b)    // atm.pressure (mm.hg)
+#define  inp_T1 (sdt->inp_t1)   // ext T
+#define  inp_T2 (sdt->inp_t2)   // in-dome T
+#define  inp_T3 (sdt->inp_t3)   // mirror T
+#define  inp_Wnd (sdt->inp_wnd) // wind
+// values used for refraction calculation
+#define  Temper      (sdt->temper)
+#define  Pressure    (sdt->press)
+// last wind gust time
+#define  Wnd10_time  (sdt->m_time10)
+#define  Wnd15_time  (sdt->m_time15)
+// IERS DUT1
+#define  DUT1  (sdt->dut1)
+// sensors reading time
+#define  A_time  (sdt->a_time)
+#define  Z_time  (sdt->z_time)
+#define  P_time  (sdt->p_time)
+// input speeds
+#define  speedAin  (sdt->speedain)
+#define  speedZin  (sdt->speedzin)
+#define  speedPin  (sdt->speedpin)
+// acceleration (''/sec^2)
+#define  acc_A  (sdt->acc_a)
+#define  acc_Z  (sdt->acc_z)
+#define  acc_P  (sdt->acc_p)
+#define  acc_F  (sdt->acc_f)
+#define  acc_D  (sdt->acc_d)
+// SEW code
+#define  code_SEW  (sdt->code_sew)
+// sew data
+#define  statusSEW(Drv) (sdt->sewdrv[(Drv)-1].status)
+#define  statusSEW1     (sdt->sewdrv[0].status)
+#define  statusSEW2     (sdt->sewdrv[1].status)
+#define  statusSEW3     (sdt->sewdrv[2].status)
+#define  speedSEW(Drv) (sdt->sewdrv[(Drv)-1].set_speed)
+#define  speedSEW1     (sdt->sewdrv[0].set_speed)
+#define  speedSEW2     (sdt->sewdrv[1].set_speed)
+#define  speedSEW3     (sdt->sewdrv[2].set_speed)
+#define  vel_SEW(Drv) (sdt->sewdrv[(Drv)-1].mes_speed)
+#define  vel_SEW1     (sdt->sewdrv[0].mes_speed)
+#define  vel_SEW2     (sdt->sewdrv[1].mes_speed)
+#define  vel_SEW3     (sdt->sewdrv[2].mes_speed)
+#define  currentSEW(Drv) (sdt->sewdrv[(Drv)-1].current)
+#define  currentSEW1     (sdt->sewdrv[0].current)
+#define  currentSEW2     (sdt->sewdrv[1].current)
+#define  currentSEW3     (sdt->sewdrv[2].current)
+#define  indexSEW(Drv) (sdt->sewdrv[(Drv)-1].index)
+#define  indexSEW1     (sdt->sewdrv[0].index)
+#define  indexSEW2     (sdt->sewdrv[1].index)
+#define  indexSEW3     (sdt->sewdrv[2].index)
+#define  valueSEW(Drv) (sdt->sewdrv[(Drv)-1].value.l)
+#define  valueSEW1     (sdt->sewdrv[0].value.l)
+#define  valueSEW2     (sdt->sewdrv[1].value.l)
+#define  valueSEW3     (sdt->sewdrv[2].value.l)
+#define  bvalSEW(Drv,Nb) (sdt->sewdrv[(Drv)-1].value.b[Nb])
+// 23-digit PEP-controllers code
+#define  PEP_code_A  (sdt->pep_code_a)
+#define  PEP_code_Z  (sdt->pep_code_z)
+#define  PEP_code_P  (sdt->pep_code_p)
+// PEP end-switches code
+#define  switch_A  (sdt->pep_sw_a)
+enum{
+     Sw_minus_A    = 1  // negative A value
+    ,Sw_plus240_A  = 2  // end switch +240degr
+    ,Sw_minus240_A = 4  // end switch -240degr
+    ,Sw_minus45_A  = 8  // "horizon" end switch
+};
+#define  switch_Z  (sdt->pep_sw_z)
+enum{
+     Sw_0_Z    = 1
+    ,Sw_5_Z    = 2
+    ,Sw_20_Z   = 4
+    ,Sw_60_Z   = 8
+    ,Sw_80_Z   = 0x10
+    ,Sw_90_Z   = 0x20
+};
+#define  switch_P  (sdt->pep_sw_p)
+enum{
+     Sw_No_P = 0    // no switches
+    ,Sw_22_P = 1    // 22degr
+    ,Sw_89_P = 2    // 89degr
+    ,Sw_Sm_P = 0x80 // Primary focus smoke sensor
+};
+// PEP codes
+#define  PEP_code_F    (sdt->pep_code_f)
+#define  PEP_code_D    (sdt->pep_code_d)
+#define  PEP_code_Rin  (sdt->pep_code_ri)
+#define  PEP_code_Rout (sdt->pep_code_ro)
+// PEP flags
+#define PEP_A_On  (sdt->pep_on[0])
+#define PEP_A_Off (PEP_A_On==0)
+#define PEP_Z_On  (sdt->pep_on[1])
+#define PEP_Z_Off (PEP_Z_On==0)
+#define PEP_P_On  (sdt->pep_on[2])
+#define PEP_P_Off (PEP_P_On==0)
+#define PEP_F_On  (sdt->pep_on[3])
+#define PEP_F_Off (PEP_F_On==0)
+#define PEP_D_On  (sdt->pep_on[4])
+#define PEP_D_Off (PEP_D_On==0)
+#define PEP_R_On  (sdt->pep_on[5])
+#define PEP_R_Off ((PEP_R_On&1)==0)
+#define PEP_R_Inp ((PEP_R_On&2)!=0)
+#define PEP_K_On  (sdt->pep_on[6])
+#define PEP_K_Off ((PEP_K_On&1)==0)
+#define PEP_K_Inp ((PEP_K_On&2)!=0)
+// IERS polar motion
+#define  polarX (sdt->xpol)
+#define  polarY (sdt->ypol)
+// current Julian date, sidereal time correction by "Equation of the Equinoxes"
+#define JDate   (sdt->jdate)
+#define EE_time (sdt->eetime)
+// humidity value (%%) & hand input
+#define  val_Hmd (sdt->val_hmd)
+#define  inp_Hmd (sdt->val_hmd)
+// worm position, mkm
+#define  worm_A (sdt->worm_a)
+#define  worm_Z (sdt->worm_z)
+// locking flags
+#define LockFlags  (sdt->lock_flags)
+enum{
+     Lock_A = 1
+    ,Lock_Z = 2
+    ,Lock_P = 4
+    ,Lock_F = 8
+    ,Lock_D = 0x10
+};
+#define A_Locked   (LockFlags&Lock_A)
+#define Z_Locked   (LockFlags&Lock_Z)
+#define P_Locked   (LockFlags&Lock_P)
+#define F_Locked   (LockFlags&Lock_F)
+#define D_Locked   (LockFlags&Lock_D)
+// SEW dome divers speed
+#define Dome_Speed (sdt->sew_dome_speed)
+// SEW dome drive number (for indication)
+#define DomeSEW_N  (sdt->sew_dome_num)
+// SEW dome driver parameters
+#define  statusSEWD  (sdt->sewdomedrv.status)    // controller status
+#define  speedSEWD   (sdt->sewdomedrv.set_speed) // speed, rpm
+#define  vel_SEWD    (sdt->sewdomedrv.mes_speed) /*���������� �������� ��/��� (rpm)*/
+#define  currentSEWD (sdt->sewdomedrv.current)   // current, A
+#define  indexSEWD   (sdt->sewdomedrv.index)     // parameter index
+#define  valueSEWD   (sdt->sewdomedrv.value.l)   // parameter value
+// dome PEP codes
+#define PEP_code_Din  (sdt->pep_code_di) // data in
+#define PEP_Dome_SEW_Ok   0x200
+#define PEP_Dome_Cable_Ok 0x100
+#define PEP_code_Dout (sdt->pep_code_do) // data out
+#define PEP_Dome_SEW_On   0x10
+#define PEP_Dome_SEW_Off  0x20
+
+
+/*******************************************************************************
+*                         BTA data structure                                   *
+*******************************************************************************/
+
+#define BTA_Data_Ver 2
+struct BTA_Data {
+    int32_t magic;                 // magic value
+    int32_t version;               // BTA_Data_Ver
+    int32_t size;                  // sizeof(struct BTA_Data)
+    int32_t pid;                   // main process PID
+    int32_t model;                 // model modes
+    int32_t timer;                 // timer selected
+    int32_t system;                // main system mode
+    int32_t sys_target;            // system pointing target
+    int32_t tel_focus;             // telescope focus type
+    double pc_coeff[8];            // pointing correction system coefficients
+    int32_t tel_state;             // telescope state
+    int32_t req_state;             // new (required) state
+    int32_t tel_hard_state;        // Power state
+    int32_t tel_mode;              // telescope mode
+    int32_t az_mode;               // azimuth reverce
+    int32_t p2_state;              // P2 motor state
+    int32_t p2_req_mode;           // P2 required state
+    int32_t focus_state;           // focus motor state
+    int32_t dome_state;            // dome motors state
+    int32_t pcor_mode;             // pointing correction mode
+    int32_t trkok_mode;            // tracking mode
+    double i_alpha, i_delta;       // input values
+    double s_alpha, s_delta;       // source
+    double v_alpha, v_delta;       // intrinsic vel.
+    double i_azim, i_zdist;        // input A/Z
+    double c_alpha, c_delta;       // calculated values
+    double tag_a, tag_z, tag_p;    // current values (from sensors)
+    double pcor_a, pcor_z, refr_z; // calculated corrections
+    double tcor_a, tcor_z, tref_z; // reverse calculation corr.
+    double diff_a, diff_z, diff_p; // coords difference
+    double vbasea,vbasez,vbasep;   // base object velocity
+    double diffva,diffvz,diffvp;   // correction by real speed
+    double speeda,speedz,speedp;   // motor speed
+    double m_time_precip;          // last precipitation time
+    uint8_t reserve[16];           // reserved
+    double rspeeda, rspeedz, rspeedp; // real motor speed (''/sec)
+    double simvela, simvelz, simvelp, simvelf, simveld; // model speed
+    uint32_t kost;                 // telescope & hand correction state
+    double m_time, s_time, l_time; // different time (UTC, stellar, local)
+    uint32_t ppndd_a, ppndd_z, ppndd_p, ppndd_b; // PPNDD sensor (rough) code
+    uint32_t dup_a, dup_z, dup_p, dup_f, dup_d;  // DUP sensor (precise) code (Gray code)
+    uint32_t low_a, low_z, low_p, low_f, low_d;  // binary 14-digit precise code
+    uint32_t code_a, code_z, code_p, code_b, code_f, code_d; // binary 23-digit rough code
+    uint32_t adc[8];               // ADC PCL818 (8-channel) codes
+    double val_a, val_z, val_p, val_b, val_f, val_d;
+    double val_t1, val_t2, val_t3, val_wnd; // calculated values
+    double val_alp, val_del;       // RA/Decl calculated by A/Z
+    double vel_a, vel_z, vel_p, vel_f, vel_d; // measured speed
+    // system messages queue
+    struct SysMesg {
+        int32_t seq_num;
+        char type;                  // message type
+        char text[MesgLen];         // message itself
+    } sys_msg_buf[MesgNum];
+    // access levels
+    uint32_t code_lev[5];
+    // network settings
+    uint32_t netmask, netaddr, acsmask, acsaddr;
+    int32_t meteo_stat;            // meteo data
+    double inp_b, inp_t1, inp_t2, inp_t3, inp_wnd; // input meteo values
+    double temper, press;          // values used for refraction calculation
+    double m_time10, m_time15;     // last wind gust time
+    double dut1; // IERS DUT1  (src: ftp://maia.usno.navy.mil/ser7/ser7.dat), DUT1 = UT1-UTC
+    double a_time, z_time, p_time; // sensors reading time
+    double speedain, speedzin, speedpin; // input speeds
+    double acc_a, acc_z, acc_p, acc_f, acc_d; // acceleration (''/sec^2)
+    uint32_t code_sew;             // SEW code
+    struct SEWdata {               // sew data
+        int32_t status;
+        double set_speed;          // target speed, rpm
+        double mes_speed;          // measured speed, rpm
+        double current;            // measured current, A
+        int32_t index;             // parameter number
+        union{                     // parameter code
+            uint8_t b[4];
+            uint32_t l;
+        } value;
+    } sewdrv[3];
+    uint32_t pep_code_a, pep_code_z, pep_code_p; // 23-digit PEP-controllers code
+    uint32_t pep_sw_a, pep_sw_z, pep_sw_p; // PEP end-switches code
+    uint32_t pep_code_f, pep_code_d, pep_code_ri, pep_code_ro; // PEP codes
+    uint8_t pep_on[10];                // PEP flags
+    double xpol, ypol;                 // IERS polar motion (src: ftp://maia.usno.navy.mil/ser7/ser7.dat)
+    double  jdate, eetime;             // current Julian date, sidereal time correction by "Equation of the Equinoxes"
+    double val_hmd, inp_hmd;           // humidity value (%%) & hand input
+    double worm_a, worm_z;             // worm position, mkm
+    /* ����� ���������� ���������� ������ */
+    uint32_t lock_flags;               // locking flags
+    int32_t sew_dome_speed;            // SEW dome divers speed: D_Lplus, D_Hminus etc
+    int32_t sew_dome_num;              // SEW dome drive number (for indication)
+    struct SEWdata  sewdomedrv;        // SEW dome driver parameters
+    uint32_t pep_code_di, pep_code_do; // dome PEP codes
+};
+
+extern volatile struct BTA_Data *sdt;
+
+/*******************************************************************************
+*                       Local data structure                                   *
+*******************************************************************************/
+// Oil pressure, MPa
+#define PressOilA    (sdtl->pr_oil_a)
+#define PressOilZ    (sdtl->pr_oil_z)
+#define PressOilTank (sdtl->pr_oil_t)
+// Oil themperature, degrC
+#define OilTemper1   (sdtl->t_oil_1)  // oil
+#define OilTemper2   (sdtl->t_oil_2)  // water
+
+// Local data structure
+struct BTA_Local {
+    uint8_t reserve[120];        // reserved data
+    double pr_oil_a,pr_oil_z,pr_oil_t; // Oil pressure
+    double t_oil_1,t_oil_2;            // Oil themperature
+};
+
+/**
+ * Message buffer structure
+ */
+struct my_msgbuf {
+    int32_t mtype;    // message type
+    uint32_t acckey;  // client access key
+    uint32_t src_pid; // source PID
+    uint32_t src_ip;  // IP of command source or 0 for local
+    char mtext[100];  // message itself
+};
+
+extern volatile struct BTA_Local *sdtl;
+extern int snd_id;
+extern int cmd_src_pid;
+extern uint32_t cmd_src_ip;
+
+#define ClientSide 0
+#define ServerSide 1
+
+#ifndef BTA_MODULE
+void bta_data_init();
+int  bta_data_check();
+void bta_data_close();
+int get_shm_block(volatile struct SHM_Block *sb, int server);
+int close_shm_block(volatile struct SHM_Block *sb);
+void get_cmd_queue(struct CMD_Queue *cq, int server);
+#endif
+
+int check_shm_block(volatile struct SHM_Block *sb);
+
+void encode_lev_passwd(char *passwd, int nlev, uint32_t *keylev, uint32_t *codlev);
+int find_lev_passwd(char *passwd, uint32_t *keylev, uint32_t *codlev);
+int check_lev_passwd(char *passwd);
+void set_acckey(uint32_t newkey);
+
+// restore packing
+#pragma pack(pop)
+//#pragma GCC diagnostic pop
+
+#endif // __BTA_SHDATA_H__
diff --git a/BTA_dome_modbus/ca/gen.sh b/BTA_dome_modbus/ca/gen.sh
new file mode 100755
index 0000000..e3fee03
--- /dev/null
+++ b/BTA_dome_modbus/ca/gen.sh
@@ -0,0 +1,49 @@
+#!/bin/sh
+
+# https://gist.github.com/zapstar/4b51d7cfa74c7e709fcdaace19233443
+mkdir -p ca/private
+chmod 700 ca/private
+# NOTE: I'm using -nodes, this means that once anybody gets
+# their hands on this particular key, they can become this CA.
+openssl req \
+    -x509 \
+    -nodes \
+    -days 36524 \
+    -newkey rsa:4096 \
+    -keyout ca/private/ca_key.pem \
+    -out ca/ca_cert.pem \
+    -subj "/C=RU/ST=KChR/L=Bukovo/O=SAO RAS/CN=sao.ru"
+
+# Create server private key and certificate request
+mkdir -p server/private
+chmod 700 ca/private
+openssl genrsa -out server/private/server_key.pem 4096
+openssl req -new \
+    -key server/private/server_key.pem \
+    -out server/server.csr \
+    -subj "/C=RU/ST=KChR/L=Bukovo/O=SAO RAS"
+
+# Create client private key and certificate request
+mkdir -p client/private
+chmod 700 client/private
+openssl genrsa -out client/private/client_key.pem 4096
+openssl req -new \
+    -key client/private/client_key.pem \
+    -out client/client.csr \
+    -subj "/C=RU/ST=KChR/L=Bukovo/O=SAO RAS"
+
+# Generate certificates
+openssl x509 -req -days 36524 -in server/server.csr \
+    -CA ca/ca_cert.pem -CAkey ca/private/ca_key.pem \
+    -CAcreateserial -out server/server_cert.pem
+openssl x509 -req -days 36524 -in client/client.csr \
+    -CA ca/ca_cert.pem -CAkey ca/private/ca_key.pem \
+    -CAcreateserial -out client/client_cert.pem
+
+# Now test both the server and the client
+# On one shell, run the following
+# openssl s_server -CAfile ca/ca_cert.pem -cert server/server_cert.pem -key server/private/server_key.pem -Verify 1
+# On another shell, run the following
+# openssl s_client -CAfile ca/ca_cert.pem -cert client/client_cert.pem -key client/private/client_key.pem
+# Once the negotiation is complete, any line you type is sent over to the other side.
+# By line, I mean some text followed by a keyboard return press.
diff --git a/BTA_dome_modbus/client.c b/BTA_dome_modbus/client.c
new file mode 100644
index 0000000..b22172f
--- /dev/null
+++ b/BTA_dome_modbus/client.c
@@ -0,0 +1,101 @@
+/*
+ * This file is part of the sslsosk project.
+ * Copyright 2023 Edward V. Emelianov <edward.emelianoff@gmail.com>.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <usefull_macros.h>
+
+#include "bta_shdata.h"
+#include "client.h"
+
+static int SSL_nbread(SSL *ssl, char *buf, int bufsz){
+    struct pollfd fds = {0};
+    int fd = SSL_get_fd(ssl);
+    fds.fd = fd;
+    fds.events = POLLIN;
+    if(poll(&fds, 1, 1) < 0){ // wait no more than 1ms
+        LOGWARN("SSL_nbread(): poll() failed");
+        WARNX("poll()");
+        return 0;
+    }
+    if(fds.revents == POLLIN){
+//        DBG("Got info in fd #%d", fd);
+        int l = read_string(ssl, buf, bufsz);
+//        DBG("read %d bytes", l);
+        return l;
+    }
+    return 0;
+}
+
+static char *time_asc(double t){
+    static char buf[128];
+    int h, m;
+    double s;
+    h   = (int)(t/3600.);
+    m = (int)((t - (double)h*3600.)/60.);
+    s = t - (double)h*3600. - (double)m*60.;
+    h %= 24;
+    if(s>59) s=59;
+    snprintf(buf, 127, "%d:%02d:%04.1f", h,m,s);
+    return buf;
+}
+
+
+void clientproc(SSL_CTX *ctx, int fd){
+    FNAME();
+    SSL *ssl;
+    char buf[1024];
+    char acClientRequest[1024] = {0};
+    int bytes;
+    if(!get_shm_block(&sdat, ClientSide)){
+        LOGERR("Can't get SHM block");
+        ERRX("Can't get SHM block");
+    }
+    ssl = SSL_new(ctx);
+    SSL_set_fd(ssl, fd);
+    int c = SSL_connect(ssl);
+    if(c < 0){
+        LOGERR("SSL_connect()");
+        ERRX("SSL_connect() error: %d", SSL_get_error(ssl, c));
+    }
+    int enable = 1;
+    if(ioctl(fd, FIONBIO, (void *)&enable) < 0){
+        LOGERR("Can't make socket nonblocking");
+        ERRX("ioctl()");
+    }
+    double t0 = sl_dtime();
+    while(1){
+        if(sl_dtime() - t0 > 3.){
+            if(!check_shm_block(&sdat)){
+                LOGERR("Broken SHM block");
+                ERRX("Broken SHM block");
+            }
+            sprintf(acClientRequest, "UTC: %s\n", time_asc(M_time));
+            SSL_write(ssl, acClientRequest, strlen(acClientRequest));
+            //val_Hmd = 55. + drand48() * 15.;
+            t0 = sl_dtime();
+        }
+        bytes = SSL_nbread(ssl, buf, sizeof(buf));
+        if(bytes > 0){
+            buf[bytes] = 0;
+            printf("Received: \"%s\"\n", buf);
+        }else if(bytes < 0){
+            LOGWARN("Server disconnected or other error");
+            ERRX("Disconnected");
+        }
+    }
+    SSL_free(ssl);
+}
diff --git a/BTA_dome_modbus/client.h b/BTA_dome_modbus/client.h
new file mode 100644
index 0000000..5fa2171
--- /dev/null
+++ b/BTA_dome_modbus/client.h
@@ -0,0 +1,23 @@
+/*
+ * This file is part of the sslsosk project.
+ * Copyright 2023 Edward V. Emelianov <edward.emelianoff@gmail.com>.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "sslsock.h"
+
+void clientproc(SSL_CTX *ctx, int fd);
diff --git a/BTA_dome_modbus/cmdlnopts.c b/BTA_dome_modbus/cmdlnopts.c
new file mode 100644
index 0000000..11b8dbb
--- /dev/null
+++ b/BTA_dome_modbus/cmdlnopts.c
@@ -0,0 +1,96 @@
+/*
+ * This file is part of the sslsosk project.
+ * Copyright 2023 Edward V. Emelianov <edward.emelianoff@gmail.com>.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
+#include <strings.h>
+#include <usefull_macros.h>
+
+#include "cmdlnopts.h"
+
+
+/*
+ * here are global parameters initialisation
+ */
+static int help;
+
+#ifdef SERVER
+#define DEFCERT     "server_cert.pem"
+#define DEFKEY      "server_key.pem"
+#else
+#define DEFCERT     "client_cert.pem"
+#define DEFKEY      "client_key.pem"
+#endif
+#define DEFCA       "ca_cert.pem"
+// default global parameters
+glob_pars G = {
+    .pidfile = DEFAULT_PIDFILE,
+    .port = DEFAULT_PORT,
+    .cert = DEFCERT,
+    .key = DEFKEY,
+    .ca = DEFCA,
+    .acc_timeout = 1.,
+};
+
+/*
+ * Define command line options by filling structure:
+ *  name        has_arg     flag    val     type        argptr              help
+*/
+static sl_option_t cmdlnopts[] = {
+// common options
+    {"help",    NO_ARGS,    NULL,   'h',    arg_int,    APTR(&help),        _("show this help")},
+    {"logfile", NEED_ARG,   NULL,   'l',    arg_string, APTR(&G.logfile),   _("file to save logs")},
+    {"pidfile", NEED_ARG,   NULL,   'P',    arg_string, APTR(&G.pidfile),   _("pidfile (default: " DEFAULT_PIDFILE ")")},
+    {"certificate",NEED_ARG,NULL,   'c',    arg_string, APTR(&G.cert),      _("path to SSL sertificate (default: " DEFCERT ")")},
+    {"key",     NEED_ARG,   NULL,   'k',    arg_string, APTR(&G.key),       _("path to SSL key (default: " DEFKEY ")")},
+    {"port",    NEED_ARG,   NULL,   'p',    arg_string, APTR(&G.port),      _("port to open (default: " DEFAULT_PORT ")")},
+    {"verbose", NO_ARGS,    NULL,   'v',    arg_none,   APTR(&G.verbose),   _("increase log verbose level (default: LOG_WARN)")},
+    {"ca",      NEED_ARG,   NULL,   'a',    arg_string, APTR(&G.ca),        _("path to SSL ca - base cert (default:" DEFCA ")")},
+#ifdef SERVER
+    {"timeout", NEED_ARG,   NULL,   't',    arg_double, APTR(&G.acc_timeout),_("server's accept timeout, s")},
+#endif
+#ifdef CLIENT
+    {"server",  NEED_ARG,   NULL,   's',    arg_string, APTR(&G.serverhost),  _("server IP address or name")},
+#endif
+   end_option
+};
+
+/**
+ * Parse command line options and return dynamically allocated structure
+ *      to global parameters
+ * @param argc - copy of argc from main
+ * @param argv - copy of argv from main
+ */
+void parse_args(int argc, char **argv){
+    int i;
+    size_t hlen = 1024;
+    char helpstring[1024], *hptr = helpstring;
+    snprintf(hptr, hlen, "Usage: %%s [args]\n\n\tWhere args are:\n");
+    // format of help: "Usage: progname [args]\n"
+    sl_helpstring(helpstring);
+    // parse arguments
+    sl_parseargs(&argc, &argv, cmdlnopts);
+    if(help) sl_showhelp(-1, cmdlnopts);
+    if(argc > 0){
+        red("Ignored options:\n");
+        for (i = 0; i < argc; i++)
+            printf("\t%s\n", argv[i]);
+    }
+}
+
diff --git a/BTA_dome_modbus/cmdlnopts.h b/BTA_dome_modbus/cmdlnopts.h
new file mode 100644
index 0000000..658fd18
--- /dev/null
+++ b/BTA_dome_modbus/cmdlnopts.h
@@ -0,0 +1,53 @@
+/*
+ * This file is part of the sslsosk project.
+ * Copyright 2023 Edward V. Emelianov <edward.emelianoff@gmail.com>.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+// default PID filename:
+#ifndef DEFAULT_PIDFILE
+    #ifdef SERVER
+        #define DEFAULT_PIDFILE "/tmp/domeserver.pid"
+    #else
+        #define DEFAULT_PIDFILE "/tmp/domeclt.pid"
+    #endif
+#endif
+#ifndef DEFAULT_PORT
+#define DEFAULT_PORT    "4444"
+#endif
+
+/*
+ * here are some typedef's for global data
+ */
+typedef struct{
+    int acc_timeout;        // accept() timeout
+    char *pidfile;          // name of PID file
+    char *logfile;          // logging to this file
+    char *cert;             // sertificate
+    char *key;              // key
+    char *port;             // port number
+    int verbose;            // logfile verbose level
+    char *ca;               // ca
+#ifdef CLIENT
+    char *serverhost;       // server IP address
+#endif
+} glob_pars;
+
+extern glob_pars G;
+
+void parse_args(int argc, char **argv);
+
diff --git a/BTA_dome_modbus/daemon.c b/BTA_dome_modbus/daemon.c
new file mode 100644
index 0000000..aab7dfd
--- /dev/null
+++ b/BTA_dome_modbus/daemon.c
@@ -0,0 +1,119 @@
+/*
+ * This file is part of the sslsosk project.
+ * Copyright 2023 Edward V. Emelianov <edward.emelianoff@gmail.com>.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <signal.h>
+#include <stdio.h>
+#include <sys/prctl.h>      // prctl
+#include <sys/wait.h>       // wait
+#include <unistd.h>
+#include <usefull_macros.h>
+
+#include "cmdlnopts.h"
+#include "daemon.h"
+#include "sslsock.h"
+
+static pid_t childpid = -1;
+static double tstart = 0.; // time of fork()
+
+void signals(int sig){
+    int savelogs = (sl_dtime() - tstart > 30.) ? TRUE : FALSE;
+    if(childpid == 0){
+        if(savelogs) LOGWARN("Child killed with sig=%d", sig);
+        exit(sig); // slave process
+    }
+    // master process
+    if(sig){
+        signal(sig, SIG_IGN);
+        if(savelogs) LOGERR("Exit with signal %d", sig);
+    }else if(savelogs) LOGERR("Exit");
+    if(G.pidfile) unlink(G.pidfile);
+    exit(sig);
+}
+
+/**
+ * @brief start_daemon - daemonize
+ * @return error code or 0
+ */
+int start_daemon(){
+    FNAME();
+    // check args
+    int port = atoi(G.port);
+    if(port < 1024 || port > 65535){
+        LOGERR("Wrong port value: %d", port);
+        return 1;
+    }
+    FILE *f = fopen(G.cert, "r");
+    if(!f) ERR("Can't open certificate file %s", G.cert);
+    fclose(f);
+    f = fopen(G.key, "r");
+    if(!f) ERR("Can't open certificate key file %s", G.key);
+    fclose(f);
+#ifdef EBUG
+    printf("cert: %s, key: %s\n", G.cert, G.key);
+#endif
+#ifdef CLIENT
+    //DBG("server: %s", G.serverhost);
+    if(!G.serverhost) ERRX("Point server name");
+#endif
+    if(G.logfile){
+        int lvl = LOGLEVEL_WARN + G.verbose;
+        DBG("level = %d", lvl);
+        if(lvl > LOGLEVEL_ANY) lvl = LOGLEVEL_ANY;
+        green("Log file %s @ level %d\n", G.logfile, lvl);
+        OPENLOG(G.logfile, lvl, 1);
+    }
+    signal(SIGTERM, signals); // kill (-15) - quit
+    signal(SIGHUP, SIG_IGN);  // hup - ignore
+    signal(SIGINT, signals);  // ctrl+C - quit
+    signal(SIGQUIT, signals); // ctrl+\ - quit
+    signal(SIGTSTP, SIG_IGN); // ignore ctrl+Z
+    LOGMSG("Started");
+#ifndef EBUG
+    sl_check4running(NULL, G.pidfile);
+    int savelogs = TRUE;
+    tstart = sl_dtime();
+    while(1){
+        childpid = fork();
+        if(childpid){ // master
+            if(savelogs) LOGMSG("Created child with pid %d", childpid);
+            wait(NULL);
+            if(savelogs) LOGWARN("Child %d died", childpid);
+            double twork = sl_dtime() - tstart;
+            if(twork < 30.) savelogs = FALSE; // too fast respawn
+            else{
+                const char* Tstr[] = {"seconds", "minutes", "hours", "days"};
+                double Tw;
+                int idx;
+                if(twork < 60.){ Tw = twork; idx = 0; }
+                else if(twork < 3600.){ Tw = twork / 60.; idx = 1; }
+                else if(twork < 86400.){ Tw = twork / 3600.; idx = 2; }
+                else{ Tw = twork / 86400.; idx = 3; }
+                LOGMSG("Child %d works for %.1f %s", childpid, Tw, Tstr[idx]);
+                savelogs = TRUE;
+            }
+            sleep(2); // wait a little before respawn
+            tstart = sl_dtime();
+        }else{ // slave
+            prctl(PR_SET_PDEATHSIG, SIGTERM); // send SIGTERM to child when parent dies
+            break;
+        }
+    }
+#endif
+    // parent should never reach this part of code
+    return open_socket();
+}
diff --git a/BTA_dome_modbus/daemon.h b/BTA_dome_modbus/daemon.h
new file mode 100644
index 0000000..7ab62c4
--- /dev/null
+++ b/BTA_dome_modbus/daemon.h
@@ -0,0 +1,22 @@
+/*
+ * This file is part of the sslsosk project.
+ * Copyright 2023 Edward V. Emelianov <edward.emelianoff@gmail.com>.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+int start_daemon();
+
diff --git a/BTA_dome_modbus/main.c b/BTA_dome_modbus/main.c
new file mode 100644
index 0000000..92cc6f1
--- /dev/null
+++ b/BTA_dome_modbus/main.c
@@ -0,0 +1,28 @@
+/*
+ * This file is part of the sslsosk project.
+ * Copyright 2023 Edward V. Emelianov <edward.emelianoff@gmail.com>.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <usefull_macros.h>
+
+#include "daemon.h"
+#include "cmdlnopts.h"
+
+int main(int argc, char **argv){
+    sl_init();
+    parse_args(argc, argv);
+    return start_daemon();
+}
diff --git a/BTA_dome_modbus/run_client b/BTA_dome_modbus/run_client
new file mode 100755
index 0000000..923944b
--- /dev/null
+++ b/BTA_dome_modbus/run_client
@@ -0,0 +1,3 @@
+#!/bin/bash
+rm client.log 2>/dev/null
+./dome_client -a ca/ca/ca_cert.pem -c ca/client/client_cert.pem -k ca/client/private/client_key.pem -vvv -s localhost -l client.log
diff --git a/BTA_dome_modbus/run_server b/BTA_dome_modbus/run_server
new file mode 100755
index 0000000..7514f3b
--- /dev/null
+++ b/BTA_dome_modbus/run_server
@@ -0,0 +1,3 @@
+#!/bin/bash
+rm server.log 2>/dev/null
+./dome_server -a ca/ca/ca_cert.pem -c ca/server/server_cert.pem -k ca/server/private/server_key.pem -vvvl server.log
diff --git a/BTA_dome_modbus/server.c b/BTA_dome_modbus/server.c
new file mode 100644
index 0000000..b1cece4
--- /dev/null
+++ b/BTA_dome_modbus/server.c
@@ -0,0 +1,139 @@
+/*
+ * This file is part of the sslsosk project.
+ * Copyright 2023 Edward V. Emelianov <edward.emelianoff@gmail.com>.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <usefull_macros.h>
+
+#include "cmdlnopts.h"
+#include "server.h"
+
+static const char *maxcl = "Max client number reached, connect later\n";
+static const char *sslerr = "SSL error occured\n";
+
+// return 0 if client disconnected
+static int handle_connection(SSL *ssl){
+    char buf[1024];
+    int r = read_string(ssl, buf, 1024);
+    if(r < 0) return 0;
+    int sd = SSL_get_fd(ssl);
+    printf("Client %d msg: \"%s\"\n", sd, buf);
+    LOGDBG("fd=%d, message=%s", sd, buf);
+    snprintf(buf, 1024, "Hello, your FD=%d\n", sd);
+    SSL_write(ssl, buf, strlen(buf));
+    return 1;
+}
+
+/**
+ * @brief timeouted_sslaccept - SSL_accept with timeout
+ * @param ssl - SSL
+ * @return 1 if connection ready or 0 if error
+ */
+static int timeouted_sslaccept(SSL *ssl){
+    double t0 = sl_dtime();
+    while(sl_dtime() - t0 < G.acc_timeout){
+        int x = SSL_accept(ssl);
+        if(x < 0){
+            int sslerr = SSL_get_error(ssl, x);
+            if(SSL_ERROR_WANT_READ == sslerr ||
+                SSL_ERROR_WANT_WRITE == sslerr) continue;
+            DBG("SSL error %d", sslerr);
+            return FALSE;
+        }
+        else return TRUE;
+    }
+    DBG("Timeout");
+    return FALSE;
+}
+
+void serverproc(SSL_CTX *ctx, int fd){
+    char buf[64];
+    int P = 0;
+    int enable = 1;
+    if(ioctl(fd, FIONBIO, (void *)&enable) < 0){
+        LOGERR("Can't make socket nonblocking");
+        ERRX("ioctl()");
+    }
+    int nfd = 1; // only one listening socket @start
+    struct pollfd poll_set[BACKLOG+1];
+    memset(poll_set, 0, sizeof(poll_set));
+    poll_set[0].fd = fd;
+    poll_set[0].events = POLLIN;
+    SSL *ssls[BACKLOG+1] = {0}; // !!! start from 1 - like in poll_set !!!
+    double t0 = sl_dtime(), tstart = t0;
+    while(1){
+        double tnow = sl_dtime();
+        if(tnow - t0 > 5. && nfd > 1){ // broadcasting message
+            //DBG("send ping");
+            snprintf(buf, 63, "ping #%d; t=%g\n", ++P, tnow - tstart);
+            int l = strlen(buf);
+            for(int i = nfd-1; i > 0; --i){
+                //DBG("To fd[%d]=%d", i, poll_set[i].fd);
+                SSL_write(ssls[i], buf, l);
+            }
+            t0 = tnow;
+        }
+        poll(poll_set, nfd, 1); // max timeout - 1ms
+        // check for accept()
+        if(poll_set[0].revents & POLLIN){
+            struct sockaddr_in addr;
+            socklen_t len = sizeof(addr);
+            int client = accept4(fd, (struct sockaddr*)&addr, &len, SOCK_NONBLOCK); // non-blocking for timeout of SSL_accept
+            DBG("Connection: %s @ %d (fd=%d)\n", inet_ntoa(addr.sin_addr), ntohs(addr.sin_port), client);
+            LOGMSG("Client %s connected to port %d (fd=%d)", inet_ntoa(addr.sin_addr), ntohs(addr.sin_port), client);
+            if(nfd == BACKLOG + 1){
+                LOGWARN("Max amount of connections: disconnect fd=%d", client);
+                WARNX("Limit of connections reached");
+                send(client, maxcl, sizeof(maxcl)-1, MSG_NOSIGNAL);
+                close(client);
+            }else{
+                DBG("New ssl");
+                SSL *ssl = SSL_new(ctx);
+                SSL_set_fd(ssl, client);
+                DBG("Accept");
+                if(timeouted_sslaccept(ssl)){
+                    DBG("OK");
+                    ssls[nfd] = ssl;
+                    memset(&poll_set[nfd], 0, sizeof(struct pollfd));
+                    poll_set[nfd].fd = client;
+                    poll_set[nfd].events = POLLIN;
+                    ++nfd;
+                }else{
+                    LOGERR("SSL_accept()");
+                    WARNX("SSL_accept()");
+                    SSL_free(ssl);
+                    send(client, sslerr, sizeof(sslerr)-1, MSG_NOSIGNAL);
+                    close(client);
+                }
+            }
+        }
+        // scan connections
+        for(int fdidx = 1; fdidx < nfd; ++fdidx){
+            if((poll_set[fdidx].revents & POLLIN) == 0) continue;
+            int fd = poll_set[fdidx].fd;
+            if(!handle_connection(ssls[fdidx])){ // socket closed
+                SSL_free(ssls[fdidx]);
+                DBG("Client fd=%d disconnected", fd);
+                LOGMSG("Client fd=%d disconnected", fd);
+                close(fd);
+                if(--nfd > fdidx){ // move last FD to current position
+                    poll_set[fdidx] = poll_set[nfd];
+                    ssls[fdidx] = ssls[nfd];
+                }
+            }
+        }
+    }
+}
diff --git a/BTA_dome_modbus/server.h b/BTA_dome_modbus/server.h
new file mode 100644
index 0000000..13f171d
--- /dev/null
+++ b/BTA_dome_modbus/server.h
@@ -0,0 +1,23 @@
+/*
+ * This file is part of the sslsosk project.
+ * Copyright 2023 Edward V. Emelianov <edward.emelianoff@gmail.com>.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "sslsock.h"
+
+void serverproc(SSL_CTX *ctx, int fd);
diff --git a/BTA_dome_modbus/sslsock.c b/BTA_dome_modbus/sslsock.c
new file mode 100644
index 0000000..ed6bae1
--- /dev/null
+++ b/BTA_dome_modbus/sslsock.c
@@ -0,0 +1,185 @@
+/*
+ * This file is part of the sslsosk project.
+ * Copyright 2023 Edward V. Emelianov <edward.emelianoff@gmail.com>.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <pthread.h>
+#include <resolv.h>
+#include <signal.h>     // pthread_kill
+#include <stdio.h>
+#include <string.h>
+#include <usefull_macros.h>
+
+#include "cmdlnopts.h"
+#include "sslsock.h"
+#ifdef SERVER
+#include "server.h"
+#else
+#include "client.h"
+#endif
+
+#ifdef SERVER
+static int OpenConn(int port){
+    int sd = socket(PF_INET, SOCK_STREAM, 0);
+    if(sd < 0){
+        LOGERR("Can't open socket");
+        ERRX("socket()");
+    }
+    int enable = 1;
+    // allow reuse of descriptor
+    if(setsockopt(sd, SOL_SOCKET,  SO_REUSEADDR, (void *)&enable, sizeof(int)) < 0){
+        LOGERR("Can't apply SO_REUSEADDR to socket");
+        ERRX("setsockopt()");
+    }
+    struct sockaddr_in addr = {0};
+    addr.sin_family = AF_INET;
+    addr.sin_port = htons(port);
+    addr.sin_addr.s_addr = INADDR_ANY;
+    if(bind(sd, (struct sockaddr*)&addr, sizeof(addr))){
+        LOGWARN("Can't bind port %d", port);
+        ERRX("bind()");
+    }
+    if(listen(sd, BACKLOG)){
+        LOGWARN("Can't listen()");
+        ERRX("listen()");
+    }
+    return sd;
+}
+#else
+static int OpenConn(int port){
+    FNAME();
+    int sd;
+    struct hostent *host;
+    struct sockaddr_in addr;
+    if((host = gethostbyname(G.serverhost)) == NULL ){
+        LOGWARN("gethostbyname(%s) error", G.serverhost);
+        ERRX("gethostbyname()");
+    }
+    sd = socket(PF_INET, SOCK_STREAM, 0);
+    DBG("sd=%d", sd);
+    bzero(&addr, sizeof(addr));
+    addr.sin_family = AF_INET;
+    addr.sin_port = htons(port);
+    addr.sin_addr.s_addr = *(long*)(host->h_addr);
+    if(connect(sd, (struct sockaddr*)&addr, sizeof(addr))){
+        close(sd);
+        LOGWARN("Can't connect to %s", G.serverhost);
+        ERRX("connect()");
+    }
+    return sd;
+}
+#endif
+
+static SSL_CTX* InitCTX(void){
+    const SSL_METHOD *method;
+    SSL_CTX *ctx;
+    OpenSSL_add_all_algorithms();
+    SSL_load_error_strings();
+    method =
+#ifdef CLIENT
+      TLS_client_method();
+#else
+      TLS_server_method();
+#endif
+    ctx = SSL_CTX_new(method);
+    if(!ctx){
+        LOGWARN("Can't create SSL context");
+        ERRX("SSL_CTX_new()");
+    }
+    if(SSL_CTX_load_verify_locations(ctx, G.ca, NULL) != 1){
+        LOGWARN("Could not set the CA file location\n");
+        ERRX("Could not set the CA file location\n");
+    }
+#ifdef SERVER
+
+    SSL_CTX_set_client_CA_list(ctx, SSL_load_client_CA_file(G.ca));
+#endif
+    if(SSL_CTX_use_certificate_file(ctx, G.cert, SSL_FILETYPE_PEM) <= 0){
+        LOGWARN("Can't use SSL certificate %s", G.cert);
+        ERRX("Can't use SSL certificate %s", G.cert);
+    }
+    if(SSL_CTX_use_PrivateKey_file(ctx, G.key, SSL_FILETYPE_PEM) <= 0){
+        LOGWARN("Can't use SSL key %s", G.key);
+        ERRX("Can't use SSL key %s", G.key);
+    }
+    if(!SSL_CTX_check_private_key(ctx)){
+        LOGWARN("Private key does not match the public certificate\n");
+        ERRX("Private key does not match the public certificate\n");
+    }
+    SSL_CTX_set_mode(ctx, SSL_MODE_AUTO_RETRY);
+#ifdef SERVER
+    SSL_CTX_set_verify(ctx, // Specify that we need to verify the client as well
+       SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
+       NULL);
+#else
+    SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER, NULL);
+#endif
+    SSL_CTX_set_verify_depth(ctx, 1); // We accept only certificates signed only by the CA himself
+    return ctx;
+}
+
+int open_socket(){
+    int fd;
+    SSL_library_init();
+    SSL_CTX *ctx = InitCTX();
+    fd = OpenConn(atoi(G.port));
+#ifdef SERVER
+    serverproc(ctx, fd);
+#else
+    clientproc(ctx, fd);
+#endif
+    // newer reached
+    close(fd);
+    SSL_CTX_free(ctx);
+    return 0;
+}
+
+static int geterrcode(SSL *ssl, int errcode){
+    int sslerr = SSL_get_error(ssl, errcode);
+    DBG("ERR: %d", sslerr);
+    if(SSL_ERROR_WANT_READ == sslerr ||
+        SSL_ERROR_WANT_WRITE == sslerr) return 0; // empty call
+    int sd = SSL_get_fd(ssl);
+    LOGERR("SSL error %d @client %d", sslerr, sd);
+    WARNX("SSL error %d @client %d", sslerr, sd);
+    return -1;
+}
+
+/**
+ * @brief read_string - read '\n'-terminated string from SSL
+ * @param ssl - SSL
+ * @param buf - buffer for text
+ * @param l - max buf length (including zero)
+ * @return amount of bytes read or -1 if client disconnected
+ */
+int read_string(SSL *ssl, char *buf, int l){
+    if(!ssl || l < 1) return 0;
+    int bytes = SSL_peek(ssl, buf, l);
+    DBG("Peek: %d", bytes);
+    if(bytes < 1){ // nothing to read or error
+        return geterrcode(ssl, bytes);
+    }
+    if(bytes < l && buf[bytes-1] != '\n'){ // string not ready, no buffer overfull
+        return 0; // wait a rest of string
+    }
+    bytes = SSL_read(ssl, buf, l);
+    DBG("Read: %d", bytes);
+    if(bytes < 1){ // error
+        return geterrcode(ssl, bytes);
+    }
+    buf[bytes-1] = 0; // replace '\n' with 0
+    return bytes;
+}
diff --git a/BTA_dome_modbus/sslsock.h b/BTA_dome_modbus/sslsock.h
new file mode 100644
index 0000000..c72c4d6
--- /dev/null
+++ b/BTA_dome_modbus/sslsock.h
@@ -0,0 +1,41 @@
+/*
+ * This file is part of the sslsosk project.
+ * Copyright 2023 Edward V. Emelianov <edward.emelianoff@gmail.com>.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include <arpa/inet.h>  // inet_ntop
+#include <fcntl.h>
+#include <netdb.h>      // addrinfo
+#include <netinet/in.h>
+#include <openssl/err.h>
+#include <openssl/ssl.h>
+#include <poll.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+
+#if ! defined CLIENT && ! defined SERVER
+#error "Define CLIENT or SERVER before including this file"
+#endif
+#if defined CLIENT && defined SERVER
+#error "Both CLIENT and SERVER defined"
+#endif
+
+#define BACKLOG     10
+
+int open_socket();
+int read_string(SSL *ssl, char *buf, int l);
diff --git a/BTA_dome_modbus/sslsosk.cflags b/BTA_dome_modbus/sslsosk.cflags
new file mode 100644
index 0000000..68d5165
--- /dev/null
+++ b/BTA_dome_modbus/sslsosk.cflags
@@ -0,0 +1 @@
+-std=c17
\ No newline at end of file
diff --git a/BTA_dome_modbus/sslsosk.config b/BTA_dome_modbus/sslsosk.config
new file mode 100644
index 0000000..82961ff
--- /dev/null
+++ b/BTA_dome_modbus/sslsosk.config
@@ -0,0 +1,7 @@
+#define _GNU_SOURCE 
+#define _XOPEN_SOURCE 1111
+#define CLIENT
+#define EBUG
+
+//#define SERVER
+
diff --git a/BTA_dome_modbus/sslsosk.creator b/BTA_dome_modbus/sslsosk.creator
new file mode 100644
index 0000000..e94cbbd
--- /dev/null
+++ b/BTA_dome_modbus/sslsosk.creator
@@ -0,0 +1 @@
+[General]
diff --git a/BTA_dome_modbus/sslsosk.cxxflags b/BTA_dome_modbus/sslsosk.cxxflags
new file mode 100644
index 0000000..6435dfc
--- /dev/null
+++ b/BTA_dome_modbus/sslsosk.cxxflags
@@ -0,0 +1 @@
+-std=c++17
\ No newline at end of file
diff --git a/BTA_dome_modbus/sslsosk.files b/BTA_dome_modbus/sslsosk.files
new file mode 100644
index 0000000..c57f565
--- /dev/null
+++ b/BTA_dome_modbus/sslsosk.files
@@ -0,0 +1,13 @@
+bta_shdata.c
+bta_shdata.h
+client.c
+client.h
+cmdlnopts.c
+cmdlnopts.h
+daemon.c
+daemon.h
+main.c
+server.c
+server.h
+sslsock.c
+sslsock.h
diff --git a/BTA_dome_modbus/sslsosk.includes b/BTA_dome_modbus/sslsosk.includes
new file mode 100644
index 0000000..9c558e3
--- /dev/null
+++ b/BTA_dome_modbus/sslsosk.includes
@@ -0,0 +1 @@
+.