Initial set values for blocks config

src/jl_modbus/jl_config.c

@@ -1,9 +1,10 @@
 #include <jl_modbus/jl_config.h>
 #include <stdio.h>
 #include <string.h>
+#include <unistd.h>
 
-#if JL_CONFIG_SAVE_TO_FILE
-static const char *jl_config_path = JL_CONFIG_SAVE_TO_FILE_PATH;
+#ifndef JL_CONFIG_USE_FILE
+static const char* jl_config_path = "./";
 void
 jl_config_load(const char *name, void *def, size_t size)
 {

src/jlv135_cli/jl_block_datatime.c

@@ -1,6 +1,8 @@
 #include <jl_modbus/jl_config.h>
 #include <jlv135_cli/jl_block_datatime.h>
 #include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
 #include <stdint.h>
 
 typedef struct _jl_datatime_config_t
@@ -27,18 +29,125 @@ jl_block_datatime_get(void)
     return 0;
 }
 
-// Метод set: заглушка (TODO)
+// Метод set: изменяет параметры блока datatime
 int
 jl_block_datatime_set(int argc, const char *argv[])
 {
-    (void)argc;
-    (void)argv;
-
-    fprintf(stderr, "TODO: Date/Time configuration modification is not yet implemented\n");
-    fprintf(stderr, "Future usage examples:\n");
+    if (argc < 1)
+    {
+        fprintf(stderr, "Error: insufficient arguments for 'set datatime'\n");
+        fprintf(stderr, "Usage:\n");
         fprintf(stderr, "  jlv135_cli set datatime ntp <on|off>\n");
+        fprintf(stderr, "  jlv135_cli set datatime settime <on|off>\n");
         fprintf(stderr, "  jlv135_cli set datatime gmt <-12..+12>\n");
-    fprintf(stderr, "  jlv135_cli set datatime correction <seconds>\n");
-
+        fprintf(stderr, "  jlv135_cli set datatime correction <-127..127>\n");
         return 1;
+    }
+
+    jl_datatime_config_t conf = {};
+    jl_config_load("datatime", &conf, sizeof(jl_datatime_config_t));
+
+    // NTP enable
+    if (strcmp(argv[0], "ntp") == 0)
+    {
+        if (argc < 2)
+        {
+            fprintf(stderr, "Error: ntp value required (on|off)\n");
+            return 1;
+        }
+
+        if (strcmp(argv[1], "on") == 0 || strcmp(argv[1], "1") == 0)
+        {
+            conf.ntp_en = 1;
+        }
+        else if (strcmp(argv[1], "off") == 0 || strcmp(argv[1], "0") == 0)
+        {
+            conf.ntp_en = 0;
+        }
+        else
+        {
+            fprintf(stderr, "Error: invalid ntp value '%s' (use on|off)\n", argv[1]);
+            return 1;
+        }
+
+        jl_config_save("datatime", &conf, sizeof(jl_datatime_config_t));
+        printf("NTP sync %s\n", conf.ntp_en ? "enabled" : "disabled");
+        return 0;
+    }
+    // Set time enable
+    else if (strcmp(argv[0], "settime") == 0)
+    {
+        if (argc < 2)
+        {
+            fprintf(stderr, "Error: settime value required (on|off)\n");
+            return 1;
+        }
+
+        if (strcmp(argv[1], "on") == 0 || strcmp(argv[1], "1") == 0)
+        {
+            conf.settime_en = 1;
+        }
+        else if (strcmp(argv[1], "off") == 0 || strcmp(argv[1], "0") == 0)
+        {
+            conf.settime_en = 0;
+        }
+        else
+        {
+            fprintf(stderr, "Error: invalid settime value '%s' (use on|off)\n", argv[1]);
+            return 1;
+        }
+
+        jl_config_save("datatime", &conf, sizeof(jl_datatime_config_t));
+        printf("Set time %s\n", conf.settime_en ? "allowed" : "not allowed");
+        return 0;
+    }
+    // GMT offset
+    else if (strcmp(argv[0], "gmt") == 0)
+    {
+        if (argc < 2)
+        {
+            fprintf(stderr, "Error: GMT offset value required\n");
+            return 1;
+        }
+
+        long val = strtol(argv[1], NULL, 10);
+        if (val < -12 || val > 12)
+        {
+            fprintf(stderr, "Error: GMT offset must be between -12 and +12\n");
+            return 1;
+        }
+
+        conf.gmt = (int8_t)val;
+        jl_config_save("datatime", &conf, sizeof(jl_datatime_config_t));
+        printf("GMT offset set to %+d hours\n", conf.gmt);
+        return 0;
+    }
+    // Time correction
+    else if (strcmp(argv[0], "correction") == 0)
+    {
+        if (argc < 2)
+        {
+            fprintf(stderr, "Error: correction value required\n");
+            return 1;
+        }
+
+        long val = strtol(argv[1], NULL, 10);
+        if (val < -127 || val > 127)
+        {
+            fprintf(stderr, "Error: correction must be between -127 and +127\n");
+            return 1;
+        }
+
+        conf.correction = (int8_t)val;
+        jl_config_save("datatime", &conf, sizeof(jl_datatime_config_t));
+        printf("Time correction set to %d sec/day\n", conf.correction);
+        return 0;
+    }
+    else
+    {
+        fprintf(stderr, "Error: unknown parameter '%s'\n", argv[0]);
+        return 1;
+    }
+
+    return 0;
 }

src/jlv135_cli/jl_block_display.c

@@ -1,6 +1,8 @@
 #include <jl_modbus/jl_config.h>
 #include <jlv135_cli/jl_block_display.h>
 #include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
 #include <stdint.h>
 #include <stdbool.h>
 
@@ -127,18 +129,134 @@ jl_block_display_get(void)
     return 0;
 }
 
