tmp

fw/modules/log/log.c

@@ -6,6 +6,7 @@
 #include "task.h"
 #include "semphr.h"
 #include "rtc.h"
+#include "settings_api.h"
 #include <string.h>
 #include <stdio.h>
 #include <inttypes.h>
@@ -13,6 +14,8 @@
 #undef DBG
 #define DBG if(1)
 
+static bool archive_state = true;
+static bool log_state = true;
 
 struct ringfs fs_log;
 struct ringfs fs_archive;
@@ -325,15 +328,45 @@ void test_fetch(void)
     printf("[entry] timestamp = % " PRId64 ", value = %u, crc = %u\r\n", entry.timestamp, entry.input_value, entry.crc);
 }
 
+//
+void log_archive_state(bool state)
+{
+    archive_state = state;
+}
 
+//
+void log_log_state(bool state)
+{
+    log_state = state;
+}
 
 
 void log_task(void *params)
 {
+    int ret = 0;
+    archive_entry_t entry = {0};
+    
     for (;;)
     {
-        vTaskDelay(1000);
-
+        if (!archive_state) {
+            vTaskDelay(1000);
+            continue;
+        }
+        
+        entry.input_value = (uint8_t)input_state_bit;
+        
+        DBG printf("Append archive entry...");
+        
+        ret = log_append((void*)&entry, ARCHIVE_ENTRY);
+              
+        if (ret != 0) {
+            DBG printf("FAIL\r\n");
+        }
+        else {
+            DBG printf("OK\r\n");
+        }
+        
+        vTaskDelay(settings.period_archive*1000);
     }
 }
 

fw/modules/log/log.h

@@ -134,6 +134,12 @@ int log_add_random_entry(uint8_t val, uint32_t cnt_entry);
 //
 void test_fetch(void);
 
+//
+void log_archive_state(bool state);
+
+//
+void log_log_state(bool state);
+
 //
 void test_archive_format(void);
 

fw/modules/misc/rtc.c

@@ -393,6 +393,13 @@ uint32_t rtc_foo(void)
     return tmr_counter_value_get(TMR5);
 }
 
