From 9dcfafa5e48b71553e084d8ffd3a15e6aa86f316 Mon Sep 17 00:00:00 2001 From: Edward Emelianov Date: Wed, 18 Nov 2026 17:50:39 +0300 Subject: [PATCH] more fixes --- BTA_dome_modbus/Makefile | 18 +- BTA_dome_modbus/Readme.md | 498 ++++++++++++++++++++++++++++++++ BTA_dome_modbus/bta_shdata.c | 30 +- BTA_dome_modbus/client.c | 95 +++--- BTA_dome_modbus/cmdlnopts.c | 5 +- BTA_dome_modbus/daemon.c | 8 +- BTA_dome_modbus/esq770.h | 6 +- BTA_dome_modbus/handlers_list.h | 4 +- BTA_dome_modbus/io.c | 13 +- BTA_dome_modbus/motors.c | 66 ++++- BTA_dome_modbus/motors.h | 1 + BTA_dome_modbus/server.c | 41 ++- BTA_dome_modbus/sslsock.c | 59 +++- BTA_dome_modbus/sslsock.h | 1 + BTA_dome_modbus/sslsosk.files | 2 + 15 files changed, 742 insertions(+), 105 deletions(-) create mode 100644 BTA_dome_modbus/Readme.md diff --git a/BTA_dome_modbus/Makefile b/BTA_dome_modbus/Makefile index 72ab840..36c2e35 100644 --- a/BTA_dome_modbus/Makefile +++ b/BTA_dome_modbus/Makefile @@ -2,7 +2,7 @@ CLIENT := dome_client SERVER := dome_server LDFLAGS += -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--discard-all -LDFLAGS += -lusefull_macros -lssl -lcrypto +LDFLAGS += -pthread -lusefull_macros -lssl -lcrypto DEFINES := $(DEF) -D_GNU_SOURCE -D_XOPEN_SOURCE=1111 SOBJDIR := mkserver COBJDIR := mkclient @@ -18,7 +18,7 @@ CC = gcc TARGFILE := build.target -ifeq ($(shell test -e $(TARGFILE) && echo -n yes),yes) +ifeq ($(shell test -e $(TARGFILE) && printf yes),yes) TARGET := $(file < $(TARGFILE)) else TARGET := RELEASE @@ -30,6 +30,7 @@ endif release: CFLAGS += -flto release: LDFLAGS += -flto +release: TARGET := RELEASE release: $(TARGFILE) $(CLIENT) $(SERVER) debug: CFLAGS += -DEBUG -Werror @@ -41,16 +42,17 @@ $(TARGFILE): @echo "$(TARGET)" > $(TARGFILE) $(CLIENT) : DEFINES += -DCLIENT +$(CLIENT) : LDFLAGS += -lcrypt $(CLIENT) : $(COBJDIR) $(COBJS) @echo -e "\tLD $(CLIENT)" - $(CC) $(LDFLAGS) $(COBJS) -o $(CLIENT) + $(CC) $(COBJS) -o $(CLIENT) $(LDFLAGS) $(SERVER) : DEFINES += -DSERVER $(SERVER) : LDFLAGS += -lmodbus $(SERVER) : $(SOBJDIR) $(SOBJS) @echo -e "\tLD $(SERVER)" - $(CC) $(LDFLAGS) $(SOBJS) -o $(SERVER) + $(CC) $(SOBJS) -o $(SERVER) $(LDFLAGS) $(SOBJDIR): @mkdir $(SOBJDIR) @@ -65,17 +67,17 @@ endif $(COBJDIR)/%.o: %.c @echo -e "\tCC $<" - $(CC) -MP -MMD -c $(LDFLAGS) $(CFLAGS) $(DEFINES) -o $@ $< + $(CC) -MP -MMD -c $(CFLAGS) $(DEFINES) -o $@ $< $(SOBJDIR)/%.o: %.c @echo -e "\t\tCC $<" - $(CC) -MP -MMD -c $(LDFLAGS) $(CFLAGS) $(DEFINES) -o $@ $< + $(CC) -MP -MMD -c $(CFLAGS) $(DEFINES) -o $@ $< clean: @echo -e "\t\tCLEAN" @rm -rf $(SOBJDIR) $(COBJDIR) $(TARGFILE) 2>/dev/null || true xclean: clean - @rm -f $(PROGRAM) + @rm -f $(CLIENT) $(SERVER) -.PHONY: clean xclean +.PHONY: clean xclean $(TARGFILE) diff --git a/BTA_dome_modbus/Readme.md b/BTA_dome_modbus/Readme.md new file mode 100644 index 0000000..c6f9bbf --- /dev/null +++ b/BTA_dome_modbus/Readme.md @@ -0,0 +1,498 @@ +# Dome Control System over SSL-sockets + +## 1. Overview + +The product is a two‑part system for controlling BTA dome driven by a set of AC motors with +**ESQ‑770** frequency converters and a **Modbus I/O board** (relays, discrete inputs, ADC): + +* **`dome_server`** — runs on the machine connected to the RS‑485 bus. It talks Modbus RTU to the +frequency converters and the I/O board, and serves an SSL/TLS socket with a simple ASCII line +protocol. +* **`dome_client`** — connects to the server, keeps the dome shared‑memory block (`bta_shdata`) up +to date, drives the motors according to commands from the higher‑level control system, and can also +be used interactively in *terminal mode*. + +Both binaries share the same argument parser, daemonization code, and SSL socket layer. The client +and server are mutually exclusive builds of the same sources (`-DCLIENT` / `-DSERVER`). + +Key properties: + +| Property | Value | +|---|---| +| Transport | TCP + TLS (min. TLS 1.2), mutual authentication | +| Default port | 4444 | +| Protocol | newline‑terminated ASCII, `key` (getter) or `key=value` (setter) | +| Motor bus | Modbus RTU over RS‑485, 10 drives, IDs 1…10 | +| Max SSL clients | 10 (`BACKLOG`) | +| Network timeout | 1 s (configurable) | + + +## 2. Repository layout + +| File | Purpose | +|---|---| +| `main.c` | Entry point: init, parse args, start daemon | +| `cmdlnopts.c/.h` | Command line / config file parsing, global `G` structure | +| `daemon.c/.h` | Daemonization, PID file, signal handling, child supervision | +| `sslsock.c/.h` | SSL context creation, socket open/connect, `read_string()` | +| `client.c/.h` | Client main loop, terminal mode, motor polling, speed control | +| `server.c/.h` | Server poll loop, connection handling, command dispatch, handlers | +| `motors.c/.h` | Modbus motor control, state cache, emulation, logging | +| `io.c/.h` | Modbus I/O board: relays, inputs, ADC, safety interlock logic | +| `esq770.h` | ESQ‑770 register map, command/status codes, unit conversions | +| `handlers_list.h` | X‑macro list of protocol commands (must stay sorted!) | +| `Makefile` | Build rules for `dome_client` / `dome_server` | +| `bta_shdata.c/.h` | shared memory with the dome control subsystem | + + +## 3. Building + +```sh +make # release build (adds -flto); the default target +make debug # debug build (-Werror, -DEBUG) +make clean # remove object dirs and build.target +make xclean # clean + remove binaries +``` + +Dependencies: + +* [`libusefull_macros`](https://github.com/eddyem/snippets_library) (logging, CLI parsing, config files, time helpers) +* OpenSSL (`libssl`, `libcrypto`) +* [`libmodbus`](https://github.com/stephane/libmodbus) (server only) +* `libcrypt` (client only) + +Build details: + +* The selected target is stored in `build.target`; if it contains `DEBUG`, a plain `make` also +builds the debug variant. Use `make DEF=...` to append extra defines. +* Binaries are `dome_server` and `dome_client`; objects go to `mkserver/` and `mkclient/` +respectively. +* The debug build passes `-DEBUG`, which GCC interprets as `-D EBUG`, i.e. it defines the `EBUG` +macro used throughout the code for verbose diagnostic printing. + + +## 4. Architecture + +``` + higher-level control (GUI / SHM) operator (terminal mode) + | | + bta_shdata <--- dome_client ---TLS---> dome_server + | + Modbus RTU (RS-485) + / \ + ESQ-770 drives 1..10 I/O board + (motors) (relays/inputs/ADC) +``` + +* The **client** reads the shared memory block `sdat` (dome speed command, lock flags, telescope +position, server PID, etc.), polls motor state from the server in a round‑robin fashion, writes +averaged state and SEW data back into SHM, and sends status messages to the GUI via +`SendMessage()`. +* The **server** is a poll‑driven event loop: every iteration it advances the motor state machine, +processes the I/O board, and serves any pending SSL traffic. +* Both sides are non‑blocking; the server uses `poll()` with an 1 ms timeout, the client sleeps ~100 +ms per cycle. + + +## 5. SSL layer (`sslsock.c`) + +`open_socket()`: + +1. Initializes the OpenSSL library and creates a context (`TLS_server_method()` / +`TLS_client_method()`). +2. Requires TLS ≥ 1.2. +3. Loads the CA file (`-a`, default `ca_cert.pem`); on the server side the CA list is also loaded +so the client certificate can be requested. +4. Loads the certificate (`-c`) and private key (`-k`), checks key/cert match. +5. Verification: + * **Server**: `SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT` — a valid client certificate + signed by the CA is mandatory. + * **Client**: `SSL_VERIFY_PEER`. + * Verification depth is limited to 1 (only certificates signed directly by the CA are accepted). +6. Opens the socket: + * **Server**: `bind()` to `INADDR_ANY:` with `SO_REUSEADDR`, then `listen(BACKLOG)`. + * **Client**: resolves `--server` via `gethostbyname()` and `connect()`s. + +`read_string(ssl, buf, l)` reads one `\n`‑terminated line: + +* Uses `SSL_peek()` to locate the newline without consuming data. +* If the buffer fills up before a newline, the pending data is discarded (`SSL_read` of `l` bytes) +and `0` is returned. +* Returns the number of bytes read (the trailing `\n` is replaced by `\0`), `0` if nothing is +available or the line is incomplete, and `-1` on disconnect/error. `SSL_ERROR_WANT_READ/WRITE` are +treated as “nothing yet”. + + +## 6. Protocol + +Text, one message per line, `\n` terminator. + +### 6.1 Message forms + +| Form | Meaning | Reply | +|---|---|---| +| `name` | getter | `name=value` | +| `name=value` | setter | `OK`, `BADVAL`, `BADKEY` or `FAIL` | +| `help` | list commands | one `command: description` line per command | +| empty line / comment | ignored | (no reply) | + +The client side (`send_motor_command()`) distinguishes getters from setters by the presence of `=`, +and treats the four uppercase tokens above as setter results. In practice only `motnum`, +`motstatus`, `motspeed`, `motcurrent`, `speed`, `stop`, `nmotors`, `forbidden` are used by the +client. + +### 6.2 Result codes + +| Token | Enum | Meaning | +|---|---|---| +| `OK` | `RESULT_OK` | setter executed | +| `BADVAL` | `RESULT_BADVAL` | malformed or out‑of‑range argument | +| `BADKEY` | `RESULT_BADKEY` | unknown command | +| `FAIL` | `RESULT_FAIL` | command failed (e.g. motors not running) | +| *(no token)* | `RESULT_SILENCE` | internal: getter answer is sent as `key=value` or no answer at all | + + +## 7. Command reference + +All commands are defined once in `handlers_list.h` and expanded into the server’s dispatch table. +**The list must be kept in alphabetical order** — the server looks commands up with a binary search +(`search_handler()`). + +| Command | Access | Argument / answer | Description | +|---|---|---|---| +| `adc=N` | get | `N` → `value` | Read ADC channel `N` (0…7) | +| `forbidden` | get/set | `0`/`1` | Setter: `1` forbids dome operations (blocks motors), `0` permits. Getter: state of the `RELAY_BLOCK_MOTORS` relay (`1` = forbidden) | +| `inputs` | get | decimal mask | State of the 16 discrete inputs | +| `logprefix` | get/set | string ≤ 31 chars | Prefix of motor log files (`_NN.log`) | +| `motcurrent` | get | amps | Current of the active motor | +| `motnum` | get/set | `0`…`9` | Number of the motor used by status/current/speed getters | +| `motspeed` | get | rev/min | Speed of the active motor | +| `motstatus` | get | `0`…`3` | Status of the active motor (see below) | +| `nmotors` | get | count | Number of motors whose status is not `OFF` | +| `relayon` | get/set | `N` / mask | Setter: turn relay `N` on. Getter: full relay state mask | +| `relayoff` | get/set | `N` / mask | Setter: turn relay `N` off. Getter: full relay state mask | +| `relayset` | get/set | mask | Setter: set/reset all relays at once by bit mask. Getter: state mask | +| `speed` | get/set | rev/min | Setter: speed setpoint, sign selects direction, `0` stops. Getter: current setpoint | +| `startlog` | action | — | Open per‑motor log files | +| `stop` | action | — | Stop all motors | +| `stoplog` | action | — | Close log files | + +### Motor status values (`motors.h`) + +| Value | Name | Meaning | +|---|---|---| +| 0 | `MOT_OFF` | no answer / disabled | +| 1 | `MOT_SLEEP` | stopped but ready | +| 2 | `MOT_RUN` | rotating | +| 3 | `MOT_ERROR` | drive fault | + +`nmotors` counts all motors whose status differs from `MOT_OFF`. + +### Relay / input bit masks (`io.h`) + +Inputs (16 bits): + +| Bit | Macro | Meaning | +|---|---|---| +| 0 | `INP_FLOOR1` | man on floor 1 | +| 1 | `INP_FLOOR2` | man on floor 2 | +| 2 | `INP_DOOR_OPENED` | door is open | +| 3 | `INP_OPEN_DOOR` | “open door” request | +| 4 | `INP_TEL_AT_NEST` | telescope is at the “nest” | + +Relays (16 bits, only some are populated): + +| Number | Macro | Meaning | +|---|---|---| +| 1 | `RELAY_OPEN_DOOR` | open the door | +| 2 | `RELAY_BLOCK_DOOR` | block the door | +| 3 | `RELAY_LIGHT` | turn on light | +| 4 | `RELAY_POWER` | turn on power socket | +| 5 | `RELAY_BLOCK_MOTORS` | block (inhibit) the motors | +| 10 | `RELAY_DOOR_UNLOCKED` | door is unlocked (turn on light) | + + +## 8. Server + +### 8.1 Startup + +`main()` → `sl_init()` → `parse_args()` → `start_daemon()` → `open_socket()` → `serverproc()`. + +`start_daemon()` (in `daemon.c`) validates the port (1024…65535) and that certificate/key files can +be opened; optionally opens the log file; installs signal handlers; checks for an already‑running +instance via the PID file; then daemonizes and runs the supervision loop: + +* The **master** forks a child, waits for it, logs the child’s lifetime, and respawns after 5 s. +Logging is throttled if children die faster than 30 s. +* The **child** sets `PR_SET_PDEATHSIG = SIGTERM` (it is killed when the master dies), sets +`isrunning = TRUE` and runs the main loop. + +Signals: `SIGTERM`, `SIGINT`, `SIGQUIT` set `isrunning = FALSE` and exit (after removing the PID +file); `SIGTSTP` and `SIGHUP` are ignored. + +### 8.2 Main loop (`serverproc()`) + +1. `motors_process()` — advance the motor state machine (one motor per call plus queued commands). +2. `io_process()` — read inputs/relays/ADC from the I/O board and apply the safety logic. +3. `poll(..., 1 ms)`. +4. On the listening socket: `accept4(..., SOCK_NONBLOCK)`, then `SSL_new()` + timeout‑protected +`SSL_accept()` (bounded by `--timeout`). On failure the client is sent an error and disconnected. +Up to `BACKLOG` (10) clients are served. +5. For each readable client: `handle_connection()` — read one line, parse `key[=value]`, dispatch +to the handler, write the reply. On disconnect the last poll entry is moved into the freed slot. + +On exit the server stops all motors and closes the Modbus connection. + +### 8.3 Motor control (`motors.c`) + +* One Modbus RTU context for the whole process, shared with `io.c` via `io_set_ctx()`. +* **Shared‑memory‑like state** in the server: `motstates[10]`, `n_working_motors`, speed/current +setpoints, and a bit‑flag word (`stop`, `change_speed`, `change_current`), all protected by +`statemutex`. +* **Setter path** (`motors_set_speedsetpoint()`, `motors_set_curntsetpoint()`, `motors_stop()`) +only sets flags; the actual bus traffic happens in `motors_process_m()`: + * Commands are sent to the **broadcast** slave address 0 (`modbus_set_slave(ctx, 0)`) without + checking the return code (what's impossible in broadcast mode). + * `stop` → `CMD_STOP` on `REG_CMD`, setpoint zeroed. + * Speed change: if `|speed| < SPEED_TOLERANCE` → `CMD_STOP`; otherwise write + `CMD_FORWARD`/`CMD_REVERSE` to `REG_CMD` and `REVMIN2FREQ(|speed|)` to `REG_FREQ_SET`. + * Setting a speed requires `n_working_motors ≥ MIN_WORKING_MOTORS` (1); otherwise `RESULT_FAIL`. + * `|speed| > MAX_SPEED` (655 rev/min) → `RESULT_BADVAL`. + * Changing the current setpoint is currently a stub (`change_current` is cleared without bus + traffic). +* **Polling path**: each call selects one slave `MOTOR_ID(curN) = curN+1` and reads +`REG_STATUS_MAIN`, `REG_STATUS_EXT`, `REG_OUTPUT_FREQ`, `REG_OUTPUT_CURRENT`; converts to rev/min +and amperes; maps statuses: + * `STATUS_CW`, `STATUS_CCW` → `MOT_RUN` + * `STATUS_STOP` → `MOT_SLEEP` + * anything else → `MOT_ERROR` + * `STATUS_READY_MASK` absent in the extended status → forced `MOT_ERROR`; an attempt is made to + reset the fault with `CMD_RESET_FAULT`. + * After `MAX_ERRORS` (5) consecutive bus errors the motor is marked `MOT_OFF`. +* `count_motors()` recomputes `n_working_motors` after each full sweep. + +### 8.4 Motor logging + +`start_log()` opens `/_NN.log` (append mode) for each motor (default prefix `motor`, +default directory `/tmp`). Each poll writes `timespeedcurrent`, but only while the motor +is `MOT_RUN`. `stop_log()` closes them. Prefixes are validated (`set_logfile_prefix()` rejects `/`, +`%`, control characters and non‑ASCII, and limits length to 31). + +### 8.5 Emulation mode + +With `--emulation` the server skips the serial port and uses `motors_open_e()` / +`motors_process_e()`: + +* All motors start in `MOT_SLEEP`; `n_working_motors = 10`. +* Speed ramps linearly toward the setpoint with `EMUL_ACCEL` (10000 min⁻²); current equals the +current setpoint while accelerating and 0.6 × setpoint when at speed. + +### 8.6 I/O board (`io.c`) + +* The board is addressed by `G.io_ID`; if it is < 1 or the Modbus context is missing, +`io_process()` does nothing. +* Each pass reads 16 inputs, 16 relay outputs and 8 ADC registers, updates the cached state under a +mutex, then runs the interlock logic. +* **Inputs → relays** (`chk_inputs()`): + * Any of `FLOOR1`, `FLOOR2`, `DOOR_OPENED` → door unblocked and unlocked, motors blocked, light on. + * `TEL_AT_NEST` → door unblocked/unlocked, and if `OPEN_DOOR` is asserted the door is opened and + the motors blocked. + * Otherwise the door is blocked and locked; if somebody is on the nest without the telescope, the + open‑door request is honoured. +* **Relays → relays** (`chk_relays()`): motors blocked ⇒ light on, otherwise off. Pending user +requests (`OnFlags`/`OffFlags`) are applied and cleared. +* Public API: `io_read_inputs()`, `io_read_relays()`, `io_read_adc()`, `io_relay_on()`, +`io_relay_off()`, `io_set_relays()`. +* At server start, `io_set_relays(0)` turns everything off and then `RELAY_BLOCK_MOTORS` is +switched on (inhibit by default). + + +## 9. Client + +### 9.1 Connection setup + +`clientproc()` / `terminal()` create an SSL connection (`openConn()`), make the socket +non‑blocking, attach the shared memory block (`get_shm_block(&sdat, ClientSide)` — may fail if the +SHM block is not created by the higher‑level system), the command queues (`mcmd`, `ocmd`, `ucmd`), +and publish `DomeSEW_N = MOTORS_AMOUNT`. + +### 9.2 Background (daemon) mode — `clientproc()` + +Every ~100 ms: + +1. `process_system(ssl)`: + * **SHM watchdog**: if `M_time` lags more than `T_sync_lost` behind wall time, or + `check_shm_block()` fails, the client tolerates 9 failures and exits on the 10th. + * **Model mode**: if the SHM reports `UseModel == FullModel`, the client logs a warning once, sends + an emergency stop, and suspends control until the model mode ends. + * **Server liveness** (unless `--emulation`): `kill(ServPID, 0)`; two consecutive failures + terminate the client. + * **Motor polling**: round‑robin over 10 motors with 4 commands each — `motnum=N`, `motstatus`, + `motspeed`, `motcurrent`. The active‑motor data feed the `SEWD` variables (`statusSEWD`, + `vel_SEWD`, `currentSEWD`) for `indexSEWD`. + * After the full sweep, the **common state** is computed: status = maximum over motors, + speed/current = mean over `MOT_RUN` motors. Transitions between “all off” and “any running” + generate `MesgFault`/`MesgInfor` messages to the GUI; an unresponsive motor in error state + generates `MesgWarn`. + * `chk_dome_speed()`: translates the SHM `Dome_Speed` state (`D_Off`, `D_Lplus/Lminus`, + `D_Mplus/Mminus`, `D_Hplus/Hminus`) into ±`LSpeed`/`MSpeed`/`HSpeed` (±71/350/610 rev/min). The + command is (re)sent every `speedchk_interval` seconds until the measured speed is within + `SPEED_TOLERANCE` of the setpoint. `D_Locked` forces a stop. +2. Drain and log any unsolicited data from the server. + +On exit: `stop_all()` sends `stop` up to 5 times (100 ms apart); if all attempts fail, an error is +logged; otherwise `Dome_Speed` is reset. + +### 9.3 Terminal mode — `terminal()` + +Enabled by `-T`. Before daemonizing (so it works without detaching), the client offers a raw line +pipe: + +* `> ` prompt; each line read from stdin is written to the SSL connection. +* Every reply line is printed as `< reply`. +* `Ctrl‑D` or a write error ends the session. + +The shared memory block and automatic motor polling are **not** used in this mode. + + +## 10. ESQ‑770 frequency converter interface (`esq770.h`) + +| Register | Address | Access | Contents | +|---|---|---|---| +| `REG_CMD` | 0x2000 | RW | Command | +| `REG_FREQ_SET` | 0x3000 | RW | Frequency setpoint (0.01 Hz) | +| `REG_TORQUE_LIMIT` | 0x3006 | RW | Torque limit | +| `REG_BRAKE_TORQUE_LIMIT` | 0x3007 | RW | Brake torque limit | +| `REG_STATUS_MAIN` | 0x6000 | R | Main status | +| `REG_STATUS_EXT` | 0x6001 | R | Extended status | +| `REG_OUTPUT_FREQ` | 0xA201 | R | Output frequency × 100 | +| `REG_OUTPUT_CURRENT` | 0xA204 | R | Output current × 10 | +| `REG_MOTOR_SPEED` | 0xA205 | R | Speed (depends on settings) | + +Commands (`REG_CMD`): `CMD_FORWARD` = 1, `CMD_REVERSE` = 2, `CMD_STOP` = 5, `CMD_FAST_STOP` = 6, +`CMD_RESET_FAULT` = 7. + +Main status (`REG_STATUS_MAIN`): `STATUS_CW` = 1, `STATUS_CCW` = 2, `STATUS_STOP` = 3, `STATUS_ERR` += 4, `STATUS_LOW_V` = 5. Extended status bit `STATUS_READY_MASK` = 0x01. + +Conversions (4‑pole motor, 100× scale): + +```c +REVMIN2FREQ(r) = (uint16_t)(100. * r / 15.) /* rev/min → register */ +FREQ2REVMIN(f) = (f * 15.) / 100. /* register → rev/min */ +current[A] = register / CURRENT_SCALE /* CURRENT_SCALE = 10 */ +``` + +Because the frequency register is 16‑bit, the maximum representable speed is 655.35 rev/min +(`MAX_SPEED = 655`). + + +## 11. Command line options + +Defined in `cmdlnopts.c`; configuration files (`-C`) use the same names and take precedence over +the command line. `-v`, `-v2`, `-v3` raise the log level to MSG, DBG and ANY respectively (default +WARN). + +### Common + +| Option | Argument | Default | Description | +|---|---|---|---| +| `-h`, `--help` | — | — | show help | +| `-l`, `--logfile` | file | — | write logs to this file | +| `-P`, `--pidfile` | file | `/tmp/domeserver.pid` / `/tmp/domeclt.pid` | PID file | +| `-c`, `--certificate` | file | `server_cert.pem` / `client_cert.pem` | SSL certificate | +| `-k`, `--key` | file | `server_key.pem` / `client_key.pem` | SSL private key | +| `-p`, `--port` | string | `4444` | TCP port | +| `-v`, `--verbose` | int (optional) | 0 | verbosity level | +| `-a`, `--ca` | file | `ca_cert.pem` | CA certificate | +| `-t`, `--timeout` | double | 1 s | network timeout (accept, command reply) | +| `-C`, `--conffile` | file | — | configuration file | + +The certificate and private key files must have absolute path as are opened after daemonisation +and `chroot('/')`. + +### Server only + +| Option | Argument | Default | Description | +|---|---|---|---| +| `-e`, `--emulation` | — | off | emulation mode (no hardware) | +| `-d`, `--serialdev` | file | — | RS‑485 device path (absolute) | +| `-s`, `--serialspeed` | int | — | serial port speed | +| `-D`, `--mldir` | dir | `/tmp` | directory for motor log files (absolute) | +| `-i`, `--ioid` | int | −1 | Modbus ID of the I/O board (disabled if < 1) | + +### Client only + +| Option | Argument | Default | Description | +|---|---|---|---| +| `-M`, `--mottmout` | double | 10 s | interval for re‑sending the speed command until it is reached | +| `-s`, `--server` | host | — (required) | server name or IP | +| `-L`, `--lostsync` | double | 5 s | shared‑memory “lost synchronization” timeout | +| `-e`, `--emulation` | — | off | run even if the SHM reports emulation mode | +| `-T`, `--terminal` | — | off | interactive terminal mode | + +Note that `-s` has different meanings in the server (`serialspeed`) and client (`server`) builds — +the option tables are compiled conditionally. + + +## 12. Tuning constants + +`motors.h` / `esq770.h`: + +| Constant | Value | Meaning | +|---|---|---| +| `MOTORS_AMOUNT` | 10 | number of drives | +| `START_ID` / `MOTOR_ID(n)` | 1 / `n+1` | Modbus slave addresses | +| `MIN_WORKING_MOTORS` | 1 | minimum motors to allow a speed setpoint | +| `MAX_ERRORS` | 5 | consecutive bus errors before a motor is `MOT_OFF` | +| `MAX_SPEED` | 655 | rev/min | +| `SPEED_TOLERANCE` | 0.01 | rev/min | +| `MAX_CURRENT` / `DEFAULT_CURRENT` | 15 / 10 | A | +| `LSpeed` / `MSpeed` / `HSpeed` | 71 / 350 / 610 | rev/min presets | +| `MODBUS_RESPONCE_TIMEOUT` | 100000 | µs | +| `EMUL_ACCEL` | 10000 | min⁻² | +| `BACKLOG` | 10 | max simultaneous SSL clients | +| `IOBUF_LEN` / `SL_VAL_LEN` / `SL_KEY_LEN` | 256 / (external) | protocol buffer sizes | + + +## 13. Client ↔ shared memory integration + +The client depends on the `bta_shdata.[ch]` module that provides: + +* `sdat` — the shared `struct` (mode, `atflag`, `Dome_Speed`, `D_Locked`, `DomeSEW_N`, `indexSEWD`, + `statusSEWD`, `vel_SEWD`, `currentSEWD`, `speedSEWD`, `M_time`, `UseModel`, `ServPID`, …); +* command queues `mcmd`, `ocmd`, `ucmd` (motor / observer / user commands); +* helpers `get_shm_block()`, `check_shm_block()`, `get_cmd_queue()`; +* `SendMessage()` with `MesgWarn`, `MesgFault`, `MesgInfor` message classes for the GUI. + +The client writes the shared block (`mode |= 0200`, i.e. write access, `atflag = 0`) and publishes +`DomeSEW_N`. If the block cannot be attached, the client logs the error and aborts. + + +## 14. Notes and caveats + +* **Command order is significant.** `handlers_list.h` must remain alphabetically sorted; the server +uses binary search over the expanded table. +* **The `EBUG` macro** is produced by the Makefile’s `-DEBUG` flag (GCC parses it as `-D EBUG`). +Debug builds therefore enable extra `printf` traces in `io.c`, `motors.c`, etc., and disable +daemonization (`#ifndef EBUG` around `sl_daemonize()`), which is handy for running under a +debugger. +* **Setters vs. getters** are distinguished purely by the presence of `=`. `startlog`, `stop`, +`stoplog` are actions; any `=value` they receive is ignored. +* The relay getters of `relayon`, `relayoff`, `relayset` are identical (they all return the full +relay mask); the setter forms differ. +* The server **broadcasts** motion commands (slave 0) and therefore does not verify their +execution; confirmation happens only indirectly through the client’s periodic speed polling and +re‑sending. +* Motor speed commands are accepted only when at least `MIN_WORKING_MOTORS` drives are alive; +otherwise `RESULT_FAIL` is returned. +* `read_string()` silently drops a line that does not fit into the buffer; keep `IOBUF_LEN` in mind +for custom clients. +* The I/O board’s safety logic runs before the relay state is refreshed, so user relay requests +issued in the same iteration may be overwritten by the interlock rules on the next pass. + + +## 15. License + +This repository is provided under the GNU General Public License v3 or later. Full text of the +GPLv3 is available at https://www.gnu.org/licenses/gpl-3.0.html. diff --git a/BTA_dome_modbus/bta_shdata.c b/BTA_dome_modbus/bta_shdata.c index fb30a35..f37f68c 100644 --- a/BTA_dome_modbus/bta_shdata.c +++ b/BTA_dome_modbus/bta_shdata.c @@ -216,16 +216,18 @@ void set_cmd_src(uint32_t ip, int 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(size > 100){ + size = 100; + buf[99] = 0; + } if(cmd_code > 0) - mbuf.mtype = cmd_code; + mbuf.mtype = (int32_t)cmd_code; else return; if(ucmd.id == snd_id) mbuf.acckey = ucmd.acckey; @@ -242,6 +244,7 @@ void send_cmd(int cmd_code, char *buf, int size) { mbuf.mtext[0] = 0; size = 1; } + // in case of error the message would be lost! msgsnd(snd_id, (struct msgbuf *)&mbuf, size+12, IPC_NOWAIT); } @@ -317,21 +320,22 @@ void send_cmd_i3d1(int cmd_code, int32_t arg1, int32_t arg2, int32_t arg3, doubl 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; + struct crypt_data data[1] = {0}; 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]; + // normally we must check what crypt_r returns! + crypt_r(passwd, salt, data); + cod.c[0] = data->output[2]; + key.c[0] = data->output[3]; + cod.c[1] = data->output[4]; + key.c[1] = data->output[5]; + cod.c[2] = data->output[6]; + key.c[2] = data->output[7]; + cod.c[3] = data->output[8]; + key.c[3] = data->output[9]; *keylev = key.ui; *codlev = cod.ui; } diff --git a/BTA_dome_modbus/client.c b/BTA_dome_modbus/client.c index 81a204c..7df10a3 100644 --- a/BTA_dome_modbus/client.c +++ b/BTA_dome_modbus/client.c @@ -55,12 +55,12 @@ typedef struct{ arg_type_t type; } value_t; -// setter: when setspeed command sent successfully -static double set_speed = 0.; // common state - by last motor polled static motor_state_t CommonState = {0}; // state of each motor static motor_state_t MotorState[MOTORS_AMOUNT] = {0}; +// new speed setter +static double set_speed = 0.; static int SSL_nbread(SSL *ssl, char *buf, int bufsz){ struct pollfd fds = {0}; @@ -72,7 +72,8 @@ static int SSL_nbread(SSL *ssl, char *buf, int bufsz){ WARNX("poll()"); return 0; } - if(fds.revents == POLLIN){ + if(fds.revents & POLLHUP) return -1; // closed + if(fds.revents & POLLIN){ // DBG("Got info in fd #%d", fd); int l = read_string(ssl, buf, bufsz); // DBG("read %d bytes", l); @@ -101,9 +102,10 @@ static sl_sock_hresult_e send_motor_command(SSL *ssl, const char *cmd, value_t * l = snprintf(buf, IOBUF_LEN-1, "%s=%g\n", cmd, setter->d); } }else l = snprintf(buf, IOBUF_LEN-1, "%s\n", cmd); + if(l < 0 || l >= IOBUF_LEN) return RESULT_FAIL; // snprintf error or overflow buf[l] = 0; //DBG("Send to server: %s", buf); - SSL_write(ssl, buf, l); + if(!write_string(ssl, buf)) return RESULT_FAIL; double t0 = sl_dtime(); while(sl_dtime() - t0 < G.acc_timeout){ l = SSL_nbread(ssl, buf, IOBUF_LEN-1); @@ -170,6 +172,25 @@ static void stop_all(SSL *ssl){ ++ntries; usleep(100000); } + if(ntries >= 5){ + LOGERR("Can't run emergency motor's stopping!"); + }else{ + Dome_Speed = D_Off; + set_speed = 0.; + } +} + +static int chkm(SSL *ssl, int motno){ + value_t Ival = {.type = ARG_TYPE_INT, .i = motno}; + value_t Dval = {.type = ARG_TYPE_DOUBLE}; + if(RESULT_OK != send_motor_command(ssl, cmd_motnum, &Ival, NULL)) return -1; + if(RESULT_OK != send_motor_command(ssl, cmd_motstatus, NULL, &Ival)) return -1; + MotorState[motno].status = (int) Ival.i; + if(RESULT_OK != send_motor_command(ssl, cmd_motspeed, NULL, &Dval)) return 0; + MotorState[motno].speed = Dval.d; + if(RESULT_OK != send_motor_command(ssl, cmd_motcurrent, NULL, &Dval)) return 0; + MotorState[motno].current = Dval.d; + return 1; } /** @@ -181,17 +202,13 @@ static void stop_all(SSL *ssl){ static int check_motor(SSL *ssl, int motno){ char msg[128]; if(!ssl || motno < 0 || motno >= MOTORS_AMOUNT) return FALSE; - value_t Ival = {.type = ARG_TYPE_INT, .i = motno}; - value_t Dval = {.type = ARG_TYPE_DOUBLE}; - if(RESULT_OK != send_motor_command(ssl, cmd_motnum, &Ival, NULL)) return FALSE; - if(RESULT_OK != send_motor_command(ssl, cmd_motstatus, NULL, &Ival)) return FALSE; - MotorState[motno].status = (int) Ival.i; - if(RESULT_OK != send_motor_command(ssl, cmd_motspeed, NULL, &Dval)) return FALSE; - MotorState[motno].speed = Dval.d; - if(RESULT_OK != send_motor_command(ssl, cmd_motcurrent, NULL, &Dval)) return FALSE; - MotorState[motno].current = Dval.d; + int ret = chkm(ssl, motno); + if(ret < 0){ + ret = FALSE; + MotorState[motno].status = MOT_ERROR; // no answer -> error + } // now set common state as mean of all - if(motno != MOTORS_AMOUNT - 1) return TRUE; + if(motno != MOTORS_AMOUNT - 1) return ret; int status = 0, N = 0; // mean status is largest double speed = 0., current = 0.; for(int i = 0; i < MOTORS_AMOUNT; ++i){ @@ -199,12 +216,12 @@ static int check_motor(SSL *ssl, int motno){ if(s == MOT_OFF) continue; if(s == MOT_ERROR){ *msg = MesgWarn; - printf(msg+1, "Dome: Error in motor %d!\n", i+1); + sprintf(msg+1, "Dome: Error in motor %d!\n", i+1); SendMessage(msg); - MotorState[i].status = MOT_OFF; + s = MotorState[i].status = MOT_OFF; } if(status < s) status = s; - if(status == MOT_RUN){ + if(s == MOT_RUN){ speed += MotorState[i].speed; current += MotorState[i].current; ++N; @@ -227,7 +244,7 @@ static int check_motor(SSL *ssl, int motno){ CommonState.status = status; CommonState.speed = speed; CommonState.current = current; - return TRUE; + return ret; } // check for speed change and send given command to server @@ -242,8 +259,8 @@ static void chk_dome_speed(SSL *ssl){ if(new_state == old_state){ if(sl_dtime() - tlast < G.speedchk_interval) return; DBG("Time - tlast = %g", sl_dtime() - tlast); - if(CommonState.speed == set_speed){ - tlast = sl_dtime(); + tlast = sl_dtime(); + if(fabs(CommonState.speed - fabs(set_speed)) < SPEED_TOLERANCE){ return; } DBG("Speed set command still not sent"); @@ -275,7 +292,8 @@ static void chk_dome_speed(SSL *ssl){ value_t Dval = {.type = ARG_TYPE_DOUBLE, .d = new_speed}; if(RESULT_OK == send_motor_command(ssl, cmd_speed, &Dval, NULL)){ DBG("New speed %g sent", new_speed); - if(RESULT_OK == send_motor_command(ssl, cmd_speed, NULL, &Dval) && fabs(Dval.d - new_speed) <= FLT_EPSILON){ + // check that server receives right new speed + if(RESULT_OK == send_motor_command(ssl, cmd_speed, NULL, &Dval) && fabs(Dval.d - new_speed) <= SPEED_TOLERANCE){ DBG("Got answer with speed set: %g", Dval.d); old_state = new_state; // all OK, command in work set_speed = new_speed; @@ -287,27 +305,22 @@ static void chk_dome_speed(SSL *ssl){ // SHM parser; return FALSE if SHM is in erroreous state static int process_system(SSL *ssl){ - static double t0 = 0., last_mtime = 0.; static int curMotNo = 0; // current motor number (we'll scan all 10 motors by one) double curtime = sl_dtime(); - if(t0 < 1.){ // first run - t0 = curtime; - last_mtime = M_time; - return TRUE; - } // check time sync static int brokenshmctr = 0; - if(M_time - last_mtime > curtime - t0 + G.T_sync_lost || !check_shm_block(&sdat)){ // broken SHM + if(curtime - M_time > G.T_sync_lost || !check_shm_block(&sdat)){ // broken SHM if(brokenshmctr == 0){ LOGERR("Stalled or broken SHM block"); } - WARNX("Stalled or broken SHM block; %g -- %g", M_time - last_mtime + G.T_sync_lost, curtime - t0); + WARNX("Stalled or broken SHM block; (M_time - curtime) = %g", M_time - curtime); if(++brokenshmctr < 10) return TRUE; return FALSE; }else brokenshmctr = 0; +#if 0 // set/reset PEP_K_On by information from server! value_t Ival = {.type = ARG_TYPE_INT, .i = 0}; - if(RESULT_OK != send_motor_command(ssl, cmd_forbidden, &Ival, NULL)) return FALSE; + if(RESULT_OK != send_motor_command(ssl, cmd_forbidden, NULL, &Ival)) return FALSE; #ifdef EBUG //if(PEP_K_On != Ival.i) DBG("Set PEP_K_On to %d", !Ival.i); #endif @@ -315,6 +328,7 @@ static int process_system(SSL *ssl){ if(Ival.i) PEP_K_On = 0; else PEP_K_On = 1; */ +#endif static int modelused = FALSE; if(!G.emulmode){ if(UseModel == FullModel){ // model @@ -326,6 +340,8 @@ static int process_system(SSL *ssl){ return TRUE; }else modelused = FALSE; static int serverisdead = FALSE; + // !!! carefully: when running not by root, kill can return -1 wiwth EPERM !!! + // (in this case this is normal: only root can run client) if(ServPID <= 0 || kill(ServPID, 0) < 0){ // dead server WARNX("Main server is dead"); if(!serverisdead){ @@ -344,8 +360,8 @@ static int process_system(SSL *ssl){ vel_SEWD = st->speed; currentSEWD = st->current; } - if(++curMotNo >= MOTORS_AMOUNT) curMotNo = 0; } + if(++curMotNo >= MOTORS_AMOUNT) curMotNo = 0; chk_dome_speed(ssl); return TRUE; } @@ -370,7 +386,7 @@ static SSL *openConn(SSL_CTX *ctx, int fd){ SSL *ssl = SSL_new(ctx); SSL_set_fd(ssl, fd); int c = SSL_connect(ssl); - if(c < 0){ + if(c != 1){ LOGERR("SSL_connect()"); ERRX("SSL_connect() error: %d", SSL_get_error(ssl, c)); } @@ -394,6 +410,9 @@ void clientproc(SSL_CTX *ctx, int fd){ LOGERR("Can't get SHM block"); ERRX("Can't get SHM block"); } + get_cmd_queue(&mcmd, ClientSide); + get_cmd_queue(&ocmd, ClientSide); + get_cmd_queue(&ucmd, ClientSide); // set amount of working motors DomeSEW_N = MOTORS_AMOUNT; DBG("set DomeSEW_N = %d", DomeSEW_N); @@ -401,21 +420,19 @@ void clientproc(SSL_CTX *ctx, int fd){ if(!process_system(ssl)){ LOGERR("Motors error"); WARNX("ERROR!"); - stop_all(ssl); - sleep(5); break; } // clear receiving buffer (TODO: parse it?) int bytes = SSL_nbread(ssl, buf, sizeof(buf)-1); if(bytes > 0){ buf[bytes] = 0; - fprintf(stderr, "Received: \"%s\"\n", buf); + LOGDBG("Received: \"%s\"", buf); }else if(bytes < 0){ - LOGWARN("Server disconnected or other error"); - ERRX("Disconnected"); + LOGERR("Server disconnected or other error"); } usleep(100000); } + if(ssl) stop_all(ssl); DBG("Exit; isrunning=%d", isrunning); SSL_free(ssl); } @@ -436,9 +453,10 @@ void terminal(SSL_CTX *ctx, int fd){ } if(sl_canread(0)){ ssize_t L = getline(&lptr, &N, stdin); + if(L < 0) break; // ctrl + D if(L > (ssize_t)(sizeof(buf)-1)) WARNX("String too long!"); else if(L > 0){ - SSL_write(ssl, lptr, L); + if(!write_string(ssl, lptr)) break; // error } } int bytes = 0; @@ -454,5 +472,6 @@ void terminal(SSL_CTX *ctx, int fd){ printed = FALSE; } } + FREE(lptr); SSL_free(ssl); } diff --git a/BTA_dome_modbus/cmdlnopts.c b/BTA_dome_modbus/cmdlnopts.c index 9b85709..70e13bc 100644 --- a/BTA_dome_modbus/cmdlnopts.c +++ b/BTA_dome_modbus/cmdlnopts.c @@ -98,9 +98,8 @@ static sl_option_t cmdlnopts[] = { */ 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"); + char helpstring[1024]; + snprintf(helpstring, 1023, "Usage: %%s [args]\n\n\tWhere args are:\n"); // format of help: "Usage: progname [args]\n" sl_helpstring(helpstring); // parse arguments diff --git a/BTA_dome_modbus/daemon.c b/BTA_dome_modbus/daemon.c index 0bb5dbc..7b4fa69 100644 --- a/BTA_dome_modbus/daemon.c +++ b/BTA_dome_modbus/daemon.c @@ -83,7 +83,7 @@ int start_daemon(){ OPENLOG(G.logfile, lvl, 1); } signal(SIGTERM, signals); // kill (-15) - quit - //signal(SIGHUP, SIG_IGN); // hup - ignore (used in sl_daemonize()) + signal(SIGPIPE, SIG_IGN); // don't fall on SSL_write() error signal(SIGINT, signals); // ctrl+C - quit signal(SIGQUIT, signals); // ctrl+\ - quit signal(SIGTSTP, SIG_IGN); // ignore ctrl+Z @@ -95,6 +95,12 @@ int start_daemon(){ tstart = sl_dtime(); while(1){ childpid = fork(); + if(childpid == -1){ + WARN("fork()"); + LOGERR("daemon(): fork() error"); + sleep(5); + continue; + } if(childpid){ // master if(savelogs) LOGMSG("Created child with pid %d", childpid); wait(NULL); diff --git a/BTA_dome_modbus/esq770.h b/BTA_dome_modbus/esq770.h index 0f125e6..f8f090e 100644 --- a/BTA_dome_modbus/esq770.h +++ b/BTA_dome_modbus/esq770.h @@ -35,14 +35,14 @@ #define REG_OUTPUT_CURRENT 0xA204 // 41476 (current * 10) #define REG_MOTOR_SPEED 0xA205 // 41477 (speed, depends on settings) -// REG_CMD bits +// REG_CMD codes #define CMD_FORWARD 1 #define CMD_REVERSE 2 #define CMD_STOP 5 #define CMD_FAST_STOP 6 #define CMD_RESET_FAULT 7 -// REG_STATUS_MAIN bits +// REG_STATUS_MAIN codes #define STATUS_CW 1 #define STATUS_CCW 2 #define STATUS_STOP 3 @@ -54,7 +54,7 @@ // convert rev/min to frequency register value and back // 100 * revmin / 60 * 4; 100 - scale, 60 - min2sec, 4 - pole amount -#define REVMIN2FREQ(r) (uint16_t)((100. * (r)) / 15.) +#define REVMIN2FREQ(r) (uint16_t)((100. * (fabs(r))) / 15.) #define FREQ2REVMIN(f) ((((double)(f)) * 15.) / 100.) #define CURRENT_SCALE 10. diff --git a/BTA_dome_modbus/handlers_list.h b/BTA_dome_modbus/handlers_list.h index f3ce6d8..09c019a 100644 --- a/BTA_dome_modbus/handlers_list.h +++ b/BTA_dome_modbus/handlers_list.h @@ -25,11 +25,11 @@ // Handlers in this list MUST be in sortered order (by name)!!! #define HANDLERS_LIST() \ -NEW_HANDLER(adc, "read nth ADC channel") \ +NEW_HANDLER(adc, "read nth ADC channel (adc=n)") \ NEW_HANDLER(forbidden, "forbid (1) or permit (0) dome operations") \ NEW_HANDLER(inputs, "read PLC discrete inputs") \ NEW_HANDLER(logprefix, "prefix of log file for nth motor (prefix_%d.log), max 31 chars") \ -NEW_HANDLER(motcurrent, "maximal motor current") \ +NEW_HANDLER(motcurrent, "maximal motor current (only stub, do nothing)") \ NEW_HANDLER(motnum, "active motor number for status requests") \ NEW_HANDLER(motspeed, "motor speed") \ NEW_HANDLER(motstatus, "motor status") \ diff --git a/BTA_dome_modbus/io.c b/BTA_dome_modbus/io.c index 524f4ef..7a8b8ca 100644 --- a/BTA_dome_modbus/io.c +++ b/BTA_dome_modbus/io.c @@ -19,6 +19,8 @@ #include #include #include +#include +#include #include #include @@ -74,10 +76,10 @@ static int change_relay(int N, int state){ return ret; } -//#define RON(relayNo) do{if((RelaysState & (1<. */ +#include #include #include +#include #include #include @@ -50,6 +52,9 @@ static motor_state_t motstates[MOTORS_AMOUNT] = {0}; // amount of working motors static int n_working_motors = 0; +// mutex for flags, currentSet, speedSet, n_working_motors and motstates +static pthread_mutex_t statemutex = PTHREAD_MUTEX_INITIALIZER; + // set points static double currentSet = DEFAULT_CURRENT, speedSet = 0.; // flags for main routine @@ -110,15 +115,19 @@ static int motors_open_m(const char *path, int speed){ return TRUE; } static int motors_open_e(const char _U_ *path, int _U_ speed){ // stub for emulation mode + pthread_mutex_lock(&statemutex); for(int i = 0; i < MOTORS_AMOUNT; ++i) motstates[i].status = MOT_SLEEP; n_working_motors = MOTORS_AMOUNT; + pthread_mutex_unlock(&statemutex); return TRUE; } // stop all void motors_stop(){ + pthread_mutex_lock(&statemutex); flags.stop = 1; + pthread_mutex_unlock(&statemutex); } // current setpoint getter @@ -129,8 +138,10 @@ double motors_get_curntsetpoint(){ int motors_set_curntsetpoint(double val){ if(val < 0. || val > MAX_CURRENT) return FALSE; DBG("Change max current to %g", val); + pthread_mutex_lock(&statemutex); currentSet = val; flags.change_current = 1; + pthread_mutex_unlock(&statemutex); return TRUE; } @@ -145,13 +156,16 @@ sl_sock_hresult_e motors_set_speedsetpoint(double val){ DBG("Speed to large"); return RESULT_BADVAL; } + pthread_mutex_lock(&statemutex); if(n_working_motors < MIN_WORKING_MOTORS){ DBG("n_working_motors = %d", n_working_motors); + pthread_mutex_unlock(&statemutex); return RESULT_FAIL; } DBG("Change speed setpoint to %g", val); speedSet = val; flags.change_speed = 1; + pthread_mutex_unlock(&statemutex); return RESULT_OK; } @@ -167,23 +181,35 @@ int motors_set_activenum(int N){ // get current value for active motor int motors_get_actcurrent(double *val){ - if(val) *val = motstates[motindex].current; + if(val){ + pthread_mutex_lock(&statemutex); + *val = motstates[motindex].current; + pthread_mutex_unlock(&statemutex); + } return TRUE; } // get speed for active motor int motors_get_actspeed(double *val){ - if(val) *val = motstates[motindex].speed; + if(val){ + pthread_mutex_lock(&statemutex); + *val = motstates[motindex].speed; + pthread_mutex_unlock(&statemutex); + } return TRUE; } // get status for active motor int motors_get_actstatus(int *val){ - if(val) *val = motstates[motindex].status; + if(val){ + pthread_mutex_lock(&statemutex); + *val = motstates[motindex].status; + pthread_mutex_unlock(&statemutex); + } return TRUE; } -// count amount of actual motors +// count amount of actual motors; called under locked statemutex static void count_motors(){ n_working_motors = 0; for(int i = 0; i < MOTORS_AMOUNT; ++i){ @@ -191,11 +217,13 @@ static void count_motors(){ } } +// should be run under locked statemutex static void log_data(int motno){ - if(!logF[motno] || motstates[motno].status != MOT_RUN) return; pthread_mutex_lock(&logmutex); + if(!logF[motno] || motstates[motno].status != MOT_RUN) goto retn; fprintf(logF[motno], "%.3f\t%.2f\t%.2f\n", sl_dtime() - Tstart, motstates[motno].speed, motstates[motno].current); +retn: pthread_mutex_unlock(&logmutex); } @@ -207,6 +235,7 @@ static void motors_process_m(){ LOGERR("Modbus not inited or other error! Error counter = %d", errctr); ERRX("Modbus not inited or other error!"); } + pthread_mutex_lock(&statemutex); if(flags.all){ if(-1 == modbus_set_slave(modbus_ctx, 0)){ WARN("Can't set broadcast slave"); @@ -215,7 +244,7 @@ static void motors_process_m(){ if(flags.stop){ DBG("User asks to stop"); speedSet = 0.; - // send command stop (don't check return code for broadcast messages! + // send command stop (don't check return code for broadcast messages!) modbus_write_register(modbus_ctx, REG_CMD, CMD_STOP); flags.stop = 0; } @@ -226,11 +255,14 @@ static void motors_process_m(){ } if(flags.change_speed){ DBG("User asks to change speed to %g", speedSet); - // send command "set speed" - uint16_t dir = (speedSet > 0.) ? CMD_FORWARD : CMD_REVERSE; - uint16_t freq = REVMIN2FREQ(fabs(speedSet)); - modbus_write_register(modbus_ctx, REG_CMD, dir); - modbus_write_register(modbus_ctx, REG_FREQ_SET, freq); + if(fabs(speedSet) < SPEED_TOLERANCE){ // stop motor + modbus_write_register(modbus_ctx, REG_CMD, CMD_STOP); + }else{ // send command "set speed" + uint16_t dir = (speedSet > 0.) ? CMD_FORWARD : CMD_REVERSE; + uint16_t freq = REVMIN2FREQ(fabs(speedSet)); + modbus_write_register(modbus_ctx, REG_CMD, dir); + modbus_write_register(modbus_ctx, REG_FREQ_SET, freq); + } flags.change_speed = 0; } } @@ -256,6 +288,7 @@ static void motors_process_m(){ curN = 0; count_motors(); } + pthread_mutex_unlock(&statemutex); return; } DBG("motor %d; status: %x, extstatus: %x", curN, regs[0], regs[1]); @@ -293,13 +326,18 @@ static void motors_process_m(){ count_motors(); } errctr = 0; + pthread_mutex_unlock(&statemutex); return; reg_error: + pthread_mutex_unlock(&statemutex); ++errctr; } static void motors_process_e(){ static double t0 = -1., curspeed = 0.; - double curt = sl_dtime(), dt = curt - t0, curcurrent = 0.; + double curt = sl_dtime(); + if(t0 < 0.) t0 = curt; + double dt = curt - t0, curcurrent = 0.; + pthread_mutex_lock(&statemutex); int curstatus = motstates[0].status; if(flags.all){ if(flags.stop){ @@ -331,17 +369,21 @@ static void motors_process_e(){ motstates[i].current = curcurrent; motstates[i].speed = curspeed; } + pthread_mutex_unlock(&statemutex); } int (*motors_open)(const char *, int) = motors_open_m; void (*motors_close)() = motors_close_m; void (*motors_process)() = motors_process_m; +// Run only @ start of main() void set_emulation_mode(){ LOGMSG("Set emulation mode"); + pthread_mutex_lock(&statemutex); motors_open = motors_open_e; motors_close = motors_close_e; motors_process = motors_process_e; + pthread_mutex_unlock(&statemutex); } int motors_get_working_amount(){ return n_working_motors; } diff --git a/BTA_dome_modbus/motors.h b/BTA_dome_modbus/motors.h index 2eb38e5..6297877 100644 --- a/BTA_dome_modbus/motors.h +++ b/BTA_dome_modbus/motors.h @@ -29,6 +29,7 @@ // freq_scale == 100, so for UINT16_t we can't make speed more than 655.35 #define MAX_SPEED 655. #define SPEED_TOLERANCE 0.01 + // emulation acceleration, min^-2 #define EMUL_ACCEL 10000. #define MAX_CURRENT 15. diff --git a/BTA_dome_modbus/server.c b/BTA_dome_modbus/server.c index c294263..59ece81 100644 --- a/BTA_dome_modbus/server.c +++ b/BTA_dome_modbus/server.c @@ -16,6 +16,7 @@ * along with this program. If not, see . */ +#include #include #include "cmdlnopts.h" @@ -35,8 +36,8 @@ typedef struct{ const char *helpstring; } command_t; -static const char *maxcl = "Max client number reached, connect later\n"; -static const char *sslerr = "SSL error occured\n"; +static const char maxcl[] = "Max client number reached, connect later\n"; +static const char sslerr[] = "SSL error occured\n"; // declaration of handlers #define NEW_HANDLER(name, unused) \ @@ -70,9 +71,8 @@ static int handle_connection(SSL *ssl){ char buf[IOBUF_LEN], key[SL_KEY_LEN], val[SL_VAL_LEN]; int r = read_string(ssl, buf, IOBUF_LEN); if(r < 0) return 0; - int sd = SSL_get_fd(ssl); - //DBG("Client %d msg: \"%s\"\n", sd, buf); - LOGDBG("fd=%d, message=%s", sd, buf); + else if(r == 0) return 1; // nothing to read or buffer overflow + LOGDBG("fd=%d, message=%s", SSL_get_fd(ssl), buf); int got = sl_get_keyval(buf, key, val); if(got == 0){ DBG("Comment or empty string"); @@ -93,7 +93,7 @@ static int handle_connection(SSL *ssl){ if(0 == strcmp(key, "help")){ for(size_t i = 0; i < HANDLERS_AMOUNT; ++i){ snprintf(buf, IOBUF_LEN-1, "%s: %s\n", command_list[i].command, command_list[i].helpstring); - SSL_write(ssl, buf, strlen(buf)); + write_string(ssl, buf); } return 1; } @@ -101,7 +101,7 @@ static int handle_connection(SSL *ssl){ // now `val` is an answer or error code if(result != RESULT_SILENCE) snprintf(buf, IOBUF_LEN-1, "%s\n", sl_sock_hresult2str(result)); else snprintf(buf, IOBUF_LEN-1, "%s=%s\n", key, val); - SSL_write(ssl, buf, strlen(buf)); + write_string(ssl, buf); return 1; } @@ -120,8 +120,9 @@ static int timeouted_sslaccept(SSL *ssl){ SSL_ERROR_WANT_WRITE == sslerr) continue; DBG("SSL error %d", sslerr); return FALSE; - } - else return TRUE; + }else if(x == 1) return TRUE; + // x == 0 -> unclosed connection + usleep(10000); } DBG("Timeout"); return FALSE; @@ -152,7 +153,7 @@ void serverproc(SSL_CTX *ctx, int fd){ 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); + write_string(ssls[i], buf); } t0 = tnow; }*/ @@ -162,6 +163,7 @@ void serverproc(SSL_CTX *ctx, int fd){ 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 + if(client < 0) continue; // accept4() error 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){ @@ -186,6 +188,7 @@ void serverproc(SSL_CTX *ctx, int fd){ }else{ LOGERR("SSL_accept()"); WARNX("SSL_accept()"); + SSL_shutdown(ssl); SSL_free(ssl); send(client, sslerr, sizeof(sslerr)-1, MSG_NOSIGNAL); shutdown(client, SHUT_WR); @@ -199,7 +202,9 @@ void serverproc(SSL_CTX *ctx, int fd){ if((poll_set[fdidx].revents & POLLIN) == 0) continue; int fd = poll_set[fdidx].fd; if(!handle_connection(ssls[fdidx])){ // socket closed + SSL_shutdown(ssls[fdidx]); SSL_free(ssls[fdidx]); + ERR_clear_error(); DBG("Client fd=%d disconnected", fd); LOGMSG("Client fd=%d disconnected", fd); close(fd); @@ -210,7 +215,10 @@ void serverproc(SSL_CTX *ctx, int fd){ } } } - for(int i = 0; i < nfd; ++i) SSL_free(ssls[i]); + for(int i = 1; i < nfd; ++i){ + SSL_shutdown(ssls[i]); + SSL_free(ssls[i]); + } motors_stop(); motors_close(); } @@ -218,6 +226,7 @@ void serverproc(SSL_CTX *ctx, int fd){ /****************** Protocol handlers (return 0 in case of success or error code >0 if failed) ******************/ static sl_sock_hresult_e adc_handler(int _U_ index, char value[SL_VAL_LEN]){ int I; uint16_t val; + // have setter format: adc=x for reading x channel if(!ISSETTER(value) || !sl_str2i(&I, value)) return RESULT_BADVAL; if(!io_read_adc(I, &val)) return RESULT_BADVAL; snprintf(value, SL_VAL_LEN-1, "%d", val); @@ -347,11 +356,13 @@ static sl_sock_hresult_e speed_handler(int _U_ index, char _U_ value[SL_VAL_LEN] } static sl_sock_hresult_e stop_handler(int _U_ index, char _U_ value[SL_VAL_LEN]){ + if(ISSETTER(value)) return RESULT_BADVAL; // not setter motors_stop(); return RESULT_OK; } -static sl_sock_hresult_e nmotors_handler(int _U_ index, char _U_ value[SL_VAL_LEN]){ +static sl_sock_hresult_e nmotors_handler(int _U_ index, char value[SL_VAL_LEN]){ + if(ISSETTER(value)) return RESULT_BADVAL; // only getter snprintf(value, SL_VAL_LEN-1, "%d", motors_get_working_amount()); return RESULT_SILENCE; } @@ -366,11 +377,13 @@ static sl_sock_hresult_e logprefix_handler(int _U_ index, char _U_ value[SL_VAL_ } static sl_sock_hresult_e startlog_handler(int _U_ index, char _U_ value[SL_VAL_LEN]){ + if(ISSETTER(value)) return RESULT_BADVAL; // not setter if(start_log()) return RESULT_OK; return RESULT_FAIL; } static sl_sock_hresult_e stoplog_handler(int _U_ index, char _U_ value[SL_VAL_LEN]){ + if(ISSETTER(value)) return RESULT_BADVAL; // not setter stop_log(); return RESULT_OK; } @@ -379,10 +392,14 @@ static sl_sock_hresult_e stoplog_handler(int _U_ index, char _U_ value[SL_VAL_LE static int search_handler(const char *name){ int low = 0; int high = HANDLERS_AMOUNT - 1; +#ifdef EBUG int iter = 0; +#endif while(low <= high){ +#ifdef EBUG ++iter; +#endif int mid = low + (high - low) / 2; // Compare the target string with the struct's string field int res = strcmp(name, command_list[mid].command); diff --git a/BTA_dome_modbus/sslsock.c b/BTA_dome_modbus/sslsock.c index 12881c4..9de9557 100644 --- a/BTA_dome_modbus/sslsock.c +++ b/BTA_dome_modbus/sslsock.c @@ -21,6 +21,7 @@ #include // pthread_kill #include #include +#include #include #include "cmdlnopts.h" @@ -75,7 +76,8 @@ static int OpenConn(int port){ bzero(&addr, sizeof(addr)); addr.sin_family = AF_INET; addr.sin_port = htons(port); - addr.sin_addr.s_addr = *(long*)(host->h_addr); + //addr.sin_addr.s_addr = *(long*)(host->h_addr); + memcpy(&addr.sin_addr, host->h_addr, host->h_length); if(connect(sd, (struct sockaddr*)&addr, sizeof(addr))){ close(sd); LOGWARN("Can't connect to %s", G.serverhost); @@ -88,8 +90,8 @@ static int OpenConn(int port){ static SSL_CTX* InitCTX(void){ const SSL_METHOD *method; SSL_CTX *ctx; - OpenSSL_add_all_algorithms(); - SSL_load_error_strings(); + //OpenSSL_add_all_algorithms(); + //SSL_load_error_strings(); method = #ifdef CLIENT TLS_client_method(); @@ -101,27 +103,39 @@ static SSL_CTX* InitCTX(void){ LOGWARN("Can't create SSL context"); ERRX("SSL_CTX_new()"); } + if(!SSL_CTX_set_min_proto_version(ctx, TLS1_2_VERSION)){ + LOGWARN("Can't set minimum TLS protocol version"); + ERRX("SSL_CTX_set_min_proto_version()"); + } 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)); + STACK_OF(X509_NAME) *cert_names = SSL_load_client_CA_file(G.ca); + if(!cert_names){ + LOGWARN("Could not load client CA file %s", G.ca); + ERRX("SSL_load_client_CA_file()"); + } + SSL_CTX_set_client_CA_list(ctx, cert_names); #endif if(SSL_CTX_use_certificate_file(ctx, G.cert, SSL_FILETYPE_PEM) <= 0){ + ERR_print_errors_fp(stderr); 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){ + ERR_print_errors_fp(stderr); 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)){ + ERR_print_errors_fp(stderr); 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); + // don't need as socket would be non-blocking + // 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, @@ -129,7 +143,7 @@ static SSL_CTX* InitCTX(void){ #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 + SSL_CTX_set_verify_depth(ctx, 1); // We accept only certificates signed by the CA himself return ctx; } @@ -143,6 +157,8 @@ int open_socket(){ if(!motors_open(G.serialpath, G.serialspeed)){ LOGERR("Can't open %s @%d", G.serialpath, G.serialspeed); WARNX("Can't open %s @%d", G.serialpath, G.serialspeed); + close(fd); + SSL_CTX_free(ctx); return 1; } DBG("Motors opened: Stop them"); @@ -155,7 +171,6 @@ int open_socket(){ if(G.terminal) terminal(ctx, fd); else clientproc(ctx, fd); #endif - // newer reached close(fd); SSL_CTX_free(ctx); return 0; @@ -186,7 +201,7 @@ int read_string(SSL *ssl, char *buf, int l){ if(bytes < 1){ // nothing to read or error return geterrcode(ssl, bytes); } - char *eol = strchr(buf, '\n'); + char *eol = memchr(buf, '\n', bytes); if(!eol){ // not found: overflow or no enough symbols if(bytes == l){ // oops: overflow, thow it out SSL_read(ssl, buf, l); @@ -202,3 +217,29 @@ int read_string(SSL *ssl, char *buf, int l){ buf[bytes-1] = 0; // replace '\n' with 0 return bytes; } + +/** + * @brief write_string - write '\n'-terminated string + * @param ssl - SSL + * @param buf - zero-terminated buffer with text (last symbol should be '\n') + * @return FALSE in case of fail or timeout (1s) + */ +int write_string(SSL *ssl, char *buf){ + double t0 = sl_dtime(); + int l = strlen(buf); + while(sl_dtime() - t0 < 1. && l > 0){ + int written = SSL_write(ssl, buf, l); + if(written <= 0){ + int err = SSL_get_error(ssl, written); + if(err == SSL_ERROR_WANT_READ || err == SSL_ERROR_WANT_WRITE){ // try next time + continue; + } + return FALSE; // error + } + buf += written; + l -= written; + if(l) usleep(10000); + } + if(l > 0) return FALSE; + return TRUE; +} diff --git a/BTA_dome_modbus/sslsock.h b/BTA_dome_modbus/sslsock.h index 4b5fc31..3508b84 100644 --- a/BTA_dome_modbus/sslsock.h +++ b/BTA_dome_modbus/sslsock.h @@ -42,3 +42,4 @@ int open_socket(); int read_string(SSL *ssl, char *buf, int l); +int write_string(SSL *ssl, char *buf); diff --git a/BTA_dome_modbus/sslsosk.files b/BTA_dome_modbus/sslsosk.files index d083aea..a1fd802 100644 --- a/BTA_dome_modbus/sslsosk.files +++ b/BTA_dome_modbus/sslsosk.files @@ -1,3 +1,5 @@ +Makefile +Readme.md bta_shdata.c bta_shdata.h client.c