Channel Simulation Software Logging System

Abstract

The present invention relates to a channel simulation software log recording system, comprising a log storage module for storing log information generated during operation in a text-formatted log file in the form of a character string; a log core component library, comprising a public interface class for external calls and a standard output stream cache interceptor; a simulation control program module for loading the log core component library; a log display module for real-time scrolling display of current log information; a simulation control business module for realizing various channel simulation functions through a channel simulator; and using standard output stream output information to complete log storage and display. The channel simulation software log recording system of the present invention can greatly reduce the complexity of software development, greatly improve the efficiency of software development, make the log function of the simulation control software more complete and unified, and can simultaneously display real-time log information in files and software interfaces, making software interaction more friendly.

Description

Technical Field

[0001] The present invention relates to the field of communication scenarios, in particular to the field of channel simulators, and specifically refers to a channel simulation software log recording system. Background Art

[0002] 1. Basic concepts of channel simulator

[0003] A channel simulator is a device that simulates the channel environment in a communication scenario. It can simulate characteristics such as multipath fading, noise interference, Doppler frequency deviation, and propagation path loss in a real channel. It can make the complex wireless channel environment repeatable and controllable in the laboratory, meeting various test requirements for communication equipment and systems.

[0004] 2. Simulation control software of channel simulator

[0005] The general usage of the channel simulator includes several steps:

[0006] ① Set up the test environment. Connect the communication device to be tested to the port of the channel simulator.

[0007] ② Start the channel simulator, and input and set the channel characteristic parameters to be simulated in the human-computer interaction interface of the channel simulator.

[0008] ③Generate channel coefficient data and load the data into the hardware circuit of the channel simulator.

[0009] ④Start running channel simulation and control the simulation to pause, continue or stop.

[0010] ⑤ Collect and analyze data. During the channel simulation process, collect data such as the bit error rate, signal-to-noise ratio, and throughput rate to evaluate the performance of the device under test.

[0011] In the above steps, the human-computer interaction interface for setting channel characteristic parameters, generating channel coefficients, and running channel simulation is the simulation control software.

[0012] The simulation control software is a desktop software developed in a high-level programming language. In addition to setting channel characteristic parameters and controlling the simulation running status, it also has an important log function. The log function can record and display various prompts, errors, warnings and debugging information during system operation. Through log recording, users and related technical personnel can track the operation of the application. When problems occur, it is convenient to locate, troubleshoot and solve the problems, and improve the performance and stability of the channel simulator.

[0013] 3. General logging and output implementation methods and existing problems

[0014] There are generally three ways to implement the logging function of simulation control software: one is to use the basic console output in the programming language, the second is to write files to achieve it, and the third is to integrate some mature logging components in the industry into the software, such as Log4cpp, Boost.Log, Easylogging++, etc.

[0015] However, there are several important problems in implementing the log function using the above three methods:

[0016] (1) The log output by the console cannot be recorded and displayed when the program is started with a non-command line.

[0017] (2) When recording logs by writing files, you cannot view the logs in real time on the running interface. You need to open the file separately to view the logs.

[0018] (3) When using mature log components in the industry, you must reference the log component library in the source code and write specific output log code. Due to the complexity of the channel simulator simulation control software, the software consists of an exe and several dynamic link libraries. Different dynamic link libraries may come from different developers or organizations. It cannot be ensured that all dynamic link libraries can reference the log component. Therefore, when a DLL does not reference the log component, it will not be able to record the log correctly. If all modules of the entire simulation control software are equipped with log functions, a lot of programming work is required.

[0019] (4) When simulation control software relies on some third-party dynamic libraries, if these dynamic libraries do not have logging functions, it is impossible to add logging functions to them. Summary of the invention

[0020] The purpose of the present invention is to overcome the shortcomings of the above-mentioned prior art and provide a channel simulation software log recording system which is simple to operate, has high development efficiency and a wide range of applications.

[0021] In order to achieve the above object, the channel simulation software log recording system of the present invention is as follows:

[0022] The channel simulation software log recording system has the following main features:

[0023] The log storage module is used to store the log information generated during the operation in the form of a string in a text-formatted log file;

[0024] The log core component library is connected to the log storage module and includes a public interface class for external calls and a standard output stream cache interceptor;

[0025] A simulation control program module is connected to the log core component library and is used to load the log core component library;

