Obsidean_VM/01-Documentation/Dispositivos - Manuales/Maselli/Maselli - Utility/Software General Description.md

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.