-// Метод set: заглушка (TODO)
+// Метод set: изменяет параметры блока display
 int
 jl_block_display_set(int argc, const char *argv[])
 {
-    (void)argc;
-    (void)argv;
-
-    fprintf(stderr, "TODO: Display configuration modification is not yet implemented\n");
-    fprintf(stderr, "Future usage examples:\n");
+    if (argc < 1)
+    {
+        fprintf(stderr, "Error: insufficient arguments for 'set display'\n");
+        fprintf(stderr, "Usage:\n");
         fprintf(stderr, "  jlv135_cli set display backlight <0-100>\n");
         fprintf(stderr, "  jlv135_cli set display night_backlight <0-100>\n");
         fprintf(stderr, "  jlv135_cli set display night <on|off>\n");
-
+        fprintf(stderr, "  jlv135_cli set display led <on|off>\n");
+        fprintf(stderr, "  jlv135_cli set display pu_temper <0|1>\n");
+        fprintf(stderr, "  jlv135_cli set display pu_hum <0|1>\n");
         return 1;
+    }
+
+    jlv_display_t conf = {};
+    jl_config_load("display", &conf, sizeof(jlv_display_t));
+
+    if (argc < 2)
+    {
+        fprintf(stderr, "Error: value required\n");
+        return 1;
+    }
+
+    // Backlight
+    if (strcmp(argv[0], "backlight") == 0)
+    {
+        long val = strtol(argv[1], NULL, 10);
+        if (val < 0 || val > 100)
+        {
+            fprintf(stderr, "Error: backlight must be between 0 and 100\n");
+            return 1;
+        }
+        conf.backlight = (uint8_t)val;
+        jl_config_save("display", &conf, sizeof(jlv_display_t));
+        printf("Backlight set to %u%%\n", conf.backlight);
+        return 0;
+    }
+    // Night backlight
+    else if (strcmp(argv[0], "night_backlight") == 0)
+    {
+        long val = strtol(argv[1], NULL, 10);
+        if (val < 0 || val > 100)
+        {
+            fprintf(stderr, "Error: night_backlight must be between 0 and 100\n");
+            return 1;
+        }
+        conf.night_backlight = (uint8_t)val;
+        jl_config_save("display", &conf, sizeof(jlv_display_t));
+        printf("Night backlight set to %u%%\n", conf.night_backlight);
+        return 0;
+    }
+    // Night mode
+    else if (strcmp(argv[0], "night") == 0)
+    {
+        if (strcmp(argv[1], "on") == 0 || strcmp(argv[1], "1") == 0)
+        {
+            conf.night = true;
+        }
+        else if (strcmp(argv[1], "off") == 0 || strcmp(argv[1], "0") == 0)
+        {
+            conf.night = false;
+        }
+        else
+        {
+            fprintf(stderr, "Error: invalid night value '%s' (use on|off)\n", argv[1]);
+            return 1;
+        }
+        jl_config_save("display", &conf, sizeof(jlv_display_t));
+        printf("Night mode %s\n", conf.night ? "enabled" : "disabled");
+        return 0;
+    }
+    // LED
+    else if (strcmp(argv[0], "led") == 0)
+    {
+        if (strcmp(argv[1], "on") == 0 || strcmp(argv[1], "1") == 0)
+        {
+            conf.led_disable = false;
+        }
+        else if (strcmp(argv[1], "off") == 0 || strcmp(argv[1], "0") == 0)
+        {
+            conf.led_disable = true;
+        }
+        else
+        {
+            fprintf(stderr, "Error: invalid led value '%s' (use on|off)\n", argv[1]);
+            return 1;
+        }
+        jl_config_save("display", &conf, sizeof(jlv_display_t));
+        printf("LED %s\n", conf.led_disable ? "disabled" : "enabled");
+        return 0;
+    }
+    // PU Temperature source
+    else if (strcmp(argv[0], "pu_temper") == 0)
+    {
+        long val = strtol(argv[1], NULL, 10);
+        if (val < 0 || val > 1)
+        {
+            fprintf(stderr, "Error: pu_temper must be 0 or 1\n");
+            return 1;
+        }
+        conf.pu_temper = (uint8_t)val;
+        jl_config_save("display", &conf, sizeof(jlv_display_t));
+        printf("PU Temperature set to %s\n", conf.pu_temper ? "from controller" : "local sensor");
+        return 0;
+    }
+    // PU Humidity source
+    else if (strcmp(argv[0], "pu_hum") == 0)
+    {
+        long val = strtol(argv[1], NULL, 10);
+        if (val < 0 || val > 1)
+        {
+            fprintf(stderr, "Error: pu_hum must be 0 or 1\n");
+            return 1;
+        }
+        conf.pu_hum = (uint8_t)val;
+        jl_config_save("display", &conf, sizeof(jlv_display_t));
+        printf("PU Humidity set to %s\n", conf.pu_hum ? "from controller" : "local sensor");
+        return 0;
+    }
+    else
+    {
+        fprintf(stderr, "Error: unknown parameter '%s'\n", argv[0]);
+        fprintf(stderr, "Note: screensaver settings are not yet supported via set command\n");
+        return 1;
+    }
+
+    return 0;
 }

src/jlv135_cli/jl_block_feature.c

@@ -1,6 +1,8 @@
 #include <jl_modbus/jl_config.h>
 #include <jlv135_cli/jl_block_feature.h>
 #include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
 #include <time.h>
 #include <stdbool.h>
 #include <stdint.h>
@@ -45,18 +47,181 @@ jl_block_feature_get(void)
     return 0;
 }
 