[0026] A log display module, connected to the simulation control program module, for scrolling and displaying the current log information in real time;

[0027] The simulation control service module is connected with the simulation control program module and is used to realize various channel simulation functions through the channel simulator; and complete the storage and display of the log by outputting information through the standard output stream.

[0028] Preferably, each time the log storage module generates a log at runtime, it creates or opens a log file named with the current date and the maximum serial number in the Logs folder according to the current system date, and appends the generated new log to the file; when the file does not exist or the file size exceeds a predetermined size limit, a new log file is created using the rule of increasing the serial number, and the log is appended to the file.

[0029] Preferably, the public interface class of the log core component library initializes the log environment according to the parameters of the incoming log; creates a standard output stream cache interceptor class object to intercept the standard output of each module of the simulation control software; writes the intercepted log into the log file according to the log storage rules; when the simulation control software generates a log, transmits a message to the user interface and displays the log in real time.

[0030] Preferably, the standard output stream cache interceptor of the log core component library replaces the streambuf object, rewrites the buffer object of the standard output stream through a redirection method, and intercepts the output content; after the log is intercepted, it is notified to the component library public interface object in the form of a message, and the public interface object writes the log to the file, and at the same time passes the message to the UI part, and the log is displayed in real time on the interface.

[0031] Preferably, the simulation control program module creates a public interface object of the log core component in the entry main() function, and uses the directory where the main program is located as the log file storage location as the entry parameter of the public interface object constructor.

[0032] Preferably, the log display module defines a function, which is bound to the public interface object of the log core component in the form of a callback function. When the public interface object generates logs in real time, the received log information is displayed on the user interface through the callback function.

[0033] The channel simulation software log recording system of the present invention can greatly reduce the complexity of software development, greatly improve the efficiency of software development, make the log function of the simulation control software more complete and unified, and can display real-time log information in files and software interfaces at the same time, making software interaction more friendly. BRIEF DESCRIPTION OF THE DRAWINGS

[0034] Figure 1 It is a schematic diagram of the architecture of the channel simulation software logging system of the present invention.

[0035] Figure 2 The diagram is a schematic diagram of the working principle of the C++ standard output stream of the channel simulation software log recording system of the present invention.

[0036] Figure 3 The present invention is a schematic diagram of the working process of the log core component library of the channel simulation software log recording system.

[0037] Figure 4 This is a schematic diagram of the dependency relationship between modules when the channel simulation software logging system of the present invention uses Log4Cpp as a log component.

[0038] Figure 5 This is a schematic diagram of the dependency relationship between modules of the channel simulation software log recording system of the present invention when the solution of the present invention is adopted.

[0039] Figure 6 The present invention is a schematic diagram of the log storage module structure of the channel simulation software log recording system.

[0040] Figure 7 It is a schematic diagram of the log core component library structure of the channel simulation software log recording system of the present invention. DETAILED DESCRIPTION

[0041] In order to more clearly describe the technical content of the present invention, further description is given below in conjunction with specific embodiments.

[0042] The channel simulation software log recording system of the present invention comprises:

[0043] The log storage module is used to store the log information generated during the operation in the form of a string in a text-formatted log file;

[0044] The log core component library is connected to the log storage module and includes a public interface class for external calls and a standard output stream cache interceptor;

[0045] A simulation control program module is connected to the log core component library and is used to load the log core component library;

[0046] A log display module, connected to the simulation control program module, for scrolling and displaying the current log information in real time;

[0047] The simulation control service module is connected with the simulation control program module and is used to realize various channel simulation functions through the channel simulator; and complete the storage and display of the log by outputting information through the standard output stream.

[0048] As a preferred embodiment of the present invention, each time the log storage module generates a log at runtime, it creates or opens a log file named with the current date and the maximum serial number in the Logs folder according to the current system date, and appends the generated new log to the file; when the file does not exist or the file size exceeds the predetermined size limit, a new log file is created using the rule of increasing the serial number, and the log is appended to the file.

[0049] As a preferred embodiment of the present invention, the public interface class of the log core component library initializes the log environment according to the parameters of the incoming log; creates a standard output stream cache interceptor class object to intercept the standard output of each module of the simulation control software; writes the intercepted log into the log file according to the log storage rules; when the simulation control software generates a log, transmits a message to the user interface and displays the log in real time.

