add working with pseudo-FX3U with my firmware

BTA_dome_modbus/io.c

@@ -0,0 +1,162 @@
+/*
+ * This file is part of the sslsosk project.
+ * Copyright 2026 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 <modbus/modbus.h>
+#include <pthread.h>
+#include <stdint.h>
+#include <string.h>
+#include <usefull_macros.h>
+
+#include "cmdlnopts.h"
+#include "io.h"
+
+
+static modbus_t *modbus_ctx = NULL;
+
+static uint8_t RelayBuf[NRELAYS];
+static uint8_t InputsBuf[NINPUTS];
+static uint16_t ADCBuf[NADCCHNLS];
+static pthread_mutex_t sync_mutex = PTHREAD_MUTEX_INITIALIZER;
+
+// == TRUE if something changed in buffers (reset in `io_read_inputs`)
+static uint8_t GotNew = FALSE;//, GotNewADC = FALSE;
+
+// share modbus_t opened in motors.c
+void io_set_ctx(modbus_t *ctx){
+    DBG("Get context");
+    pthread_mutex_lock(&sync_mutex);
+    modbus_ctx = ctx;
+    pthread_mutex_unlock(&sync_mutex);
+}
+
+// process reading relays & inputs state
+void io_process(){
+    uint8_t buf[NRELAYS + NINPUTS];
+    uint16_t adcbuf[NADCCHNLS];
+    if(!modbus_ctx || G.io_ID < 1) return;
+    if(-1 == modbus_set_slave(modbus_ctx, G.io_ID)){
+        WARN("Can't set IO slave ID to %d", G.io_ID);
+        return;
+    }
+    pthread_mutex_lock(&sync_mutex);
+    if(-1 == modbus_read_bits(modbus_ctx, 0, NRELAYS, buf)){
+        WARN("Can't read relay state");
+        goto ret;
+    }
+    for(int i = 0; i < NRELAYS; ++i){
+        if(buf[i] == RelayBuf[i]) continue;
+#ifdef EBUG
+        if(buf[i]) printf("Relay %d is ON\n", i);
+        else printf("Relay %d is OFF\n", i);
+        fflush(stdout);
+#endif
+        RelayBuf[i] = buf[i];
+        GotNew = TRUE;
+    }
+    if(-1 == modbus_read_input_bits(modbus_ctx, 0, NINPUTS, buf)){
+        WARN("Can't read inputs");
+        goto ret;
+    }
+    for(int i = 0; i < NINPUTS; ++i){
+        if(buf[i] == InputsBuf[i]) continue;
+#ifdef EBUG
+        if(buf[i]) printf("Input %d is Active\n", i);
+        else printf("Input %d is Inactive\n", i);
+        fflush(stdout);
+#endif
+        InputsBuf[i] = buf[i];
+        GotNew = TRUE;
+    }
+    if(-1 == modbus_read_input_registers(modbus_ctx, 0, NADCCHNLS, adcbuf)){
+        WARN("Can't read ADC inputs");
+        goto ret;
+    }
+    for(int i = 0; i < NADCCHNLS; ++i){
+        if(abs(adcbuf[i] - ADCBuf[i]) < ADCTHRESH) continue;
+        // GotNewADC = TRUE; break;
+#ifdef EBUG
+        printf("ADC input %d changed to %d\n", i, adcbuf[i]);
+        fflush(stdout);
+#endif
+    }
+    memcpy(ADCBuf, adcbuf, sizeof(uint16_t) * NADCCHNLS);
+ret:
+    pthread_mutex_unlock(&sync_mutex);
+}
+
+// get inputs state
+int io_read_inputs(char inputs[NINPUTS]){
+    pthread_mutex_lock(&sync_mutex);
+    int got = GotNew;
+    GotNew = FALSE;
+    memcpy(inputs, InputsBuf, NINPUTS);
+    pthread_mutex_unlock(&sync_mutex);
+    return got;
+}
+
+int io_read_adc(int nch, uint16_t *val){
+    if(!val || nch < 0 || nch >= NADCCHNLS) return FALSE;
+    pthread_mutex_lock(&sync_mutex);
+    /*int got = GotNewADC;
+    GotNewADC = FALSE;*/
+    *val = ADCBuf[nch];
+    pthread_mutex_unlock(&sync_mutex);
+    return TRUE;
+}
+
+// get relays state
+void io_read_relays(char relays[NRELAYS]){
+    pthread_mutex_lock(&sync_mutex);
+    memcpy(relays, RelayBuf, NRELAYS);
+    pthread_mutex_unlock(&sync_mutex);
+}
+
+static int change_relay(int N, int state){
+    if(!modbus_ctx || N < 0 || N >= NRELAYS) return FALSE;
+    int ret = FALSE;
+    pthread_mutex_lock(&sync_mutex);
+    if(1 == modbus_write_bit(modbus_ctx, N, state)) ret = TRUE;
+    else WARN("Can't set bit %d to %d", N, state);
+    pthread_mutex_unlock(&sync_mutex);
+    return ret;
+}
+
+// set relay with given number
+int io_relay_on(int N){
+    return change_relay(N, 1);
+}
+
+// reset relay with given number
+int io_relay_off(int N){
+    return change_relay(N, 0);
+}
+
+int io_set_relays(int N){
+    if(!modbus_ctx || N < 0) return FALSE;
+    int ret = FALSE;
+    uint8_t bits[NRELAYS];
+    for(int i = 0; i < NRELAYS; ++i){
+        if(N & (1 << i)) bits[i] = 1;
+        else bits[i] = 0;
+    }
+    pthread_mutex_lock(&sync_mutex);
+    if(1 == modbus_write_bits(modbus_ctx, 0, NRELAYS, bits)) ret = TRUE;
+    else WARN("Can't write bits %d", N);
+    pthread_mutex_unlock(&sync_mutex);
+    return ret;
+}