-// Метод set: заглушка (TODO)
+// Метод set: изменяет параметры блока feature
 int
 jl_block_feature_set(int argc, const char *argv[])
 {
-    (void)argc;
-    (void)argv;
-
-    fprintf(stderr, "TODO: Feature configuration modification is not yet implemented\n");
-    fprintf(stderr, "Future usage examples:\n");
+    if (argc < 1)
+    {
+        fprintf(stderr, "Error: insufficient arguments for 'set feature'\n");
+        fprintf(stderr, "Usage:\n");
         fprintf(stderr, "  jlv135_cli set feature sound <on|off>\n");
         fprintf(stderr, "  jlv135_cli set feature wifi <on|off>\n");
+        fprintf(stderr, "  jlv135_cli set feature remote <on|off>\n");
         fprintf(stderr, "  jlv135_cli set feature socket1 <on|off>\n");
-
+        fprintf(stderr, "  jlv135_cli set feature socket2 <on|off>\n");
+        fprintf(stderr, "  jlv135_cli set feature mb_server <on|off>\n");
+        fprintf(stderr, "  jlv135_cli set feature extra_sensor <value>\n");
         return 1;
+    }
+
+    jl_feature_t conf = {};
+    jl_config_load("feature", &conf, sizeof(jl_feature_t));
+
+    if (argc < 2)
+    {
+        fprintf(stderr, "Error: value required\n");
+        return 1;
+    }
+
+    // Вспомогательная функция для парсинга on/off значений
+    bool value_bool;
+    if (strcmp(argv[1], "on") == 0 || strcmp(argv[1], "1") == 0)
+    {
+        value_bool = true;
+    }
+    else if (strcmp(argv[1], "off") == 0 || strcmp(argv[1], "0") == 0)
+    {
+        value_bool = false;
+    }
+    else
+    {
+        // Если это не on/off, то может быть числовое значение для integer полей
+        value_bool = false; // будет использоваться только для boolean полей
+    }
+
+    // Boolean features
+    if (strcmp(argv[0], "sound") == 0)
+    {
+        if (strcmp(argv[1], "on") != 0 && strcmp(argv[1], "1") != 0 &&
+            strcmp(argv[1], "off") != 0 && strcmp(argv[1], "0") != 0)
+        {
+            fprintf(stderr, "Error: invalid sound value '%s' (use on|off)\n", argv[1]);
+            return 1;
+        }
+        conf.sound = value_bool;
+        jl_config_save("feature", &conf, sizeof(jl_feature_t));
+        printf("Feature sound %s\n", conf.sound ? "enabled" : "disabled");
+        return 0;
+    }
+    else if (strcmp(argv[0], "wifi") == 0)
+    {
+        if (strcmp(argv[1], "on") != 0 && strcmp(argv[1], "1") != 0 &&
+            strcmp(argv[1], "off") != 0 && strcmp(argv[1], "0") != 0)
+        {
+            fprintf(stderr, "Error: invalid wifi value '%s' (use on|off)\n", argv[1]);
+            return 1;
+        }
+        conf.wifi = value_bool;
+        jl_config_save("feature", &conf, sizeof(jl_feature_t));
+        printf("Feature wifi %s\n", conf.wifi ? "enabled" : "disabled");
+        return 0;
+    }
+    else if (strcmp(argv[0], "remote") == 0)
+    {
+        if (strcmp(argv[1], "on") != 0 && strcmp(argv[1], "1") != 0 &&
+            strcmp(argv[1], "off") != 0 && strcmp(argv[1], "0") != 0)
+        {
+            fprintf(stderr, "Error: invalid remote value '%s' (use on|off)\n", argv[1]);
+            return 1;
+        }
+        conf.remote = value_bool;
+        jl_config_save("feature", &conf, sizeof(jl_feature_t));
+        printf("Feature remote %s\n", conf.remote ? "enabled" : "disabled");
+        return 0;
+    }
+    else if (strcmp(argv[0], "socket1") == 0)
+    {
+        if (strcmp(argv[1], "on") != 0 && strcmp(argv[1], "1") != 0 &&
+            strcmp(argv[1], "off") != 0 && strcmp(argv[1], "0") != 0)
+        {
+            fprintf(stderr, "Error: invalid socket1 value '%s' (use on|off)\n", argv[1]);
+            return 1;
+        }
+        conf.socket1 = value_bool;
+        jl_config_save("feature", &conf, sizeof(jl_feature_t));
+        printf("Feature socket1 %s\n", conf.socket1 ? "enabled" : "disabled");
+        return 0;
+    }
+    else if (strcmp(argv[0], "socket2") == 0)
+    {
+        if (strcmp(argv[1], "on") != 0 && strcmp(argv[1], "1") != 0 &&
+            strcmp(argv[1], "off") != 0 && strcmp(argv[1], "0") != 0)
+        {
+            fprintf(stderr, "Error: invalid socket2 value '%s' (use on|off)\n", argv[1]);
+            return 1;
+        }
+        conf.socket2 = value_bool;
+        jl_config_save("feature", &conf, sizeof(jl_feature_t));
+        printf("Feature socket2 %s\n", conf.socket2 ? "enabled" : "disabled");
+        return 0;
+    }
+    else if (strcmp(argv[0], "mb_server") == 0)
+    {
+        if (strcmp(argv[1], "on") != 0 && strcmp(argv[1], "1") != 0 &&
+            strcmp(argv[1], "off") != 0 && strcmp(argv[1], "0") != 0)
+        {
+            fprintf(stderr, "Error: invalid mb_server value '%s' (use on|off)\n", argv[1]);
+            return 1;
+        }
+        conf.mb_server = value_bool;
+        jl_config_save("feature", &conf, sizeof(jl_feature_t));
+        printf("Feature mb_server %s\n", conf.mb_server ? "enabled" : "disabled");
+        return 0;
+    }
+    else if (strcmp(argv[0], "socket1_auto_disable") == 0)
+    {
+        if (strcmp(argv[1], "on") != 0 && strcmp(argv[1], "1") != 0 &&
+            strcmp(argv[1], "off") != 0 && strcmp(argv[1], "0") != 0)
+        {
+            fprintf(stderr, "Error: invalid socket1_auto_disable value '%s' (use on|off)\n", argv[1]);
+            return 1;
+        }
+        conf.socket1_auto_disable = value_bool;
+        jl_config_save("feature", &conf, sizeof(jl_feature_t));
+        printf("Feature socket1_auto_disable %s\n", conf.socket1_auto_disable ? "enabled" : "disabled");
+        return 0;
+    }
+    else if (strcmp(argv[0], "socket1_mb_disable") == 0)
+    {
+        if (strcmp(argv[1], "on") != 0 && strcmp(argv[1], "1") != 0 &&
+            strcmp(argv[1], "off") != 0 && strcmp(argv[1], "0") != 0)
+        {
+            fprintf(stderr, "Error: invalid socket1_mb_disable value '%s' (use on|off)\n", argv[1]);
+            return 1;
+        }
+        conf.socket1_mb_disable = value_bool;
+        jl_config_save("feature", &conf, sizeof(jl_feature_t));
+        printf("Feature socket1_mb_disable %s\n", conf.socket1_mb_disable ? "enabled" : "disabled");
+        return 0;
+    }
+    // Integer features
+    else if (strcmp(argv[0], "extra_sensor") == 0)
+    {
+        conf.extra_sensor = (int)strtol(argv[1], NULL, 10);
+        jl_config_save("feature", &conf, sizeof(jl_feature_t));
+        printf("Extra sensor set to %d\n", conf.extra_sensor);
+        return 0;
+    }
+    else if (strcmp(argv[0], "socket1_server") == 0)
+    {
+        conf.socket1_server = (int)strtol(argv[1], NULL, 10);
+        jl_config_save("feature", &conf, sizeof(jl_feature_t));
+        printf("Socket1 server set to %d\n", conf.socket1_server);
+        return 0;
+    }
+    else if (strcmp(argv[0], "socket2_server") == 0)
+    {
+        conf.socket2_server = (int)strtol(argv[1], NULL, 10);
+        jl_config_save("feature", &conf, sizeof(jl_feature_t));
+        printf("Socket2 server set to %d\n", conf.socket2_server);
+        return 0;
+    }
+    else
+    {
+        fprintf(stderr, "Error: unknown parameter '%s'\n", argv[0]);
+        return 1;
+    }
+
+    return 0;
 }