[0050] As a preferred embodiment of the present invention, the standard output stream cache interceptor of the log core component library replaces the streambuf object, rewrites the buffer object of the standard output stream through a redirection method, and intercepts the output content; after the log is intercepted, it is notified to the component library public interface object in the form of a message, and the public interface object writes the log to the file, and at the same time passes the message to the UI part, and displays the log in real time on the interface.

[0051] As a preferred embodiment of the present invention, the simulation control program module creates a public interface object of the log core component in the entry main() function, and uses the directory where the main program is located as the log file storage location as the entry parameter of the public interface object constructor.

[0052] As a preferred embodiment of the present invention, the log display module defines a function, which is bound to the public interface object of the log core component in the form of a callback function. When the public interface object generates logs in real time, the received log information is displayed on the user interface through the callback function.

[0053] In the specific implementation of the present invention, the problem to be solved is:

[0054] (1) During the use of the channel simulator, the log files can be saved and the log information can be viewed in real time in the simulation control software interface.

[0055] (2) In the process of simulation control software development, the amount of log code can be reduced to the greatest extent possible. There is no need for each functional module to rely on and reference the log module, and there is no need to write specific log output code.

[0056] (3) Try to make all dependent third-party dynamic libraries have unified logging functions.

[0057] The present invention is an efficient channel simulation software log recording method and system, which mainly consists of the following Figure 1 As shown, it includes the following important parts:

[0058] 1. Log storage module.

[0059] (1) The log files of the channel simulator are stored in the Logs subfolder under the directory where the simulation control program module is located.

[0060] (2) The log information generated by the channel simulator simulation control software during operation is stored in a text-formatted log file in the form of a string.

[0061] (3) The log file consists of multiple files, and the file names are named according to a specific rule: "Log_YYYYMMDD_N.txt", where YYYYMMDD indicates the current system date and N is a serial number.

[0062] (4) Each time a log is generated during the operation of the simulation control software, a log file named with the current date and the maximum serial number is created or opened in the Logs folder according to the current system date, and the new log is appended to the file. If the file does not exist or the file size exceeds the preset size limit, a new log file is created using the rule of increasing the serial number, and then the log is appended to the file.

[0063] 2. Log core component library.

[0064] The log core component library is a dynamic link library (DLL) developed based on C++ language. It mainly includes two important parts: one is the public interface class for external calls, and the other is the standard output stream cache interceptor of the simulation control software.

[0065] (1) The functions of the public interface class include:

[0066] ① It is created and called by the simulated control program module, and the log environment is initialized according to parameters such as the storage path of the incoming log and the maximum size limit of the log file.

[0067] ② Create a standard output stream cache interceptor class object and start intercepting the standard output of each module of the simulation control software.

[0068] ③Write the intercepted logs into the log file according to the log storage rules.

[0069] ④When the simulation control software generates a log, it transmits a message to the user interface and displays the log in real time.

[0070] (2) The standard output stream cache interceptor is inherited from the standard C++ library<streambuf.h> The streambuf class is the buffer class of the C++ standard output stream. When the standard output stream performs output, it must pass through the streambuf object before the content can be output to the final device. Its principle and process are as follows. Figure 2 Here, the interceptor replaces the streambuf object and rewrites the buffer object of the standard output stream through the redirection method, thereby intercepting the output content, which is the log. Its working process is shown in the attached Figure 3 As shown, after the log is intercepted, it is notified to the component library public interface object in the form of a message, and then the public interface object writes the log to a file, and at the same time transmits the message to the UI part of the software to realize the real-time display of the log on the interface.

[0071] 3. Simulation control program module.

[0072] The main function of the simulation control program module is to load the log core component library. In the main program's entry main() function, create a public interface object for the log core component, and use the directory where the main program is located as the log file storage location as the entry parameter of the public interface object constructor. The public interface object is released when the application exits, and the life cycle of the public interface object is consistent with that of the simulation control program module.

[0073] 4. Log display module

[0074] The log display module is an important part of the main interface of the simulation control software. In the main interface of the simulation control software, a fixed area is reserved to scroll and display the current log information in real time. A function is defined in the log display module, which is responsible for binding with the public interface object of the log core component in the form of a callback function. When the public interface object generates logs in real time, the callback function in the main interface will display the received log information on the user interface.

[0075] 5. Simulation control business module

[0076] The simulation control business module refers to the other business modules of the channel simulator simulation control software, which are used to implement various channel simulation functions. Since the core component of the log intercepts the standard output stream output information by rewriting the streambuf object, in the simulation control business module, only the standard output stream output information needs to be used to complete the storage and display of the log.

