439 lines
29 KiB
Markdown
439 lines
29 KiB
Markdown
# Software Documentation
|
|
|
|
This document outlines the functionalities, protocols, and services of the provided software components, based on the C# source code.
|
|
|
|
## Namespaces and Classes
|
|
|
|
### 1. `ClasseSQL`
|
|
|
|
This namespace is responsible for interactions with a SQL database.
|
|
|
|
* **`ClassSQL` (internal)**
|
|
* **Functionalities:**
|
|
* Provides static methods to manage a SQL database connection.
|
|
* `SetConnectionString(string Stringa)`: Sets the main part of the SQL connection string.
|
|
* `SetInitialCatalog(string Stringa)`: Sets the initial catalog (database name) for the SQL connection.
|
|
* `SendComandoSQL(string SQLCommand)`: Executes a given SQL command string and returns the results as a `DataTable`. It handles opening and closing the SQL connection.
|
|
* **Protocols:**
|
|
* Uses **System.Data.SqlClient**, indicating interaction with Microsoft SQL Server.
|
|
* **Services:**
|
|
* Provides a basic SQL database querying service.
|
|
|
|
* **`ComandoSQL` (internal, implements `IDisposable`)**
|
|
* **Functionalities:**
|
|
* Represents a SQL command to be executed.
|
|
* Constructor `ComandoSQL(string StringaConnessione, string StringaComando)`: Initializes a new SQL command with a connection string and the command text.
|
|
* `AddParameter(string IDParametro, object Valore)`: Adds parameters to the SQL command to prevent SQL injection and handle various data types.
|
|
* `Send()`: Executes the SQL command (presumably a SELECT query) and fills a `DataTable` with the results. It manages connection opening/closing and basic error handling.
|
|
* `Error` (property): Boolean indicating if an error occurred during the command execution.
|
|
* `TableReturned` (property): Returns the `DataTable` containing the query results.
|
|
* `ErrorString` (property): Provides the error message if an error occurred.
|
|
* Implements `IDisposable` to release resources like `SqlConnection`, `SqlCommand`, and `DataTable`.
|
|
* **Protocols:**
|
|
* Uses **System.Data.SqlClient** for SQL Server communication.
|
|
* **Services:**
|
|
* Offers a more structured way to execute parameterized SQL queries and retrieve data.
|
|
|
|
### 2. `MaselliPanel`
|
|
|
|
This namespace appears to be related to panel management, possibly for a user interface, but also includes a global error handling class.
|
|
|
|
* **`ErrGlobale` (public)**
|
|
* **Functionalities:**
|
|
* A simple class to store global error messages.
|
|
* Contains `Messaggio` (message string) and `Visualizzato` (boolean flag, likely for UI purposes to track if an error has been displayed).
|
|
* **Services:**
|
|
* Basic global error information holder.
|
|
|
|
* **`Pannelli` (public)**
|
|
* **Functionalities:**
|
|
* Defines a large number of constants (`NUM_PANNELLO_*`), likely representing unique identifiers for different UI panels or sections within the application. These constants seem to be related to various instruments and their functionalities (CO2, Ossigeno, URXX, UC08, UV, US, etc.) and specific operations (Setup, Calibration, Linearization, Parameters, Data Acquisition).
|
|
* Static fields `NumeroPannello` and `NumeroPannelloBack` to track the current and previous panel, respectively. This suggests a navigation system.
|
|
* **Services:**
|
|
* Provides a centralized definition and tracking mechanism for UI panel navigation.
|
|
|
|
### 3. `MaselliScreen`
|
|
|
|
This namespace contains classes primarily for UI management, screen drawing, and custom UI elements. While the user is not interested in graphical aspects, the functionalities provided by these classes are noted.
|
|
|
|
* **`ClassScreen` (public)**
|
|
* **Functionalities:** (Ignoring graphical details)
|
|
* `SetRisoluzioneApp(int RisoluzioneX, int RisoluzioneY)`: Sets the application's screen resolution.
|
|
* `LoadImmagineDaFile(...)`: Methods to load images for UI elements.
|
|
* **Services:**
|
|
* Basic UI helper functions.
|
|
|
|
* **`MaselliColours` (internal)**
|
|
* **Functionalities:** Defines static color properties for UI elements. (Details ignored as per user request).
|
|
|
|
* **`MaselliInputBox` (public)**
|
|
* **Functionalities:**
|
|
* Provides static methods `Show(...)` to display a custom input dialog to the user.
|
|
* Can be configured to show a password input field.
|
|
* **Services:**
|
|
* Custom user input dialog service.
|
|
|
|
* **`MaselliMessageBox` (public)**
|
|
* **Functionalities:**
|
|
* Provides static methods `Show(...)` to display custom message boxes with different buttons (OK, OKCancel, YesNo) and icons (Information, Warning, Question, Error).
|
|
* **Services:**
|
|
* Custom message display service.
|
|
|
|
* **`MaselliSaveAs` (public, implements `IDisposable`)**
|
|
* **Functionalities:**
|
|
* A custom "Save As" dialog implementation.
|
|
* `ShowDialog()`: Displays the dialog.
|
|
* Allows navigation through drives and directories.
|
|
* **Services:**
|
|
* Custom file saving dialog service.
|
|
|
|
### 4. `MaselliSerial`
|
|
|
|
This namespace deals with serial communication commands.
|
|
|
|
* **`ComandoSeriale` (public)**
|
|
* **Functionalities:**
|
|
* Represents a serial command to be sent to an instrument.
|
|
* Properties include:
|
|
* `StringaComando`: The actual command string.
|
|
* `TipoComando`: Type of command (e.g., "M" for modify, "V" for read variable, "P"/"I"/"i"/"X" for image requests).
|
|
* `Indirizzo`: Instrument address.
|
|
* `NumeroFunzione`: Function number/code.
|
|
* `ValoreComando`: Value associated with the command.
|
|
* `FormatoValore`: Format of the value.
|
|
* `Stato`: Status of the command (e.g., PENDING, OK_COMMAND).
|
|
* `NumeroRipetizioni`: Number of times the command has been retried.
|
|
* `Timeout`: Timeout for the command.
|
|
* `Terminatore`: Terminator byte for the command response.
|
|
* `Linea`: Communication line number.
|
|
* **Protocols:**
|
|
* Implies a custom serial communication protocol where commands have specific types, addresses, and function codes.
|
|
* **Services:**
|
|
* Data structure for serial commands.
|
|
|
|
* **`StatiComando` (internal)**
|
|
* **Functionalities:**
|
|
* Defines constants for the different states a serial command can be in (e.g., `EMPTY`, `PENDING`, `WAIT_TX`, `WAIT_RX`, `OK_COMMAND`, `ERROR_COMMAND`).
|
|
* **Services:**
|
|
* Provides status definitions for serial command processing.
|
|
|
|
### 5. `MaselliSocket`
|
|
|
|
This namespace handles network communication via sockets.
|
|
|
|
* **`ClassMaselliSocket` (internal)**
|
|
* **Functionalities:**
|
|
* Manages a TCP/IP socket connection.
|
|
* Constructor initializes a socket for `AddressFamily.InterNetwork`, `SocketType.Stream`, `ProtocolType.Tcp`.
|
|
* `Connect(string host, int port)`: Connects to a specified host and port.
|
|
* `Disconnect()`: Disconnects the socket.
|
|
* `Close()`: Closes the socket and stops an internal timer.
|
|
* `Send(byte[] message)` / `Send(string message)`: Sends data over the socket.
|
|
* Handles receiving data asynchronously using a timer (`timerSocket`) and processing it.
|
|
* `FlagResponse` / `FlagResponseImage`: Flags indicating if a text response or image data has been received.
|
|
* `RxBuffer` / `RxBufferBytes`: Buffers for received text and byte data.
|
|
* Internal state management for socket phases (e.g., `OPEN`, `READ`, `RECONNECT`).
|
|
* Appears to be used in conjunction with `ClassSerialeStrumenti` when `EnableEthernetBridge` is active, suggesting it acts as a bridge for serial commands over TCP/IP.
|
|
* **Protocols:**
|
|
* **TCP/IP Sockets**: Explicitly uses `System.Net.Sockets.Socket` with `ProtocolType.Tcp`.
|
|
* **Services:**
|
|
* Provides TCP/IP client communication services, potentially for bridging serial communication over a network.
|
|
|
|
### 6. `MaselliVariables`
|
|
|
|
This namespace defines classes for handling variables, likely from instruments.
|
|
|
|
* **`ClassVariabile` (public)**
|
|
* **Functionalities:**
|
|
* Represents a variable, likely a parameter or measurement from an instrument.
|
|
* Properties include:
|
|
* `Scritta`, `ScrittaPerStampa`: Display names for the variable.
|
|
* `NumeroStrumento`, `NomeStrumento`: Identifiers for the instrument the variable belongs to.
|
|
* `Valore`: The current value of the variable.
|
|
* `Presenza`: Indicates if the variable is present/active.
|
|
* `Formato`: String format for displaying the value.
|
|
* `ListaValori`: A list of `ItemValore` for variables that have predefined sets of values (e.g., enums).
|
|
* `UnitaMisura`: Unit of measurement.
|
|
* `LimiteLow`, `LimiteHigh`: Low and high limits for the variable's value.
|
|
* `NumeroFunzione`, `NumeroFunzioneUniAna`: Function numbers, likely for communication protocols.
|
|
* `ValueConversion`: A delegate for custom value conversions (e.g., temperature scales).
|
|
* Methods:
|
|
* `ValoreToSQL()`: Formats the variable's value for SQL insertion.
|
|
* `ValoreFormattato()`: Formats the variable's value for display, handling units and lists.
|
|
* `ToDouble()`, `ToFloat()`, `ToInteger()`, `ToShort()`: Converts the variable's value to different numeric types, applying conversions if necessary.
|
|
* `Modifica()`: A method that likely opens a UI dialog (`Clas_dynamic.SuperInputBox` or `FrmSceltaVar`) to allow the user to modify the variable's value, performing validation against limits.
|
|
* **Protocols:**
|
|
* Interaction with UI elements (`Clas_dynamic.SuperInputBox`, `FrmSceltaVar`) for modification.
|
|
* Formatting for SQL suggests interaction with database services.
|
|
* **Services:**
|
|
* Manages instrument variables, including their values, display formats, units, limits, and modification logic.
|
|
|
|
* **`ItemValore` (public)**
|
|
* **Functionalities:**
|
|
* A simple class to hold a value (`Valore`) and its corresponding display text (`Scritta`). Used for variables that represent a selection from a list (e.g., an enum).
|
|
* **Services:**
|
|
* Represents a single item in a list of possible values for a `ClassVariabile`.
|
|
|
|
### 7. `RicetteMaselli`
|
|
|
|
This namespace seems to handle "recipes," which are likely sets of parameters to be sent to an instrument.
|
|
|
|
* **`ClassRicetta` (public)**
|
|
* **Functionalities:**
|
|
* Represents a recipe.
|
|
* `Invia`: Boolean flag to indicate if the recipe should be sent.
|
|
* `Address`: Target instrument address for the recipe.
|
|
* `Parametri`: A list of `ElementoRicetta` objects, forming the recipe's content.
|
|
* **Services:**
|
|
* Container for instrument recipes.
|
|
|
|
* **`ElementoRicetta` (public)**
|
|
* **Functionalities:**
|
|
* Represents a single parameter within a `ClassRicetta`.
|
|
* `NumeroFunzione`: Function number of the parameter.
|
|
* `Valore`: Value of the parameter.
|
|
* `Formato`: Format of the parameter's value.
|
|
* **Services:**
|
|
* Data structure for individual recipe parameters.
|
|
|
|
### 8. `StrumentiMaselli`
|
|
|
|
This is a core namespace defining the structure and behavior of various Maselli instruments.
|
|
|
|
* **`ClassCertificazione` (public)**
|
|
* **Functionalities:**
|
|
* Holds data related to instrument certification/calibration.
|
|
* Properties for serial number, memory name function numbers, measured value, certified value, accuracy, tolerance, technician, batch info, etc.
|
|
* **Services:**
|
|
* Manages certification data for an instrument.
|
|
|
|
* **`ClassResettable` (public)**
|
|
* **Functionalities:**
|
|
* Defines constants `NO` (0) and `YES` (1), likely for boolean-like flags.
|
|
|
|
* **`ClassStrumentoMaselli` (public, abstract)**
|
|
* **Functionalities:**
|
|
* Abstract base class for all Maselli instruments.
|
|
* `Presenza`: Boolean indicating if the instrument is detected.
|
|
* `NumeroLinea`: Communication line number.
|
|
* `Serial`: An `InstrumentSerial` object managing serial communication details.
|
|
* `Identification`: An `Identifier` object for instrument type and name.
|
|
* `Inizializzato`: Flag indicating if the instrument has been initialized.
|
|
* Various `NumFun*` properties (e.g., `NumFunMemoryName`, `NumFunSerialNumber`): Store function numbers for specific instrument operations, crucial for the Maselli communication protocol.
|
|
* `ForzaProtocolloADAM`, `ForzaProtocolloPROFIBUS`: Flags to force specific communication protocols.
|
|
* `RicettaDaInviare`: A `ClassRicetta` object for sending recipes to the instrument.
|
|
* `SuperComandi`, `ComandiAvvio`, `ComandiUscita`: Lists of `ComandiDaInviare` for various stages of instrument interaction.
|
|
* `TabellaCorrispondenzaUniAna`: Array mapping universal/analog function numbers to specific instrument function numbers.
|
|
* `ListaDataAcquisition`: Dictionary for data acquisition configuration.
|
|
* `DatiSQL`: Holds data to be saved to a SQL database for the instrument.
|
|
* `Certificazione`: `ClassCertificazione` object.
|
|
* `ModalitaMaselli`: Boolean indicating if the instrument is in "Maselli" communication mode (likely a proprietary protocol).
|
|
* Abstract methods (e.g., `InizializzaListaVariabili`, `RecognizeEquipment`, `AddStartupCommands`) to be implemented by derived instrument classes.
|
|
* `InitAfterRecognize()`: Method to perform initialization steps after an instrument is recognized.
|
|
* `AssegnaTabellaCorrispondenzaUniAna()`: Populates the function number mapping table.
|
|
* **Protocols:**
|
|
* Defines the framework for interacting with instruments using function numbers, addresses, and specific command sequences (Maselli proprietary protocol).
|
|
* Implies support for ADAM and PROFIBUS protocols.
|
|
* **Services:**
|
|
* Base framework for instrument communication, identification, parameter management, and data handling.
|
|
|
|
* **`ComandiDaInviare` (public)**
|
|
* **Functionalities:**
|
|
* Represents a command to be sent, containing the command string, function number, and value.
|
|
* **Services:**
|
|
* Data structure for commands used in `ClassStrumentoMaselli`.
|
|
|
|
* **`DatiSQL` (public)**
|
|
* **Functionalities:**
|
|
* Stores data (`OrdineLavoro`, `Matricola`, `Note`, and a list of `ElementoDatabase`) intended for SQL database storage.
|
|
* **Services:**
|
|
* Data container for instrument-related information to be saved in a database.
|
|
|
|
* **`ElementoDatabase` (public)**
|
|
* **Functionalities:**
|
|
* Represents a single data element to be stored in the database, linking a name, a function number (to retrieve its value from `UtilityMaselli.Variabili`), and its string value.
|
|
* **Services:**
|
|
* Defines a database-bound data item.
|
|
|
|
* **`Identifier` (public)**
|
|
* **Functionalities:**
|
|
* Stores identification information for an instrument: `DeviceName`, `RecognizingStrings` (used to identify the instrument model from its response), `EquipmentRecognized` flag, `DeviceType`, `EquipmentType`, and `MemoryYear`.
|
|
* **Services:**
|
|
* Provides instrument identification capabilities.
|
|
|
|
* **`Image<T>` (public, generic where `T` : struct)**
|
|
* **Functionalities:**
|
|
* A generic class to store image data (e.g., CCD or pressure sensor readings).
|
|
* `Data`: Array of type `T` to hold the image pixels/data points.
|
|
* `Request`: The command string used to request this image.
|
|
* `IsNewData`: Flag indicating if new image data is available.
|
|
* **Services:**
|
|
* Generic image data container.
|
|
|
|
* **`InstrumentSerial` (public)**
|
|
* **Functionalities:**
|
|
* Holds serial communication parameters and state for an instrument.
|
|
* Properties like `Protocol`, `Indirizzo` (address), `FaseComunicazione` (communication phase), timeouts, and flags for image requests or special command handling.
|
|
* **Services:**
|
|
* Manages serial communication state for an instrument.
|
|
|
|
* **`StrumentoWithCCDImage` (public, abstract, inherits `StrumentoWithImage<ushort>`)**
|
|
* **Functionalities:**
|
|
* Abstract class for instruments that use a CCD image sensor. Inherits from `StrumentoWithImage` specialized with `ushort` for image data.
|
|
* **Services:**
|
|
* Base class for CCD-based instruments.
|
|
|
|
* **`StrumentoWithImage<TImage>` (public, abstract, inherits `ClassStrumentoMaselli`)**
|
|
* **Functionalities:**
|
|
* Abstract generic class for instruments that produce image data.
|
|
* `Immagine`: An `Image<TImage>` object to store the instrument's image data.
|
|
* **Services:**
|
|
* Generic base class for image-producing instruments.
|
|
|
|
* **`StrumentoWithPressureImage` (public, abstract, inherits `StrumentoWithImage<double>`)**
|
|
* **Functionalities:**
|
|
* Abstract class for instruments that produce pressure image/profile data. Inherits from `StrumentoWithImage` specialized with `double`.
|
|
* **Services:**
|
|
* Base class for pressure-profile instruments.
|
|
|
|
### 9. `Uc09_Utility`
|
|
|
|
This namespace provides various utility classes and global static members used throughout the application.
|
|
|
|
* **`BaudRate_UC` (public)**
|
|
* **Functionalities:** Defines constants for standard baud rates.
|
|
|
|
* **`BITCW` (public, enum : ushort, Flags)**
|
|
* **Functionalities:** Defines bit flags, likely for a control word or status register.
|
|
|
|
* **`BitcwState` (public, Form)**
|
|
* **Functionalities:** (UI class, details ignored as per request, but functional aspect noted)
|
|
* Displays the state of individual bits within a BITCW (control word) variable.
|
|
* **Services:**
|
|
* UI for visualizing BITCW states.
|
|
|
|
* **`BITCW_UR` (public)**
|
|
* **Functionalities:** Defines constants representing specific alarm or status bits for "UR" type instruments (e.g., `LOW_BRIX`, `MEMORY_FAIL`).
|
|
|
|
* **`CCDPoint` (public, struct)**
|
|
* **Functionalities:** A simple struct to store X and Y coordinates, likely for CCD image data points.
|
|
|
|
* **`ClassDataAcquisition` (public, implements `IDisposable`)**
|
|
* **Functionalities:**
|
|
* Manages data acquisition to a file.
|
|
* `Enable(short time, string path)`: Starts data acquisition, writing data to the specified `path` at intervals defined by `time`.
|
|
* `Disable()`: Stops data acquisition.
|
|
* Uses a timer to periodically write formatted data (including date, time, and values from `UtilityMaselli.StrumentoAcquisizioneDati.ListaDataAcquisition`) to the log file.
|
|
* **Services:**
|
|
* Provides a service for logging instrument data to a file over time.
|
|
|
|
* **`ClassDatabaseSQL` (public, implements `IDisposable`)**
|
|
* **Functionalities:**
|
|
* Handles more complex database interactions, specifically for saving instrument calibration data and parameters to different tables (`UC07Calib`, `Sonico`, `Ossigeno`, `DsLottoModello`) based on instrument type.
|
|
* `CreaListaPerDatabase(ClassStrumentoMaselli StrumentoDaSalvare)`: Prepares and sends data for a given instrument to the appropriate SQL table. It iterates through `StrumentoDaSalvare.DatiSQL.ListaElementiDatabase` and formats values for SQL insertion.
|
|
* `SalvaPontremoliDb(...)`: Asynchronously saves/updates data to a table named `DsLottoModello`, likely for a specific production/testing environment ("Pontremoli"). This method is more complex, handling different update queries based on whether an image is being saved or parameters. It also appears to dynamically add user scale parameters if a certain condition is met.
|
|
* `cerca_identificativo_utente()`: Queries an `Utente` table to find a user ID based on `utente_utility`.
|
|
* Uses `OleDbConnection` and `OleDbCommand`, suggesting it might connect to databases via OLEDB providers (which could include SQL Server or others like Access). The connection string `Provider=SQLOLEDB` points to SQL Server.
|
|
* **Protocols:**
|
|
* **OLEDB** for database communication, specifically with a SQL Server provider (`SQLOLEDB`).
|
|
* **Services:**
|
|
* Advanced database service for logging specific instrument data and production/testing records.
|
|
|
|
* **`ClasseOSK` (internal)**
|
|
* **Functionalities:**
|
|
* Manages the On-Screen Keyboard (OSK).
|
|
* `Attiva()`: Starts the `osk.exe` process.
|
|
* `Disattiva()`: Kills the `osk.exe` process.
|
|
* Handles Wow64 file system redirection for 64-bit OS.
|
|
* **Services:**
|
|
* Provides control over the Windows On-Screen Keyboard.
|
|
|
|
* **`ClassFormControlsEnanche` (internal)**
|
|
* **Functionalities:** (UI helper, functional aspect noted)
|
|
* Enhances form controls by managing their actions (e.g., modify variable, change panel) and enabling/disabling them based on communication state or variable presence.
|
|
* `AddControl(...)`: Adds controls to its internal management list with specified actions and associated function numbers.
|
|
* `VisualizeValuesInLabels()`: Updates text of managed labels with formatted variable values.
|
|
* `EnableControls()`: Enables/disables controls based on the instrument's communication phase and variable presence.
|
|
* **Services:**
|
|
* Advanced UI control management and data binding helper.
|
|
|
|
* **`ClassInizializzazioni` (internal)**
|
|
* **Functionalities:**
|
|
* `InizializzaVariabili()`: Initializes the global `UtilityMaselli.Variabili` list with default `ClassVariabile` objects.
|
|
* `InizializzaStrumenti()`: Initializes instances of various instrument classes (`ClassStrumentoUCXX`, `ClassStrumentoUG`, etc.) based on `UtilityMaselli.Setup` settings. It configures their addresses, device names, recognizing strings, menu numbers, and essential function numbers.
|
|
* **Services:**
|
|
* Provides application startup initialization for variables and instruments.
|
|
|
|
* **`ClassSerialeStrumenti` (public, implements `IDisposable`)**
|
|
* **Functionalities:**
|
|
* The core class for managing serial (and bridged socket) communication with Maselli instruments.
|
|
* `AddStrumento(ClassStrumentoMaselli strumento)`: Adds an instrument to its management list.
|
|
* `InserisciComandoSeriale(...)`: Adds a serial command to a concurrent queue (`QueueComandiSeriali`) for processing.
|
|
* `PreparaComando(...)`: Formats a command string according to the Maselli protocol (e.g., `>LLLLAA T;FFFVALUE;cc\r`). This includes calculating length and checksum.
|
|
* `CalcolaChecksum(...)`: Calculates the checksum for a command string.
|
|
* Manages communication phases for each instrument (`FaseComunicazione` in `InstrumentSerial`). Phases include recognizing, sending super commands, linked, closing, etc.
|
|
* Handles sending commands from the queue and processing received responses.
|
|
* `GestioneComandoRicevuto(...)`: Parses responses, checks for errors (NO02-NO07), and decodes data or images.
|
|
* `DecodificaRisposta(...)`, `DecoderProtocolloMaselli(...)`: Decodes Maselli protocol responses, updates `ClassVariabile` objects in `UtilityMaselli.Variabili`.
|
|
* `DecodificaImmagine(...)`: Decodes image data from responses.
|
|
* Manages serial port (`System.IO.Ports.SerialPort`) or socket (`ClassMaselliSocket`) communication based on `UtilityMaselli.Setup.EnableEthernetBridge`.
|
|
* Uses a timer (`_timerSerialeUtility`) to drive its state machine and command processing loop.
|
|
* Handles instrument recognition by comparing received memory names with `RecognizingStrings` in the instrument's `Identifier`.
|
|
* Invokes events for various stages like `ReceiveCallback`, `ModifiedReceived`, `FirstRequestCallback`, `ProtocolChangedToMaselli`.
|
|
* **Protocols:**
|
|
* **Maselli Serial Protocol**: Implements the logic for constructing, sending, and parsing commands based on a proprietary Maselli protocol that uses addresses, function numbers, types (V, M, P, I, X, k), length fields, and checksums. The structure `>LLLLAA T;FFFVALUE;cc\r` is characteristic of this.
|
|
* **System.IO.Ports.SerialPort** for direct serial communication.
|
|
* **TCP/IP Sockets** (via `ClassMaselliSocket`) for Ethernet-bridged serial communication.
|
|
* **Services:**
|
|
* Central communication hub for all connected Maselli instruments, managing command queues, protocol encoding/decoding, and instrument state.
|
|
|
|
* **`ClassSetup` (public)**
|
|
* **Functionalities:**
|
|
* Manages application settings, loading them from a file (`FilePath`) and saving them back.
|
|
* Settings include COM port, baud rate, instrument addresses, UI preferences (virtual keyboard, resolution), data acquisition parameters, and flags for enabling specific instruments or communication modes (Ethernet bridge, ADAM/Profibus protocol switching).
|
|
* **Services:**
|
|
* Application configuration management.
|
|
|
|
* **Instrument-specific classes (`ClassStrumentoUCXX`, `ClassStrumentoUG`, `ClassStrumentoURXX`, `ClassStrumentoUSXX`, `ClassStrumentoUVXX`)**: These inherit from `ClassStrumentoMaselli` or its derivatives.
|
|
* **Functionalities:**
|
|
* Override abstract methods from the base class to provide instrument-specific initialization for variables, data acquisition lists, print parameter lists, database element lists, startup commands, and value conversions.
|
|
* `RecognizeEquipment()`: Often refines equipment type based on the memory name (e.g., UC8 vs. UC07).
|
|
* `InizializzaListaVariabili()`: Defines specific `ClassVariabile` objects with their function numbers, formats, limits, and units for that instrument type.
|
|
* `InitializeValueConversion()`: Assigns specific conversion delegates (e.g., for temperature, CO2, pressure) to relevant variables.
|
|
* `AddStartupCommands()`: Adds specific "super commands" or initial commands to be sent to the instrument upon connection or recognition.
|
|
* **Services:**
|
|
* Implement the specific logic and parameter definitions for each type of Maselli instrument.
|
|
|
|
* **`UtilityMaselli` (internal, static)**
|
|
* **Functionalities:**
|
|
* Acts as a global static container for application-wide objects and settings.
|
|
* Holds references to:
|
|
* `Setup`: The application settings.
|
|
* `Variabili`: The global list of all `ClassVariabile` objects.
|
|
* Instances of each instrument type (e.g., `StrumentoUC`, `StrumentoUR`).
|
|
* `SerialeStrumenti`: The main serial communication object.
|
|
* `CurrentDevice`, `StrumentoAcquisizioneDati`, `StrumentoStampa`, `StrumentoCertificazione`: References to the currently active/focused instrument for different operations.
|
|
* Paths for icons, executable, service files, images.
|
|
* `DataBaseSQLMaselli`: The database interaction object.
|
|
* **Services:**
|
|
* Global access point for shared application resources and state.
|
|
|
|
* **`ControlAction`, `ControlsEnabling`, `DefinitionItems`, `Definitions`, `FasiSerialeUtility`, `FasiStrumento`, `StatiComunicazione`, `StatiSeriale`**: These classes define constants used throughout the application for managing states, actions, and types.
|
|
|
|
### General Protocols & Services Summary
|
|
|
|
* **Protocols:**
|
|
* **Maselli Proprietary Serial/Socket Protocol:** The core communication method with instruments, characterized by commands like `>LLLLAA T;FFFVALUE;cc\r`, function numbers, addresses, and checksums. Managed by `ClassSerialeStrumenti`.
|
|
* **SQL Database Protocol:** Interaction with SQL Server using `System.Data.SqlClient` (in `ClasseSQL`) and `OleDbConnection` with `SQLOLEDB` provider (in `ClassDatabaseSQL`).
|
|
* **TCP/IP:** Used by `ClassMaselliSocket` for network communication, likely as a bridge for the Maselli serial protocol.
|
|
* **ADAM/PROFIBUS:** Mentioned as protocols that can be forced for instruments, suggesting the system can switch instruments to these standard industrial protocols.
|
|
|
|
* **Services:**
|
|
* **Instrument Communication Service:** `ClassSerialeStrumenti` provides the central service for communicating with all instruments, handling command queuing, sending, receiving, and basic decoding.
|
|
* **Database Interaction Service:** `ClasseSQL` and `ClassDatabaseSQL` offer services to query and store data in a SQL database. This includes instrument parameters, calibration data, and potentially production/testing records.
|
|
* **Variable Management Service:** `MaselliVariables.ClassVariabile` and `UtilityMaselli.Variabili` manage the state, display, and modification of instrument parameters and measurements.
|
|
* **Configuration Service:** `ClassSetup` manages loading and saving application and instrument settings.
|
|
* **UI Management Services:** Various classes in `MaselliScreen` and `MaselliPanel` (though graphical details are excluded) provide functionalities for UI panel navigation, custom dialogs, and screen adaptation.
|
|
* **Data Acquisition Service:** `Uc09_Utility.ClassDataAcquisition` logs instrument data to files over time.
|
|
* **Error Handling:** Basic error tracking in `ComandoSQL` and `ErrGlobale`, with more structured logging in `CommunicationHandlerLoggerService` (used by `ClassSerialeStrumenti`).
|
|
* **Instrument Abstraction:** `StrumentiMaselli.ClassStrumentoMaselli` and its derived classes provide an abstraction layer for different types of Maselli instruments. |