src/jlv135_cli/jl_block_modbus.c

@@ -75,13 +75,20 @@ jl_block_modbus_set(int argc, const char *argv[])
         fprintf(stderr, "Usage examples:\n");
         fprintf(stderr, "  jlv135_cli set modbus rs485 speed <value>\n");
         fprintf(stderr, "  jlv135_cli set modbus rs485 timeout <ms>\n");
-        fprintf(stderr, "  jlv135_cli set modbus tcp ip <address>\n");
+        fprintf(stderr, "  jlv135_cli set modbus rs485 repeat <count>\n");
+        fprintf(stderr, "  jlv135_cli set modbus tcp ip <x.x.x.x>\n");
         fprintf(stderr, "  jlv135_cli set modbus tcp port <number>\n");
+        fprintf(stderr, "  jlv135_cli set modbus tcp timeout <ms>\n");
+        fprintf(stderr, "  jlv135_cli set modbus tcp repeat <count>\n");
         fprintf(stderr, "  jlv135_cli set modbus addr <1-247>\n");
         fprintf(stderr, "  jlv135_cli set modbus active_port <0|1>\n");
+        fprintf(stderr, "  jlv135_cli set modbus tcycle <ms>\n");
         return 1;
     }
 
+    jl_modbus_config_t conf = {};
+    jl_config_load("modbus", &conf, sizeof(jl_modbus_config_t));
+
     // RS485 параметры
     if (strcmp(argv[0], "rs485") == 0)
     {
@@ -92,12 +99,9 @@ jl_block_modbus_set(int argc, const char *argv[])
             return 1;
         }
 
-        // RS485 speed - реализовано
+        // RS485 speed
         if (strcmp(argv[1], "speed") == 0)
         {
-            jl_modbus_config_t conf = {};
-            jl_config_load("modbus", &conf, sizeof(jl_modbus_config_t));
-
             long val = strtol(argv[2], NULL, 10);
             int  idx = jl_modbus_rs485_baud_rate_get_index_by_baud(val);
 
@@ -118,52 +122,184 @@ jl_block_modbus_set(int argc, const char *argv[])
             printf("RS485 speed set to %u baud\n", jl_modbus_rs485_baud_rates[idx]);
             return 0;
         }
-        // RS485 timeout - TODO
+        // RS485 timeout
         else if (strcmp(argv[1], "timeout") == 0)
         {
-            fprintf(stderr, "TODO: RS485 timeout modification is not yet implemented\n");
+            long val = strtol(argv[2], NULL, 10);
+            if (val < 0 || val > 65535)
+            {
+                fprintf(stderr, "Error: timeout must be between 0 and 65535 ms\n");
                 return 1;
             }
-        // RS485 repeat - TODO
+            conf.port_rtu.timeout = (uint16_t)val;
+            jl_config_save("modbus", &conf, sizeof(jl_modbus_config_t));
+            printf("RS485 timeout set to %u ms\n", conf.port_rtu.timeout);
+            return 0;
+        }
+        // RS485 repeat
         else if (strcmp(argv[1], "repeat") == 0)
         {
-            fprintf(stderr, "TODO: RS485 repeat count modification is not yet implemented\n");
+            long val = strtol(argv[2], NULL, 10);
+            if (val < 0 || val > 65535)
+            {
+                fprintf(stderr, "Error: repeat count must be between 0 and 65535\n");
                 return 1;
             }
+            conf.port_rtu.repeate = (uint16_t)val;
+            jl_config_save("modbus", &conf, sizeof(jl_modbus_config_t));
+            printf("RS485 repeat count set to %u\n", conf.port_rtu.repeate);
+            return 0;
+        }
         else
         {
             fprintf(stderr, "Error: unknown RS485 parameter '%s'\n", argv[1]);
             return 1;
         }
     }