[0077] The specific embodiments of the present invention are as follows:

[0078] 1. Log storage module:

[0079] The log storage module is a specific folder in the file system of the built-in operating system of the channel simulator. Its structure is as shown in the attached figure. Figure 6 shown.

[0080] 2. Log core component library

[0081] The specific implementation of the log core library is to write a C++ dynamic link library for the Windows platform based on Visual studio 2019. The dynamic link library is named TRLogLib. Figure 7 As shown, TRLogLib contains two important classes, TRLog and FdOutRealBuf, where TRLog is the specific implementation of the public interface class of the log core library, and FdOutRealBuf is the specific implementation of the standard output stream cache interceptor.

[0082] (1) The TRLog class is called by the simulation control program module to initialize the log environment. When the simulation control software generates a log, it sends a message to the user interface that displays the log in real time. The TRLog class includes the following important members:

[0083] ①Constructor TRLog(char*logFilePath, int logFileMaxSize).

[0084] The TRLog class is called when it is instantiated, passing in two parameters: the log storage path and the maximum size limit of the log file.

[0085] The constructor is responsible for creating the fd_out_real_buf object and redirecting the standard output stream to the fd_out_real_buf object. Before redirection, the original buffer object of the standard output stream is recorded and assigned to the last_buf pointer.

[0086] After the fd_out_real_buf object is created, its setCallBack() function is called, and the member function voidrecive(std::string logMessage) is bound to the fd_out_real_buf object as a parameter.

[0087] ②void add_callbackfun(const std::function<void(std::string)> &p_interrupt). This function parameter is a function pointer, i.e., a callback function. Its main function is to pass the log information outward through the callback function when TRLog receives the log from the interceptor, so as to realize the real-time display of the log to the user interface.

[0088] ③Destructor ~ TRLog(). This function is called when the TRLog class is destroyed. The destructor is responsible for destroying the fd_out_real_buf object and redirecting the standard output stream to the original buffer object.

[0089] ④ A function that receives the message from the interceptor log: void recive(std::string logMessage); as the input parameter to call the setCallBack() function of the fd_out_real_buf object.

[0090] ⑤File writing function void write2file(). Write the generated log string into the file according to the log rules in the log storage module.

[0091] ⑥std::streambuf*last_buf. It is used to save the original buffer object of the standard output stream.

[0092] ⑦FdOutRealBuf*fd_out_real_buf. Customized FdOutRealBuf object.

[0093] ⑧std::vector <std::function<void(std::string)> >m_interruptlist. Used to store the callback function pointer passed in the add_callbackfun function.

[0094] (2) FdOutRealBuf inherits from the standard C++ library<streambuf.h> The main members of the FdOutRealBuf class include:

[0095] ①Byte array. char_buffer[MAX_BUFFER_SIZE]. Temporarily store the intercepted output content in an array, which is used to convert it into a string and send messages to the outside. MAX_BUFFER_SIZE is the default size of the buffer, and the default value is 4096.

[0096] ②Constructor FdOutRealBuf(). It mainly implements the initialization of the buffer. In the constructor, the setp() function of std::streambuf is used to bind _buffer to the current standard output stream. This means that _buffer is the buffer of the standard output stream and can receive the output content of the standard output stream in real time. The implementation code is: setp(_buffer+0, _buffer+(s_buffer_size-1));

[0097] ③std::function<void(std::string)> callBack callback function member.

[0098] ④Message binding function void setCallBack(conststd::function<void(std::string)> &cb). The function parameter is a function pointer, i.e., the callback function, which is assigned to callBack.

[0099] ⑤int sync() function. When the standard output stream cout executes message output, the sync function of the buffer class is called. At this time, _buffer is converted into a string and the callback function callback is called to pass the log string to the external TRLog object.

[0100] 3. Simulation control program module

[0101] The simulation control program module is an executable file based on the Windows platform, which can be implemented by creating a WidgetApplication based on the QT C++ development framework. Write the following code in its entry function main() to call TRLogLib.

[0102] int main(int argc, char*argv[])

[0103] {

[0104] QApplication a(argc, argv);

[0105] TRLog log(QApplication::applicationDirPath().toLocal8Bit().toStdString().c_str()+" / logs", 10*1024*1024);

[0106] MainWindow w;

[0107] w.show();

[0108] return a.exec();

[0109] }