+//
+void rtc_set_in_ms(uint64_t ms)
+{
+    TM_RTC_SetDataTimeUnix(ms);
+    
+}
+
 //
 void TMR5_GLOBAL_IRQHandler(void)
 {

fw/modules/misc/rtc.h

@@ -77,4 +77,7 @@ uint64_t rtc_get_ms(void);
 //
 uint32_t rtc_foo(void);
 
+//
+void rtc_set_in_ms(uint64_t ms);
+
 #endif

fw/modules/misc/swap.c

@@ -0,0 +1,43 @@
+#include "swap.h"
+
+
+// 
+uint16_t swap_uint16(uint16_t val) 
+{
+    return (val << 8) | (val >> 8 );
+}
+
+//
+int16_t swap_int16(int16_t val) 
+{
+    return (val << 8) | ((val >> 8) & 0xFF);
+}
+
+//
+uint32_t swap_uint32(uint32_t val)
+{
+    val = ((val << 8) & 0xFF00FF00 ) | ((val >> 8) & 0xFF00FF ); 
+    return (val << 16) | (val >> 16);
+}
+
+//
+int32_t swap_int32(int32_t val)
+{
+    val = ((val << 8) & 0xFF00FF00) | ((val >> 8) & 0xFF00FF ); 
+    return (val << 16) | ((val >> 16) & 0xFFFF);
+}
+
+//
+int64_t swap_int64(int64_t val)
+{
+    val = ((val << 8) & 0xFF00FF00FF00FF00ULL ) | ((val >> 8) & 0x00FF00FF00FF00FFULL );
+    val = ((val << 16) & 0xFFFF0000FFFF0000ULL ) | ((val >> 16) & 0x0000FFFF0000FFFFULL );
+    return (val << 32) | ((val >> 32) & 0xFFFFFFFFULL);
+}
+
+uint64_t swap_uint64(uint64_t val)
+{
+    val = ((val << 8) & 0xFF00FF00FF00FF00ULL ) | ((val >> 8) & 0x00FF00FF00FF00FFULL );
+    val = ((val << 16) & 0xFFFF0000FFFF0000ULL ) | ((val >> 16) & 0x0000FFFF0000FFFFULL );
+    return (val << 32) | (val >> 32);
+}

fw/modules/misc/swap.h

@@ -0,0 +1,26 @@
+#ifndef __SWAP_H
+#define __SWAP_H
+
+#include "at32f403a_407.h"
+
+//
+uint16_t swap_uint16(uint16_t val);
+
+//
+int16_t swap_int16(int16_t val);
+
+//
+uint32_t swap_uint32(uint32_t val);
+
+//
+int32_t swap_int32(int32_t val);
+
+//
+int64_t swap_int64(int64_t val);
+
+//
+uint64_t swap_uint64(uint64_t val);
+
+
+
+#endif /* #ifndef __SWAP_H */

fw/modules/modbus/modbus_params.c

@@ -8,10 +8,10 @@
 #include "log.h"
 #include "settings_api.h"
 #include "common_config.h"
+#include "swap.h"
 #include <string.h>
 
 
-
 mb_param_t mb_param[MB_PARAM_MAX];
 
 uint32_t rtc_sinhro;
@@ -22,13 +22,14 @@ bool psw_ok = false;
 uint8_t fw_version[8];
 uint16_t save_sys_cmd = 0;  // Команда сохранения системных настроек
 uint16_t system_cmd = 0;	// Команда управления контроллером
+uint64_t value_64 = 0;
 
 void get_time(uint8_t* buf, uint8_t size);
 void get_din_mode(uint8_t* buf, uint8_t size);
 
 void get_log_entries_number(uint8_t* buf, uint8_t size);
 void get_archive_entries_number(uint8_t* buf, uint8_t size);
-
+void get_rtc(uint8_t* buf, uint8_t size);
 
 
 
@@ -201,6 +202,26 @@ void mb_init_params(void)
     
     index++;
     
+    // uptime
+    mb_param[index].reg = 0x0801;
+	mb_param[index].size = 2;
+	mb_param[index].param = (uint8_t*)&uptime; // 
+	mb_param[index].set = NULL;
+    mb_param[index].get = NULL;
+    mb_param[index].check_handler = mb_check_dummy;
+    
+    index++;
+    
+    // RTC
+    mb_param[index].reg = 0x0803;
+	mb_param[index].size = 4;
+	mb_param[index].param = (uint8_t*)&value_64; // 
+	mb_param[index].set = mb_set_rtc;
+    mb_param[index].get = get_rtc;
+    mb_param[index].check_handler = mb_check_dummy;
+    
+    index++;
+    
     // ---------------------------------------------------------------------- //
     // Журналы/рахивы
     // ---------------------------------------------------------------------- //
@@ -412,6 +433,7 @@ void mb_get_param(uint8_t *buf, uint16_t index)
 //                          Чтение параметров
 // -------------------------------------------------------------------------- //
 
+#if 0
 void get_time(uint8_t* buf, uint8_t size)
 {
     uint32_t rtc_unix = RTC_GetUnixTime();
@@ -424,6 +446,9 @@ void get_time(uint8_t* buf, uint8_t size)
 		ptr--;
 	}
 }
+#endif
+
+
 
 //
 void get_din_mode(uint8_t* buf, uint8_t size)
@@ -434,17 +459,30 @@ void get_din_mode(uint8_t* buf, uint8_t size)
 //
 void get_log_entries_number(uint8_t* buf, uint8_t size)
 {
-    uint16_t capacity = log_capacity();
-    SWAP_16(buf, capacity);
+    static uint16_t capacity;
+    
+    capacity = swap_uint16(log_capacity());
+    
+    buf = (uint8_t*)&capacity;
 }
 
 //
 void get_archive_entries_number(uint8_t* buf, uint8_t size)
 {
-    uint16_t capacity = log_arch_capacity();
-    SWAP_16(buf, capacity);
+    static uint16_t capacity;
+      
+    capacity = swap_uint16(log_arch_capacity());
+    
+    buf = (uint8_t*)&capacity;
 }
 