-    // TCP параметры - TODO
+    // TCP параметры
     else if (strcmp(argv[0], "tcp") == 0)
     {
-        fprintf(stderr, "TODO: TCP configuration modification is not yet implemented\n");
-        fprintf(stderr, "Future usage:\n");
-        fprintf(stderr, "  jlv135_cli set modbus tcp ip <x.x.x.x>\n");
-        fprintf(stderr, "  jlv135_cli set modbus tcp port <number>\n");
-        fprintf(stderr, "  jlv135_cli set modbus tcp timeout <ms>\n");
+        if (argc < 3)
+        {
+            fprintf(stderr, "Error: insufficient arguments for 'set modbus tcp'\n");
+            fprintf(stderr, "Usage: jlv135_cli set modbus tcp <ip|port|timeout|repeat> <value>\n");
             return 1;
         }
-    // Device address - TODO
+
+        // TCP IP address
+        if (strcmp(argv[1], "ip") == 0)
+        {
+            unsigned int ip[4];
+            if (sscanf(argv[2], "%u.%u.%u.%u", &ip[0], &ip[1], &ip[2], &ip[3]) != 4)
+            {
+                fprintf(stderr, "Error: invalid IP address format '%s' (use x.x.x.x)\n", argv[2]);
+                return 1;
+            }
+
+            for (int i = 0; i < 4; i++)
+            {
+                if (ip[i] > 255)
+                {
+                    fprintf(stderr, "Error: IP address octets must be between 0 and 255\n");
+                    return 1;
+                }
+            }
+
+            // Упаковываем IP адрес в uint32_t
+            conf.port_tcp.addr = (ip[0]) | (ip[1] << 8) | (ip[2] << 16) | (ip[3] << 24);
+            jl_config_save("modbus", &conf, sizeof(jl_modbus_config_t));
+            printf("TCP IP address set to %u.%u.%u.%u\n", ip[0], ip[1], ip[2], ip[3]);
+            return 0;
+        }
+        // TCP port
+        else if (strcmp(argv[1], "port") == 0)
+        {
+            long val = strtol(argv[2], NULL, 10);
+            if (val < 1 || val > 65535)
+            {
+                fprintf(stderr, "Error: port must be between 1 and 65535\n");
+                return 1;
+            }
+            conf.port_tcp.port = (uint16_t)val;
+            jl_config_save("modbus", &conf, sizeof(jl_modbus_config_t));
+            printf("TCP port set to %u\n", conf.port_tcp.port);
+            return 0;
+        }
+        // TCP timeout
+        else if (strcmp(argv[1], "timeout") == 0)
+        {
+            long val = strtol(argv[2], NULL, 10);
+            if (val < 0 || val > 65535)
+            {
+                fprintf(stderr, "Error: timeout must be between 0 and 65535 ms\n");
+                return 1;
+            }
+            conf.port_tcp.timeout = (uint16_t)val;
+            jl_config_save("modbus", &conf, sizeof(jl_modbus_config_t));
+            printf("TCP timeout set to %u ms\n", conf.port_tcp.timeout);
+            return 0;
+        }
+        // TCP repeat
+        else if (strcmp(argv[1], "repeat") == 0)
+        {
+            long val = strtol(argv[2], NULL, 10);
+            if (val < 0 || val > 65535)
+            {
+                fprintf(stderr, "Error: repeat count must be between 0 and 65535\n");
+                return 1;
+            }
+            conf.port_tcp.repeate = (uint16_t)val;
+            jl_config_save("modbus", &conf, sizeof(jl_modbus_config_t));
+            printf("TCP repeat count set to %u\n", conf.port_tcp.repeate);
+            return 0;
+        }
+        else
+        {
+            fprintf(stderr, "Error: unknown TCP parameter '%s'\n", argv[1]);
+            return 1;
+        }
+    }
+    // Device address
     else if (strcmp(argv[0], "addr") == 0)
     {
-        fprintf(stderr, "TODO: Device address modification is not yet implemented\n");
+        if (argc < 2)
+        {
+            fprintf(stderr, "Error: address value required\n");
             return 1;
         }
-    // Active port - TODO
+
+        long val = strtol(argv[1], NULL, 10);
+        if (val < 1 || val > 247)
+        {
+            fprintf(stderr, "Error: device address must be between 1 and 247\n");
+            return 1;
+        }
+        conf.addr = (uint16_t)val;
+        jl_config_save("modbus", &conf, sizeof(jl_modbus_config_t));
+        printf("Device address set to %u\n", conf.addr);
+        return 0;
+    }
+    // Active port
     else if (strcmp(argv[0], "active_port") == 0)
     {
-        fprintf(stderr, "TODO: Active port switching is not yet implemented\n");
+        if (argc < 2)
+        {
+            fprintf(stderr, "Error: active_port value required (0=RS485, 1=TCP)\n");
             return 1;
         }
-    // Polling cycle - TODO
+
+        long val = strtol(argv[1], NULL, 10);
+        if (val < 0 || val > 1)
+        {
+            fprintf(stderr, "Error: active_port must be 0 (RS485) or 1 (TCP)\n");
+            return 1;
+        }
+        conf.num_port = (uint16_t)val;
+        jl_config_save("modbus", &conf, sizeof(jl_modbus_config_t));
+        printf("Active port set to %u (%s)\n", conf.num_port,
+               conf.num_port == 0 ? "RS485" : "TCP");
+        return 0;
+    }
+    // Polling cycle
     else if (strcmp(argv[0], "tcycle") == 0)
     {
-        fprintf(stderr, "TODO: Polling cycle modification is not yet implemented\n");
+        if (argc < 2)
+        {
+            fprintf(stderr, "Error: tcycle value required\n");
             return 1;
         }
+
+        long val = strtol(argv[1], NULL, 10);
+        if (val < 0 || val > 65535)
+        {
+            fprintf(stderr, "Error: polling cycle must be between 0 and 65535 ms\n");
+            return 1;
+        }
+        conf.tcycle = (uint16_t)val;
+        jl_config_save("modbus", &conf, sizeof(jl_modbus_config_t));
+        printf("Polling cycle set to %u ms\n", conf.tcycle);
+        return 0;
+    }
     else
     {
         fprintf(stderr, "Error: unknown parameter '%s'\n", argv[0]);

src/jlv135_cli/jl_block_secure.c

@@ -1,6 +1,8 @@
 #include <jl_modbus/jl_config.h>
 #include <jlv135_cli/jl_block_secure.h>
 #include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
 #include <stdint.h>
 #include <stdbool.h>
 
@@ -28,18 +30,93 @@ jl_block_secure_get(void)
     return 0;
 }
 