[0110] In the above code, a TRLog object is declared using TRLog log. In the construction, the log storage path is passed to the log object by adding the current program's running directory plus " / logs". The size of a single log file is limited to 10M.

[0111] 4 Display interface implementation steps

[0112] In the above simulation control program module implementation steps, the simulation control main program creates a main window MainWindow class by default. On this basis, in order to use the main window as the display interface of the log and to display the log in real time, it is necessary to implement it according to the following steps:

[0113] (1) Add a QTextBrowser type text box in the main form to display logs in real time.

[0114] (2) Add a member function in the MainWindow class. This member function will be bound to TRLog in a callback manner. The function definition is as follows:

[0115] void MainWindow::setBrowserText(std::string msg)

[0116] {

[0117] this->ui->textBrowser->append(QString::fromStdString(msg));

[0118] }

[0119] (3) Add code in the main() function of the simulation control program module, call the add_callbackfun() function of the TRLog object, and bind the setBrowserText message to TRLog.

[0120] MainWindow w;

[0121] log.add_callbackfun(std::bind(&MainWindow::setBrowserText,&w, std::placeholders::_1));

[0122] 5. Specific ways to generate logs in business modules

[0123] In the business modules that need to generate logs, there is no need to write specific log output code. Just use the C++ standard output stream to output information. For example: std:: << "this is log message..." << std::endl, where "this is log message..." is the log information.

[0124] The technical solution of the present invention refers to the solution for recording log files and displaying logs by technical means before generating logs, and does not include the parsing of logs. For example: "The log storage module is used to store the log information generated during operation in a text-format log file in the form of a string; the log core component library is connected to the log storage module and includes a public interface class for external calls and a standard output stream buffer interceptor", and the above two modules are both solutions for generating logs.

[0125] After each log is generated at runtime by the log storage module in the technical solution of the present invention, according to the current system date, a log file named with the current date and the maximum serial number is created or opened under the Logs folder, and the newly generated log is appended to the file; when the file does not exist or the file size exceeds the predetermined size limit, a new log file is created according to the rule of incrementing the serial number, and the log is appended to the file.

[0126] The log core component library in the technical solution of the present invention is connected to the log storage module and includes a public interface class for external calls and a standard output stream buffer interceptor.

[0127] The standard output stream buffer interceptor of the log core component library in the technical solution of the present invention replaces the streambuf object, rewrites the buffer object of the standard output stream by the redirection method, and intercepts the output content; after the log is intercepted, it is notified to the public interface object of the component library in the form of a message, and then the public interface object writes the log to the file and at the same time sends a message to the UI part to display the log in real time on the interface.

[0128] The simulation control program module in the technical solution of the present invention is connected to the log core component library and is used to load the log core component library.

[0129] The simulation control program module in the technical solution of the present invention creates a public interface object of the log core component in the entry main() function, and uses the directory where the main program is located as the storage location of the log file as the entry parameter of the public interface object constructor.

[0130] Compared with the implementation methods of general log recording and output, the present invention has the following obvious advantages:

[0131] 1. The present invention can greatly reduce the complexity of software development. Figure 4 and attached Figure 5 For example, when Log4Cpp is used as the log component, all business modules that need to generate logs need to rely on Log4Cpp. When the log core component of the present invention is used as the log function component of the simulation control software, it is only necessary to call the public interface class of the library at the main program entrance to achieve the purpose of generating logs and recording logs for the entire software, which greatly reduces the coupling between modules.

[0132] 2. The present invention can greatly improve the efficiency of software development. When the log core component of the present invention is used as the log function component of the simulation control software, there is no need to write a specific output log code in the module that needs to generate logs. It is only necessary to use the C++ standard output stream to output information. When using a general log component library, it is necessary to write a specific log code. For example:

[0133] When using Log4Cpp, the code to generate the log is as follows:

[0134] ①#include<log4cpp / Category.hh>

[0135] ②log4cpp::Categroy&root=log4cpp::Categroy::getRoot();

[0136] ③root.info("this is log message...");

[0137] The code for generating logs using the log core component of the present invention:

[0138] std::<<"this is log message..."< <std::endl;

[0139] It can be seen that the log generation method of the present invention does not need to follow a specific syntax, which reduces the difficulty of development and improves software development efficiency.