+//
+void get_rtc(uint8_t* buf, uint8_t size)
+{
+    uint64_t rtc = swap_uint64(rtc_get_ms());
+        
+    memcpy(buf, &rtc, 8);
+}
 
 // -------------------------------------------------------------------------- //
 //                          Установка параметров
@@ -526,6 +564,13 @@ mb_delay_action_t mb_control(void)
 #endif    
 }
 
+//
+mb_delay_action_t mb_set_rtc(void)
+{
+    rtc_set_in_ms((uint32_t)(value_64/1000));
+    return MB_NO_ACTION;
+}
+
 // -------------------------------------------------------------------------- //
 //                      Проверка параметров                                   //
 // -------------------------------------------------------------------------- //

fw/modules/modbus/modbus_params.h

@@ -11,10 +11,8 @@
 extern "C" {
 #endif
 
-
-#define SWAP_16(x, y)   {x[0] = y >> 8; x[1] = y & 0x0FF;}
   
-#define MB_PARAM_MAX			69 //54
+#define MB_PARAM_MAX			71 //54
 
 
 //
@@ -79,6 +77,8 @@ mb_delay_action_t mb_sys_settings_save(void);
 //
 mb_delay_action_t mb_control(void);
 
+//
+mb_delay_action_t mb_set_rtc(void);
 
 // -------------------------------------------------------------------------- //
 //                      Проверка параметров                                   //

fw/modules/terminal/terminal_sbs.cpp

@@ -109,8 +109,19 @@ int SbsTerminal::execute(int argc, const char * const *argv)
         log_get_archive_entry(atoi(argv[1]), &fs_archive, &archive_entry);
         return 0;
     }
+    //
+    if (strcmp(argv[0], "lstate") == 0) {
+        log_log_state(atoi(argv[1]));
+        return 0;
+    }
+    //
+    if (strcmp(argv[0], "astate") == 0) {
+        log_archive_state(atoi(argv[1]));
+        return 0;
+    }
     // ---------------------------------------------------------------------- //
     if (strcmp(argv[0], "mstime") == 0) {
+        TM_RTC_PrintTime();
         printf("\r\n%" PRId64 " [ms]\r\n", rtc_get_ms());
         return 0;
     }
@@ -160,6 +171,9 @@ int SbsTerminal::help(int argc, const char * const *argv)
     printl ("  aentry         Get archive entry [position] [sector] [slot]");
     printl ("  lformat        Format log partition");
     printl ("  aformat        Format archive partition");
+    printl ("  lstate         log enable/disable");
+    printl ("  astate         archive enable/disable");
+    printl ("  mstime         gurrnet rtc in ms");
     printl ("  settings       Print settings structure");
     
     printeol();

fw/user/main.cpp

@@ -33,6 +33,7 @@ extern "C" {
 #include "analog_input.h"
 #include "dac_transport.h"
 #include "log.h"
+#include "swap.h"
 }
 #include "terminal_sbs.h"
 #include "terminal_usartbridge.h"