-// Метод set: заглушка (TODO)
+// Метод set: изменяет параметры блока secure
 int
 jl_block_secure_set(int argc, const char *argv[])
 {
-    (void)argc;
-    (void)argv;
-
-    fprintf(stderr, "TODO: Security configuration modification is not yet implemented\n");
-    fprintf(stderr, "Future usage examples:\n");
+    if (argc < 1)
+    {
+        fprintf(stderr, "Error: insufficient arguments for 'set secure'\n");
+        fprintf(stderr, "Usage:\n");
         fprintf(stderr, "  jlv135_cli set secure user_pass <password>\n");
         fprintf(stderr, "  jlv135_cli set secure service_pass <password>\n");
         fprintf(stderr, "  jlv135_cli set secure user_lock <on|off>\n");
-
+        fprintf(stderr, "  jlv135_cli set secure service_lock <on|off>\n");
         return 1;
+    }
+
+    jlv_secure_t conf = {};
+    jl_config_load("secure", &conf, sizeof(jlv_secure_t));
+
+    if (argc < 2)
+    {
+        fprintf(stderr, "Error: value required\n");
+        return 1;
+    }
+
+    // User password
+    if (strcmp(argv[0], "user_pass") == 0)
+    {
+        conf.user_pass = (uint32_t)strtoul(argv[1], NULL, 10);
+        jl_config_save("secure", &conf, sizeof(jlv_secure_t));
+        printf("User password set\n");
+        return 0;
+    }
+    // Service password
+    else if (strcmp(argv[0], "service_pass") == 0)
+    {
+        conf.service_pass = (uint32_t)strtoul(argv[1], NULL, 10);
+        jl_config_save("secure", &conf, sizeof(jlv_secure_t));
+        printf("Service password set\n");
+        return 0;
+    }
+    // User lock
+    else if (strcmp(argv[0], "user_lock") == 0)
+    {
+        if (strcmp(argv[1], "on") == 0 || strcmp(argv[1], "1") == 0)
+        {
+            conf.user_block = true;
+        }
+        else if (strcmp(argv[1], "off") == 0 || strcmp(argv[1], "0") == 0)
+        {
+            conf.user_block = false;
+        }
+        else
+        {
+            fprintf(stderr, "Error: invalid user_lock value '%s' (use on|off)\n", argv[1]);
+            return 1;
+        }
+
+        jl_config_save("secure", &conf, sizeof(jlv_secure_t));
+        printf("User lock %s\n", conf.user_block ? "enabled" : "disabled");
+        return 0;
+    }
+    // Service lock
+    else if (strcmp(argv[0], "service_lock") == 0)
+    {
+        if (strcmp(argv[1], "on") == 0 || strcmp(argv[1], "1") == 0)
+        {
+            conf.service_block = true;
+        }
+        else if (strcmp(argv[1], "off") == 0 || strcmp(argv[1], "0") == 0)
+        {
+            conf.service_block = false;
+        }
+        else
+        {
+            fprintf(stderr, "Error: invalid service_lock value '%s' (use on|off)\n", argv[1]);
+            return 1;
+        }
+
+        jl_config_save("secure", &conf, sizeof(jlv_secure_t));
+        printf("Service lock %s\n", conf.service_block ? "enabled" : "disabled");
+        return 0;
+    }
+    else
+    {
+        fprintf(stderr, "Error: unknown parameter '%s'\n", argv[0]);
+        return 1;
+    }
+
+    return 0;
 }

src/jlv135_cli/jl_block_sensor.c

@@ -1,6 +1,8 @@
 #include <jl_modbus/jl_config.h>
 #include <jlv135_cli/jl_block_sensor.h>
 #include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
 #include <stdint.h>
 
 typedef struct _jlv_sensor_t
@@ -27,18 +29,111 @@ jl_block_sensor_get(void)
     return 0;
 }
 