[0140] 3. The present invention makes the log function of the simulation control software more complete and unified. It is inevitable to call some third-party component libraries during the software development process. When using third-party libraries, the source code of these libraries is often unable to be modified. If a general log component is used to develop the simulation control software, it means that the logs generated by the third-party library will not be guaranteed to be stored in files according to unified requirements, because the log saving method adopted by the third-party library is uncertain. When the log core component of the present invention is used to save the log, as long as the third-party library is loaded into the current process during runtime and the standard output stream is used to output information to the console, the information will be uniformly intercepted and saved in the current log file. It can be seen that the present invention can unify the log function of the simulation control software to the greatest extent.

[0141] 4. The solution of the present invention can display real-time log information in files and software interfaces at the same time, making software interaction more friendly.

[0142] The specific implementation scheme of this embodiment can refer to the relevant description in the above embodiment, which will not be repeated here.

[0143] It can be understood that the same or similar parts of the above embodiments can be referenced to each other, and the contents not described in detail in some embodiments can refer to the same or similar contents in other embodiments.

[0144] It should be noted that, in the description of the present invention, the terms "first", "second", etc. are only used for descriptive purposes and cannot be understood as indicating or implying relative importance. In addition, in the description of the present invention, unless otherwise specified, the meaning of "plurality" refers to at least two.

[0145] In the description of this specification, the description with reference to the terms "one embodiment", "some embodiments", "examples", "specific examples", or "some examples" means that the specific features, structures, materials or characteristics described in conjunction with the embodiment or example are included in at least one embodiment or example of the present invention. In this specification, the schematic representation of the above terms does not necessarily refer to the same embodiment or example. Moreover, the specific features, structures, materials or characteristics described may be combined in any one or more embodiments or examples in a suitable manner.

[0146] The channel simulation software log recording system of the present invention can greatly reduce the complexity of software development, greatly improve the efficiency of software development, make the log function of the simulation control software more complete and unified, and can display real-time log information in files and software interfaces at the same time, making software interaction more friendly.

[0147] In this specification, the present invention has been described with reference to specific embodiments thereof. However, it is apparent that various modifications and variations may be made without departing from the spirit and scope of the present invention. Therefore, the specification and drawings should be regarded as illustrative rather than restrictive.

Claims

1. A channel simulation software logging system, characterized in that: The system comprises: The log storage module is used to store the log information generated during the operation in the form of a string in a text-formatted log file; The log core component library is connected to the log storage module and includes a public interface class for external calls and a standard output stream cache interceptor; A simulation control program module is connected to the log core component library and is used to load the log core component library; A log display module, connected to the simulation control program module, for scrolling and displaying the current log information in real time; The simulation control service module is connected with the simulation control program module and is used to realize various channel simulation functions through the channel simulator; and complete the storage and display of the log by outputting information through the standard output stream.

2. The channel simulation software logging system according to claim 1, characterized in that: The log storage module creates or opens a log file named with the current date and the maximum serial number in the Logs folder each time a log is generated at runtime, according to the current system date, and appends the generated new log to the file; When the file does not exist or the file size exceeds the preset size limit, a new log file is created using the rule of increasing serial numbers and the log is appended to the file.

3. The channel simulation software logging system according to claim 1, characterized in that: The public interface class of the log core component library initializes the log environment according to the parameters of the incoming log; creates a standard output stream cache interceptor class object to intercept the standard output of each module of the simulation control software; writes the intercepted log into the log file according to the log storage rules; when the simulation control software generates a log, transmits a message to the user interface and displays the log in real time.

4. The channel simulation software logging system according to claim 1, characterized in that: The standard output stream cache interceptor of the log core component library replaces the streambuf object, rewrites the buffer object of the standard output stream through the redirection method, and intercepts the output content; After the log is intercepted, it is notified to the component library public interface object in the form of a message, and then the public interface object writes the log to the file, and at the same time passes the message to the UI part to display the log in real time on the interface.

5. The channel simulation software logging system according to claim 1, characterized in that: The simulation control program module creates a public interface object of the log core component in the entry main() function, and uses the directory where the main program is located as the log file storage location as the entry parameter of the public interface object constructor.

6. The channel simulation software logging system according to claim 1, characterized in that: The log display module defines a function, which is bound to the public interface object of the log core component in the form of a callback function. When the public interface object generates logs in real time, the received log information is displayed on the user interface through the callback function.

Images