@@ -114,7 +115,8 @@ int main(void)
 
 void init_task(void *argument)
 {
-    // Для теста
+// -------------------------------------------------------------------------- //    
+// Для теста
     //sys_clear();
     
 // -------------------------------------------------------------------------- //    

project/ewarm/module_universal_io.ewp

@@ -2221,6 +2221,9 @@
                 <file>
                     <name>$PROJ_DIR$\..\..\fw\modules\misc\rtc.c</name>
                 </file>
+                <file>
+                    <name>$PROJ_DIR$\..\..\fw\modules\misc\swap.c</name>
+                </file>
                 <file>
                     <name>$PROJ_DIR$\..\..\fw\modules\misc\uptime.c</name>
                 </file>

project/ewarm/module_universal_io.ewt

@@ -2432,6 +2432,9 @@
                 <file>
                     <name>$PROJ_DIR$\..\..\fw\modules\misc\rtc.c</name>
                 </file>
+                <file>
+                    <name>$PROJ_DIR$\..\..\fw\modules\misc\swap.c</name>
+                </file>
                 <file>
                     <name>$PROJ_DIR$\..\..\fw\modules\misc\uptime.c</name>
                 </file>

tools/digital_io.py

@@ -5,7 +5,8 @@ import log_reader
 import colorama
 from colorama import Fore
 from time import sleep
-
+import time
+from datetime import datetime, timedelta, timezone
 
 class IO_Digital(IO_Module):
     def __init__(self, tty: str, brate: int, address: int):
@@ -22,14 +23,18 @@ def main():
     dev.MB_DEBUG = False
 
     '''Системные переменные и параметры'''
-    # dev.sys.set_system_vars(1234)
     dev.sys.get_system_vars()
+
+    ''' Установить текущее время с учетом часового пояса'''
+    dev.sys.set_rtc()     
     
+
     '''Лог и архив. Настройки лога.'''
-    dev.log.get_log_info()
-    dev.log.get_random_entries()
+    # dev.log.get_log_info()
+    # dev.log.get_random_entries()
     # dev.log.set_archive_period(10)
-    
+    # dev.log.get_all_archive()
+
     '''Сохранение настроек'''
     # dev.sys.save_sattings()
     

tools/log_reader.py

@@ -48,6 +48,10 @@ class DigitalLogReader(LogReader):
     def get_archive(self):
         print("DigitalLogReader")
 
+    def get_archive_entry(self, index):
+        data = self.modbus.read_file_record(ARCHIVE_ENTRY, index, 1)        
+        return struct.unpack('<QBB', data[5:15])
+        
     def get_random_archive_entry(self):
         data = self.modbus.read_file_record(ARCHIVE_ENTRY, randint(1, self.archive_entries_number), 1)
         entry = struct.unpack('<QBB', data[5:15])
@@ -67,6 +71,13 @@ class DigitalLogReader(LogReader):
             self.get_random_log_entry()
             sleep(0.1)
 
+    def get_all_archive(self):
+        self.get_log_info()
+        for i in range(1, self.archive_entries_number + 1):
+            print(self.get_archive_entry(i))
+            sleep(0.1)
+
+
 
 
 class AnalogInputLogReader(LogReader):
@@ -82,7 +93,7 @@ def main():
 
     module = DigitalLogReader('COM24', 115200, 15)
 
-    module.get_log_info()
+    # module.get_log_info()
     # module.get_archive()
     # module.set_archive_period(10)
 

tools/mb_registers.py

@@ -1,7 +1,8 @@
 reg_table = {'in_bits': 0x0100, 'in_cnt': 0x0102, 'in_mode': 0x0120, 'in_norm': 0x0122, 'in_deb_start': 0x124,
              'out_cur': 0x0200, 'out_mode': 0x0202, 'out_mode_save': 0x0203, 'pwm_duty': 0x0210,
              'pwm_duty_save': 0x0220, 'pwm_per': 0x0230, 'pwm_per_save': 0x0240,
-             'param_manager': 0x0800, 'rtc_unix': 0x0802, 'rtc_sinhro': 0x0804, 'uptime': 0x0800, 'log_info': 0x0900, 
+             'param_manager': 0x0800, 'rtc_unix': 0x0802, 'rtc_sinhro': 0x0804, 'uptime': 0x0801, 
+             'rtc': 0x0803, 'log_info': 0x0900, 
              'log_ent': 0x0901, 'arch_cap': 0x0902, 'arch_ent': 0x0903, 'archive_per': 0x0904,
              'model': 0x0080, 'prod_date': 0x0081, 'serial_number': 0x0083, 'fw_ver': 0x0085, 
              'test_status': 0x0089, 'password': 0x008A, 'save_sys_settings': 0x008B}

tools/modbus.py

@@ -149,6 +149,10 @@ class Modbus(ModbusMixin):
         """Read 32-bit integer from holding registers"""
         return struct.unpack('>I', self.read_holding_registers_raw(address, 2))[0]
 
+    def read_uint64_holding(self, address: int) -> int:
+        """Read 64-bit integer from holding registers"""
+        return struct.unpack('>Q', self.read_holding_registers_raw(address, 4))[0]        
+
     # 0x10
     def write_holding_registers_raw(self, address:int, values: bytes):
         """Write 16-bit integers to holding registers on device"""
@@ -185,6 +189,10 @@ class Modbus(ModbusMixin):
         """Write 32-bit integer to holding register"""
         self.write_holding_registers_raw(address, struct.pack('>I', value))
 
+    def write_uint64(self, address: int, value: int):
+        """Write 64-bit integer to holding register"""
+        self.write_holding_registers_raw(address, struct.pack('>Q', value))
+
     def test_send(self, data: bytes):
         while True:
             self.serial.write(data)

tools/sys_params.py

@@ -1,9 +1,9 @@
-"""Модуль для работы с сис"""
 from modbus import Modbus
 from mb_registers import reg_table
 from colorama import Fore
 import time
 import random
+from datetime import datetime, timedelta, timezone
 
 models = {0x100: 'MDIO_88', 0x200: 'MAO_8', 0x300: 'MAI_12'}
 test_state = {0: 'No Test', 1: 'Test OK', 2: 'Test FAIL'}
@@ -21,6 +21,10 @@ class IO_SysParams:
         self.SAVE_SYS_SETTINGS = 0x0001
         self.SAVE_SETTIGNS = 0x0001
 
+        t = datetime.now(timezone.utc).astimezone()
+        self.utc_offset = t.utcoffset() // timedelta(seconds=1)
+        
+
     def get_system_vars(self):
         """Запрос системных настроек и параметров"""
 
@@ -54,7 +58,11 @@ class IO_SysParams:
         # Статус тестирования
         status = self.modbus.read_holding_registers(reg_table['test_status'], 1)[0]
         print("Test status: ", Fore.LIGHTMAGENTA_EX + test_state[status])
-        print('\n')
+
+        # Локальное время модуля
+        t = time.ctime(self.get_rtc()/1000 - self.utc_offset)
+        print("Local time : ", Fore.LIGHTMAGENTA_EX + t)
+        
 
     def set_system_vars(self, password: int):
         """Установка системных настроек"""
@@ -81,10 +89,19 @@ class IO_SysParams:
         print("Save system settings...")
         self.modbus.write_holding_register(reg_table['save_sys_settings'], self.SAVE_SYS_SETTINGS)
 
-
     def save_sattings(self):
         self.modbus.write_holding_register(reg_table['param_manager'], self.SAVE_SETTIGNS)
 
+    def get_uptime(self):
+        return self.modbus.read_uint32_holding(reg_table['uptime'])
+
+    def get_rtc(self):
+        return self.modbus.read_uint64_holding(reg_table['rtc'])
+
+    def set_rtc(self):
+        """Установить текущее время"""
+        t = int((time.time() + self.utc_offset) * 1000)
+        self.modbus.write_uint64(reg_table['rtc'], t)
 
 # def set_manager_register(dev: IO_Module, commands: list):
 #     foo = 0

tools/time_test.py

@@ -0,0 +1,28 @@
+import time
+from datetime import datetime, timedelta, timezone
+
+def main():
+    '''
+    seconds = time.time()
+    print(int(seconds))
+
+    # Local time
+    local_time = time.ctime(time.time())
+    print(type(local_time))
+    print(local_time)
+    print(time.localtime())
+    '''
+
+    '''
+    print(timezone.utc)
+    d = datetime.now(timezone.utc).astimezone()
+    print(d)
+    utc_offset = d.utcoffset() // timedelta(seconds=1)
+    print(utc_offset)
+    '''
+
+    
+    print(f'RTC: {time.ctime(1722011409)}. Unix time stamp:')
+
+if __name__ == '__main__':
+    main()