-// Метод set: заглушка (TODO)
+// Метод set: изменяет параметры блока sensor
 int
 jl_block_sensor_set(int argc, const char *argv[])
 {
-    (void)argc;
-    (void)argv;
-
-    fprintf(stderr, "TODO: Sensor configuration modification is not yet implemented\n");
-    fprintf(stderr, "Future usage examples:\n");
+    if (argc < 1)
+    {
+        fprintf(stderr, "Error: insufficient arguments for 'set sensor'\n");
+        fprintf(stderr, "Usage:\n");
         fprintf(stderr, "  jlv135_cli set sensor send_th <on|off>\n");
         fprintf(stderr, "  jlv135_cli set sensor send_p <on|off>\n");
         fprintf(stderr, "  jlv135_cli set sensor tk_delta <value>\n");
-
+        fprintf(stderr, "  jlv135_cli set sensor tnot_lin <value>\n");
         return 1;
+    }
+
+    jlv_sensor_t conf = {};
+    jl_config_load("sensor", &conf, sizeof(jlv_sensor_t));
+
+    // Send T/H
+    if (strcmp(argv[0], "send_th") == 0)
+    {
+        if (argc < 2)
+        {
+            fprintf(stderr, "Error: send_th value required (on|off)\n");
+            return 1;
+        }
+
+        if (strcmp(argv[1], "on") == 0 || strcmp(argv[1], "1") == 0)
+        {
+            conf.send_TH = 1;
+        }
+        else if (strcmp(argv[1], "off") == 0 || strcmp(argv[1], "0") == 0)
+        {
+            conf.send_TH = 0;
+        }
+        else
+        {
+            fprintf(stderr, "Error: invalid send_th value '%s' (use on|off)\n", argv[1]);
+            return 1;
+        }
+
+        jl_config_save("sensor", &conf, sizeof(jlv_sensor_t));
+        printf("Send T/H %s\n", conf.send_TH ? "enabled" : "disabled");
+        return 0;
+    }
+    // Send Pressure
+    else if (strcmp(argv[0], "send_p") == 0)
+    {
+        if (argc < 2)
+        {
+            fprintf(stderr, "Error: send_p value required (on|off)\n");
+            return 1;
+        }
+
+        if (strcmp(argv[1], "on") == 0 || strcmp(argv[1], "1") == 0)
+        {
+            conf.send_P = 1;
+        }
+        else if (strcmp(argv[1], "off") == 0 || strcmp(argv[1], "0") == 0)
+        {
+            conf.send_P = 0;
+        }
+        else
+        {
+            fprintf(stderr, "Error: invalid send_p value '%s' (use on|off)\n", argv[1]);
+            return 1;
+        }
+
+        jl_config_save("sensor", &conf, sizeof(jlv_sensor_t));
+        printf("Send Pressure %s\n", conf.send_P ? "enabled" : "disabled");
+        return 0;
+    }
+    // TK Delta
+    else if (strcmp(argv[0], "tk_delta") == 0)
+    {
+        if (argc < 2)
+        {
+            fprintf(stderr, "Error: tk_delta value required\n");
+            return 1;
+        }
+
+        conf.TK_delta = strtof(argv[1], NULL);
+        jl_config_save("sensor", &conf, sizeof(jlv_sensor_t));
+        printf("TK Delta set to %.3f\n", conf.TK_delta);
+        return 0;
+    }
+    // TNot Linear
+    else if (strcmp(argv[0], "tnot_lin") == 0)
+    {
+        if (argc < 2)
+        {
+            fprintf(stderr, "Error: tnot_lin value required\n");
+            return 1;
+        }
+
+        conf.TNot_lin = strtof(argv[1], NULL);
+        jl_config_save("sensor", &conf, sizeof(jlv_sensor_t));
+        printf("TNot Linear set to %.3f\n", conf.TNot_lin);
+        return 0;
+    }
+    else
+    {
+        fprintf(stderr, "Error: unknown parameter '%s'\n", argv[0]);
+        return 1;
+    }
+
+    return 0;
 }

src/jlv135_cli/jl_block_service.c

@@ -1,6 +1,8 @@
 #include <jl_modbus/jl_config.h>
 #include <jlv135_cli/jl_block_service.h>
 #include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
 #include <stdint.h>
 #include <stdbool.h>
 
@@ -58,18 +60,111 @@ jl_block_service_get(void)
     return 0;
 }
 
-// Метод set: заглушка (TODO)
+// Метод set: изменяет параметры блока service
 int
 jl_block_service_set(int argc, const char *argv[])
 {
-    (void)argc;
-    (void)argv;
-
-    fprintf(stderr, "TODO: Service configuration modification is not yet implemented\n");
-    fprintf(stderr, "Future usage examples:\n");
+    if (argc < 1)
+    {
+        fprintf(stderr, "Error: insufficient arguments for 'set service'\n");
+        fprintf(stderr, "Usage:\n");
         fprintf(stderr, "  jlv135_cli set service filter <1-4> min <value>\n");
         fprintf(stderr, "  jlv135_cli set service filter <1-4> max <value>\n");
         fprintf(stderr, "  jlv135_cli set service filter <1-4> duplex <on|off>\n");
-
+        fprintf(stderr, "  jlv135_cli set service filter <1-4> duplex_min <value>\n");
+        fprintf(stderr, "  jlv135_cli set service filter <1-4> duplex_max <value>\n");
         return 1;
+    }
+
+    jlv_service_t conf = {};
+    jl_config_load("service", &conf, sizeof(jlv_service_t));
+
+    // Filter configuration
+    if (strcmp(argv[0], "filter") == 0)
+    {
+        if (argc < 4)
+        {
+            fprintf(stderr, "Error: insufficient arguments for filter configuration\n");
+            fprintf(stderr, "Usage: jlv135_cli set service filter <1-4> <parameter> <value>\n");
+            return 1;
+        }
+
+        // Получаем номер фильтра (1-4)
+        long filter_num = strtol(argv[1], NULL, 10);
+        if (filter_num < 1 || filter_num > JL_FILTER_MAX)
+        {
+            fprintf(stderr, "Error: filter number must be between 1 and %d\n", JL_FILTER_MAX);
+            return 1;
+        }
+
+        int filter_idx = (int)filter_num - 1;
+
+        // Min value (single)
+        if (strcmp(argv[2], "min") == 0)
+        {
+            conf.filters[filter_idx].single.min_p = (uint16_t)strtoul(argv[3], NULL, 10);
+            jl_config_save("service", &conf, sizeof(jlv_service_t));
+            printf("Filter %ld min set to %u\n", filter_num, conf.filters[filter_idx].single.min_p);
+            return 0;
+        }
+        // Max value (single)
+        else if (strcmp(argv[2], "max") == 0)
+        {
+            conf.filters[filter_idx].single.max_p = (uint16_t)strtoul(argv[3], NULL, 10);
+            jl_config_save("service", &conf, sizeof(jlv_service_t));
+            printf("Filter %ld max set to %u\n", filter_num, conf.filters[filter_idx].single.max_p);
+            return 0;
+        }
+        // Duplex mode
+        else if (strcmp(argv[2], "duplex") == 0)
+        {
+            if (strcmp(argv[3], "on") == 0 || strcmp(argv[3], "1") == 0)
+            {
+                conf.filters[filter_idx].duplex_filter = true;
+            }
+            else if (strcmp(argv[3], "off") == 0 || strcmp(argv[3], "0") == 0)
+            {
+                conf.filters[filter_idx].duplex_filter = false;
+            }
+            else
+            {
+                fprintf(stderr, "Error: invalid duplex value '%s' (use on|off)\n", argv[3]);
+                return 1;
+            }
+            jl_config_save("service", &conf, sizeof(jlv_service_t));
+            printf("Filter %ld duplex mode %s\n", filter_num,
+                   conf.filters[filter_idx].duplex_filter ? "enabled" : "disabled");
+            return 0;
+        }
+        // Min value (duplex)
+        else if (strcmp(argv[2], "duplex_min") == 0)
+        {
+            conf.filters[filter_idx].duplex.min_p = (uint16_t)strtoul(argv[3], NULL, 10);
+            jl_config_save("service", &conf, sizeof(jlv_service_t));
+            printf("Filter %ld duplex min set to %u\n", filter_num,
+                   conf.filters[filter_idx].duplex.min_p);
+            return 0;
+        }
+        // Max value (duplex)
+        else if (strcmp(argv[2], "duplex_max") == 0)
+        {
+            conf.filters[filter_idx].duplex.max_p = (uint16_t)strtoul(argv[3], NULL, 10);
+            jl_config_save("service", &conf, sizeof(jlv_service_t));
+            printf("Filter %ld duplex max set to %u\n", filter_num,
+                   conf.filters[filter_idx].duplex.max_p);
+            return 0;
+        }
+        else
+        {
+            fprintf(stderr, "Error: unknown filter parameter '%s'\n", argv[2]);
+            return 1;
+        }
+    }
+    else
+    {
+        fprintf(stderr, "Error: unknown parameter '%s'\n", argv[0]);
+        return 1;
+    }
+
+    return 0;
 }

src/jlv135_cli/jl_block_wifi.c

@@ -27,18 +27,85 @@ jl_block_wifi_get(void)
     return 0;
 }
 
-// Метод set: заглушка (TODO)
+// Метод set: изменяет параметры блока wifi
 int
 jl_block_wifi_set(int argc, const char *argv[])
 {
-    (void)argc;
-    (void)argv;
-
-    fprintf(stderr, "TODO: WiFi configuration modification is not yet implemented\n");
-    fprintf(stderr, "Future usage examples:\n");
+    if (argc < 1)
+    {
+        fprintf(stderr, "Error: insufficient arguments for 'set wifi'\n");
+        fprintf(stderr, "Usage:\n");
         fprintf(stderr, "  jlv135_cli set wifi ssid <network_name>\n");
         fprintf(stderr, "  jlv135_cli set wifi password <password>\n");
         fprintf(stderr, "  jlv135_cli set wifi enable <on|off>\n");
-
         return 1;
+    }
+
+    jlv_wifi_t conf = {};
+    jl_config_load("wifi", &conf, sizeof(jlv_wifi_t));
+
+    // SSID
+    if (strcmp(argv[0], "ssid") == 0)
+    {
+        if (argc < 2)
+        {
+            fprintf(stderr, "Error: SSID value required\n");
+            return 1;
+        }
+
+        strncpy(conf.ssid, argv[1], JLV_WIFI_SSID_BYTES - 1);
+        conf.ssid[JLV_WIFI_SSID_BYTES - 1] = '\0';
+        jl_config_save("wifi", &conf, sizeof(jlv_wifi_t));
+        printf("WiFi SSID set to: %s\n", conf.ssid);
+        return 0;
+    }
+    // Password
+    else if (strcmp(argv[0], "password") == 0)
+    {
+        if (argc < 2)
+        {
+            fprintf(stderr, "Error: password value required\n");
+            return 1;
+        }
+
+        strncpy(conf.password, argv[1], sizeof(conf.password) - 1);
+        conf.password[sizeof(conf.password) - 1] = '\0';
+        jl_config_save("wifi", &conf, sizeof(jlv_wifi_t));
+        printf("WiFi password set\n");
+        return 0;
+    }
+    // Enable/Disable
+    else if (strcmp(argv[0], "enable") == 0)
+    {
+        if (argc < 2)
+        {
+            fprintf(stderr, "Error: enable value required (on|off)\n");
+            return 1;
+        }
+
+        if (strcmp(argv[1], "on") == 0 || strcmp(argv[1], "1") == 0)
+        {
+            conf.enable = true;
+        }
+        else if (strcmp(argv[1], "off") == 0 || strcmp(argv[1], "0") == 0)
+        {
+            conf.enable = false;
+        }
+        else
+        {
+            fprintf(stderr, "Error: invalid enable value '%s' (use on|off)\n", argv[1]);
+            return 1;
+        }
+
+        jl_config_save("wifi", &conf, sizeof(jlv_wifi_t));
+        printf("WiFi %s\n", conf.enable ? "enabled" : "disabled");
+        return 0;
+    }
+    else
+    {
+        fprintf(stderr, "Error: unknown parameter '%s'\n", argv[0]);
+        return 1;
+    }
+
+    return 0;
 }