Sedici tipi di gauge per dashboard e pannelli HMI, dal quadrante radiale a un serbatoio di processo, a un simbolo di pompa e all'annunciatore, più una manopola, un cursore, un interruttore e un pulsante che l'utente aziona. Disegna fasce verdi, ambra e rosse, genera un allarme quando un valore supera un limite, lascia che la lancetta scivoli verso ogni nuova lettura e genera lo stesso gauge in PNG o SVG su un server.
Tredici funzionalità in cinque gruppi, con i nomi reali di classi e proprietà e un link a ogni topic della guida. Le funzionalità contrassegnate come Registered non sono nella build .NET Community gratuita.
Sedici tipi su un solo modello, con intervalli, stili, skin e più lancette.
Strumenti e scale
Dashboard, pannelli HMI e banchi di prova hanno bisogno di strumenti diversi: un quadrante per la velocità, una barra per il livello, un display digitale per la frequenza, una spia per una pompa, un pannello di tile per gli allarmi. sgcGauges include sedici tipi, dodici display e quattro gauge di input, che condividono un solo modello, le stesse scale, lancette, intervalli, soglie e temi. Impari una sola API e ogni strumento si comporta allo stesso modo.
TsgcVCLRadialGauge, TsgcVCLLinearGauge, TsgcVCLDigitalGauge, TsgcVCLLEDGauge, TsgcVCLLEDBarGauge, TsgcVCLProgressRingGaugeTsgcVCLVUMeterGauge, TsgcVCLClockGauge, TsgcVCLCompassGauge, TsgcVCLAnnunciatorGaugeTsgcVCLTankGauge e TsgcVCLSymbolGauge per le schermate di processoTsgcRadialGauge, per l'uso headlessCommunity ha i gauge radiale, lineare, digitale a 7 segmenti, LED, barra LED, anello di avanzamento, serbatoio e simbolo di processo. VU meter, orologio, bussola e annunciatore sono Registered.
Leggi l'argomento della guida
Strumenti e scale
Un operatore legge un gauge a colpo d'occhio solo quando verde, ambra e rosso indicano dove dovrebbe trovarsi il valore. Dai a una scala un minimo e un massimo qualsiasi, imposta l'intervallo principale e i segni secondari e aggiungi intervalli colorati per le fasce che contano. Gli intervalli hanno spessore e didascalia propri, e la scala può andare al contrario o mettere i segni all'interno o all'esterno. Gli intervalli sono disegnati sulla scala stessa, quindi compaiono anche nell'output PNG e SVG e in entrambi i temi senza lavoro extra.
Scales[0].Ranges.Add con StartValue, EndValue, Color, Thickness e CaptionTsgcGaugeScale: Minimum, Maximum, MajorInterval, MinorCount, ReversedLabelFormat e ShowLabels per le etichette della scalaStartAngle e SweepAngle definiscono l'arco di un gauge radiale
Strumenti e scale
Livelli, temperature e avanzamento rispetto a un obiettivo sono lineari per natura. Un gauge lineare disegna tre stili: una barra semplice, un termometro con bulbo e un bullet graph che confronta il valore con un indicatore di obiettivo. Mettilo in orizzontale o in verticale per adattarlo a un serbatoio, a una barra laterale o a una riga di tabella. L'obiettivo del bullet è una proprietà, non una lancetta aggiuntiva, quindi il bullet graph funziona anche nell'edizione Community gratuita. Un gauge piccolo sta in una cella di griglia o in un tile di dashboard.
LinearStyle: glsBar, glsThermometer o glsBulletTarget disegna l'indicatore di obiettivo del bullet, in ogni edizioneOrientation e BulbSize
Strumenti e scale Solo Registered
Alcune letture hanno senso solo affiancate: valore effettivo e obiettivo, ingresso e uscita, ore e minuti. Un gauge può avere più di una scala e più di una lancetta, e ogni lancetta sceglie la propria scala e il proprio stile: un ago, un indicatore o una barra. Le soglie possono controllare qualsiasi lancetta. Un quadrante a doppia lancetta fa risparmiare spazio nei pannelli affollati e rende subito visibile la differenza tra obiettivo e valore effettivo.
Pointers di TsgcGaugePointer con Kind, NeedleStyle, MarkerShape e ScaleIndexScales con Radius e Offset per ogni scalaPointerIndex su soglie e collegamenti ai feedCommunity disegna una scala e una lancetta per gauge; l'edizione Registered le disegna tutte.
Leggi l'argomento della guidaStrumenti e scale
Una schermata di processo mostra recipienti e apparecchiature, non solo quadranti. Il gauge serbatoio disegna un recipiente con il suo livello e i segni dei quattro limiti ISA, HH, H, L e LL, e un'isteresi mantiene lo stato di un limite finché il livello non se ne allontana. Il gauge con simboli di processo disegna una valvola, una pompa, un motore, un ventilatore, uno scambiatore di calore o un sensore nel suo stato: spento, acceso, guasto, aperto, chiuso o in transito. Una pompa o un ventilatore in funzione ruota, un guasto lampeggia con un segno e una valvola in transito ha il contorno tratteggiato, così l'operatore non legge mai lo stato dal solo colore.
TsgcVCLTankGauge: Shape (verticale, orizzontale, fondo conico o sfera), LimitHH, LimitH, LimitL, LimitLL, LimitHysteresis, LimitStateTsgcVCLSymbolGauge: Kind, State, Rotation, SpinPeriod, FlashIntervalValueMap per i codici d'impiantoIl serbatoio e il simbolo di processo sono in ogni edizione, Community compresa. I loro feed live tramite il ponte sono Registered. Entrambi fanno parte del pacchetto HMI di sgcUI, insieme ai simboli P&ID, a un elenco allarmi ISA-18.2 e a un NumPad touch.
Leggi l'argomento della guidaGauge che reagiscono: soglie, animazione, display industriali e feed live.
Allarmi, movimento e dati live
Una pressione che oscilla attorno al limite non deve far scattare cento allarmi al minuto. Una soglia ha un valore, una direzione e una banda di isteresi: scatta una sola volta quando il valore la attraversa e si riarma solo dopo che il valore è tornato indietro della banda. OnThreshold gira sempre nel thread principale, qualunque thread abbia scritto il valore, così puoi accendere un LED o mostrare un messaggio direttamente. Ogni soglia può controllare una lancetta diversa, quindi un gauge può generare un allarme di massimo sul valore effettivo e uno di minimo su una seconda lettura.
Thresholds di TsgcGaugeThreshold con Value, Hysteresis e DirectiongtdRising, gtdFalling o gtdBothValueColor ricolora il testo del valore mentre la soglia è attivaAllarmi, movimento e dati live
Una lancetta che salta sembra rotta, una che scivola sembra uno strumento. Ogni nuovo valore si anima dal precedente per una durata a tua scelta, con una di cinque curve di easing, così un cambiamento improvviso è facile da seguire e un feed live non sfarfalla mai. Disattiva l'animazione per i banchi di prova che richiedono subito il valore grezzo. OnChange ti dice quando il valore è cambiato, indipendentemente dall'animazione sullo schermo.
Animation (TsgcGaugeAnimation) con Enabled e Duration, 300 ms per impostazione predefinitaEasing: geLinear, geQuadOut, geCubicOut, geCubicInOut, geBackOutIsAnimating indica se una lancetta si sta ancora muovendo
Allarmi, movimento e dati live
I pannelli di controllo parlano un linguaggio visivo tutto loro. Il gauge digitale disegna cifre a 7 segmenti, a 14 segmenti o a matrice di punti, con segmenti fantasma e inclinazione opzionali. I LED lampeggiano, la barra LED mantiene il picco e l'annunciatore mostra un pannello di tile di allarme che lampeggiano finché un operatore non li riconosce. Ognuno di questi display ha le stesse scale, soglie e temi degli altri gauge, quindi gli allarmi funzionano ovunque allo stesso modo.
TsgcVCLDigitalGauge: DisplayType, Digits, ShowGhost, SkewTsgcVCLLEDGauge con Blink e BlinkInterval; TsgcVCLLEDBarGauge con PeakHoldTsgcVCLAnnunciatorGauge: Tiles, FlashInterval, Acknowledge, AcknowledgeAllCommunity ha cifre a 7 segmenti, LED e la barra LED. I display a 14 segmenti e a matrice di punti e l'annunciatore sono Registered.
Leggi l'argomento della guidaAllarmi, movimento e dati live Solo Registered
In una console IoT la maggior parte del codice è di raccordo: sottoscrivere, analizzare, trovare il gauge, impostare il valore. Il ponte sgcGaugesWS lo elimina. Una sorgente di feed si collega a un client sgcWebSockets e ogni collegamento associa un topic e un percorso JSON a una lancetta di gauge. Sono supportati i filtri di topic MQTT con + e #, e un percorso di filtro seleziona un dispositivo da uno stream condiviso. Più collegamenti possono condividere una sola sorgente, quindi un'unica connessione al broker governa un intero pannello.
TsgcGaugeFeedSource_MQTT, TsgcGaugeFeedSource_WebSocket, TsgcGaugeFeedSource_SSEBindings di TsgcGaugeFeedBinding: Gauge, PointerIndex, Topic, ValuePathFilterPath e FilterValue selezionano i messaggiOnValue e OnError sulla sorgenteValueMap trasforma i codici d'impianto, come un bit del PLC o RUNNING, negli stati di un simbolo di processoIl ponte richiede sgcWebSockets. In Community, imposta Value dal tuo codice; è sicuro da un thread in background.
Leggi l'argomento della guidaLo stesso gauge su un server e in qualsiasi tema.
Output e aspetto
I gauge servono anche fuori dallo schermo: in un report di turno, in un'e-mail di stato o in una pagina web servita dal tuo backend. Ogni modello di gauge e ogni controllo si salva da solo in PNG o SVG senza form, così un programma console, un servizio Windows o un server Linux64 può generare lo stesso strumento che vede l'operatore. Larghezza, altezza e scala sono parametri, quindi una chiamata produce una miniatura per un elenco e un'altra un'immagine 2x nitida per un report.
SaveToPNG e SaveToSVG su ogni modello e controlloTsgcRadialGauge e TsgcLinearGauge
Output e aspetto
Una sala di controllo abbassa la luminosità degli schermi di notte, un ufficio preferisce un aspetto luminoso. Una sola proprietà fa passare un gauge dal tema chiaro a quello scuro, e i colori di quadrante, scala, etichette e valore seguono. I gauge usano lo stesso tipo di tema di ogni prodotto sgcUI, quindi cambiano insieme a dashboard, grafici e griglie. Gli intervalli mantengono i propri colori in entrambi i temi, così il verde significa ancora normale anche di notte. La proprietà FormatSettings fissa il separatore decimale della lettura indipendentemente dalle impostazioni locali dell'utente.
Theme := utDark o utLightFaceColor, BackgroundColor e i font si possono ancora impostare per ogni gaugeTitle, Units e ValueFormat per la letturaOnFormatValue per formattare tu stesso il testo del valoreL'anteprima mostra esattamente ciò che ricevono la stampante e il PDF.
Stampa, anteprima e PDF
Un gauge viene stampato in una pagina come sullo schermo, con le sue scale, intervalli, soglie, lancette e testi. Viene stampato al suo valore finale, quindi un'animazione in corso non compare mai a metà sulla carta, e continua a girare sullo schermo.
Print mostra la finestra di stampa o stampa direttamente sulla stampante predefinita, e ShowPrintPreview apre un'anteprima con navigazione tra le pagine, zoom, impostazione della pagina, stampa ed esportazione PDFPrintSettings contiene la carta, l'orientamento, i margini, la scala e il testo dell'intestazione e del piè di pagina, e la stampante, l'anteprima e il PDF li usano tuttiExportToPDF scrive il gauge come grafica vettoriale con testo reale, PDF/UA con tag per impostazione predefinita, con un testo alternativo che legge la didascalia, il valore con la sua unità e l'intervalloPDFALevel di TsgcUIPDFOptions aggiunge PDF/A-2a o PDF/A-3a per l'archiviazione, da solo o insieme a PDF/UALa stampa e l'anteprima sono in tutte le edizioni, compresa l'edizione Community gratuita, su VCL, FireMonkey, WinForms, WPF e Avalonia. In FireMonkey la stampa funziona su Windows e macOS, e l'anteprima e l'esportazione PDF su tutte le piattaforme. L'esportazione PDF richiede il ponte sgcUIPDF e uno sgcPDF con licenza (il pacchetto NuGet esegece.sgcUICore.sgcPDF in .NET), quindi non è nell'edizione Community.
UI Automation per screen reader e alto contrasto, senza alcuna configurazione.
Accessibilità
Ogni tipo di gauge espone la sua didascalia, il suo valore e il suo intervallo a Microsoft UI Automation, e le soglie vengono segnalate come annunci. Il gauge si descrive con lo stesso testo alternativo che scrive in un PDF accessibile.
TabStop a True quando gli utenti da tastiera devono arrivare su un gaugeL'accessibilità è attiva per impostazione predefinita in tutte le edizioni, compresa l'edizione Community gratuita, su VCL in ogni versione di Delphi e C++Builder da Delphi 7 a Delphi 13, su FireMonkey su Windows e su WinForms, WPF e Avalonia. In Delphi e C++Builder, AccessibleName e AccessibleDescription impostano il nome e la descrizione esposti a UI Automation, e in .NET il nome accessibile e il testo della guida standard di ciascun framework fanno lo stesso. Vedi i report di conformità sull'accessibilità.
sgcGauges nelle demo della suite sgcUI: applicazioni complete che funzionano offline con dati simulati integrati.
Indicatori radiali, lineari e LED per ogni lettura di una pompa.
Altamira Plant →
Indicatori di velocità, bussola e temperatura del frigo di un camion.
Altamira Fleet →
Un indicatore radiale del VaR, barre di esposizione, un anello di avanzamento e tessere di allarme lampeggianti.
Altamira Markets →
Un indicatore radiale dell'obiettivo trimestrale e indicatori lineari per regione.
Altamira ERP →
Un HMI di impianto mostra due serbatoi con gauge di livello, LED delle pompe, quadranti di pressione con fasce rosse e un pannello annunciatore per gli allarmi. Le soglie con isteresi generano ogni allarme una sola volta, l'annunciatore lampeggia finché l'operatore non lo riconosce e il turno di notte passa al tema scuro.
Una console di telemetria si sottoscrive a un broker e mostra sei letture live da dispositivi sul campo. I collegamenti associano ogni topic e campo JSON a una lancetta, le lancette scivolano verso ogni nuovo valore e non si scrive a mano alcun codice di gestione dei messaggi. Gli stessi gauge vengono generati in PNG per l'e-mail di stato giornaliera.
Una dashboard direzionale mette i gauge nei tile accanto a schede KPI e grafici: l'utilizzo come anello di avanzamento, il tempo di consegna come bullet graph rispetto all'obiettivo e il livello di servizio come quadrante con fasce colorate. Tutto segue una sola proprietà del tema e i gauge si adattano alle dimensioni dei loro tile.
La stessa API in Delphi, C++ Builder e C#: un gauge radiale di pressione con una fascia rossa e una soglia di allarme, un gauge di livello bullet e un LED di allarme lampeggiante.
Un gauge radiale di pressione con una fascia rossa e una soglia di allarme, un gauge di livello bullet e un LED di allarme lampeggiante su un form VCL.
uses
SysUtils, Classes, Controls, Forms, sgcUICore_Theme,
sgcGauges_Types, sgcGauges_Model, sgcGauges_VCL;
type
TTankPanel = class(TComponent)
public
Pressure: TsgcVCLRadialGauge;
Level: TsgcVCLLinearGauge;
Alarm: TsgcVCLLEDGauge;
procedure PressureThreshold(Sender: TObject; aThreshold: TsgcGaugeThreshold;
aValue: Double; aRising: Boolean);
end;
procedure TTankPanel.PressureThreshold(Sender: TObject;
aThreshold: TsgcGaugeThreshold; aValue: Double; aRising: Boolean);
begin
// runs in the main thread, whatever thread wrote the value
Alarm.Active := aRising;
end;
function CreateTankPanel(aForm: TForm): TTankPanel;
begin
Result := TTankPanel.Create(aForm);
Result.Pressure := TsgcVCLRadialGauge.Create(aForm);
Result.Pressure.Parent := aForm;
Result.Pressure.SetBounds(16, 16, 240, 240);
Result.Pressure.Title := 'Pressure';
Result.Pressure.Units := 'bar';
Result.Pressure.Theme := utDark;
Result.Pressure.Scales[0].Maximum := 10;
Result.Pressure.Scales[0].MajorInterval := 2;
with Result.Pressure.Scales[0].Ranges.Add do
begin
StartValue := 8;
EndValue := 10;
Color := $FFE34948;
end;
with Result.Pressure.Thresholds.Add do
begin
Value := 8;
Hysteresis := 0.5;
Direction := gtdBoth;
end;
Result.Pressure.Animation.Easing := geCubicOut;
Result.Pressure.OnThreshold := Result.PressureThreshold;
Result.Level := TsgcVCLLinearGauge.Create(aForm);
Result.Level.Parent := aForm;
Result.Level.SetBounds(272, 16, 320, 110);
Result.Level.Title := 'Tank level';
Result.Level.Units := '%';
Result.Level.LinearStyle := glsBullet;
Result.Level.Target := 80;
Result.Alarm := TsgcVCLLEDGauge.Create(aForm);
Result.Alarm.Parent := aForm;
Result.Alarm.SetBounds(272, 140, 64, 64);
Result.Alarm.OnColor := $FFE34948;
Result.Alarm.Blink := True;
Result.Level.Value := 62;
Result.Pressure.Value := 6.5;
// the same drawing code exports the gauge to PNG at twice its size
Result.Pressure.SaveToPNG(ExtractFilePath(ParamStr(0)) + 'pressure.png', 2);
end;Lo stesso pannello in C++ Builder con gli header generati.
#include <vcl.h>
#include "sgcUICore_Theme.hpp"
#include "sgcGauges_Types.hpp"
#include "sgcGauges_Model.hpp"
#include "sgcGauges_VCL.hpp"
class TTankPanel : public TObject
{
public:
TsgcVCLRadialGauge *Pressure;
TsgcVCLLinearGauge *Level;
TsgcVCLLEDGauge *Alarm;
void __fastcall PressureThreshold(TObject *Sender,
TsgcGaugeThreshold *aThreshold, double aValue, bool aRising);
};
void __fastcall TTankPanel::PressureThreshold(TObject *Sender,
TsgcGaugeThreshold *aThreshold, double aValue, bool aRising)
{
// runs in the main thread, whatever thread wrote the value
Alarm->Active = aRising;
}
TTankPanel * __fastcall CreateTankPanel(TForm *Form)
{
TTankPanel *P = new TTankPanel();
P->Pressure = new TsgcVCLRadialGauge(Form);
P->Pressure->Parent = Form;
P->Pressure->SetBounds(16, 16, 240, 240);
P->Pressure->Title = "Pressure";
P->Pressure->Units = "bar";
P->Pressure->Theme = utDark;
P->Pressure->Scales->Items[0]->Maximum = 10;
P->Pressure->Scales->Items[0]->MajorInterval = 2;
TsgcGaugeRange *R = P->Pressure->Scales->Items[0]->Ranges->Add();
R->StartValue = 8;
R->EndValue = 10;
R->Color = 0xFFE34948;
TsgcGaugeThreshold *T = P->Pressure->Thresholds->Add();
T->Value = 8;
T->Hysteresis = 0.5;
T->Direction = gtdBoth;
P->Pressure->Animation->Easing = geCubicOut;
P->Pressure->OnThreshold = P->PressureThreshold;
P->Level = new TsgcVCLLinearGauge(Form);
P->Level->Parent = Form;
P->Level->SetBounds(272, 16, 320, 110);
P->Level->Title = "Tank level";
P->Level->Units = "%";
P->Level->LinearStyle = glsBullet;
P->Level->Target = 80;
P->Alarm = new TsgcVCLLEDGauge(Form);
P->Alarm->Parent = Form;
P->Alarm->SetBounds(272, 140, 64, 64);
P->Alarm->OnColor = 0xFFE34948;
P->Alarm->Blink = true;
P->Level->Value = 62;
P->Pressure->Value = 6.5;
// the same drawing code exports the gauge to PNG at twice its size
P->Pressure->SaveToPNG(ExtractFilePath(ParamStr(0)) + "pressure.png", 2);
return P;
}La versione WinForms in C#, con gli stessi nomi di classe di Delphi.
using System;
using System.Drawing;
using System.Windows.Forms;
using esegece.sgcGauges;
using esegece.sgcUICore;
public class TankForm : Form
{
private readonly TsgcWinFormsRadialGauge pressure;
private readonly TsgcWinFormsLinearGauge level;
private readonly TsgcWinFormsLEDGauge alarm;
public TankForm()
{
ClientSize = new Size(610, 270);
pressure = new TsgcWinFormsRadialGauge { Bounds = new Rectangle(10, 10, 240, 240) };
pressure.Title = "Pressure";
pressure.Units = "bar";
pressure.Theme = TsgcUITheme.utDark;
pressure.Scales[0].Maximum = 10;
pressure.Scales[0].MajorInterval = 2;
TsgcGaugeRange red = pressure.Scales[0].Ranges.Add();
red.StartValue = 8;
red.EndValue = 10;
red.Color = 0xFFE34948;
TsgcGaugeThreshold limit = pressure.Thresholds.Add();
limit.Value = 8;
limit.Hysteresis = 0.5;
limit.Direction = TsgcGaugeThresholdDirection.gtdBoth;
pressure.Animation.Easing = TsgcGaugeEasing.geCubicOut;
level = new TsgcWinFormsLinearGauge { Bounds = new Rectangle(260, 10, 340, 110) };
level.Title = "Tank level";
level.Units = "%";
level.LinearStyle = TsgcGaugeLinearStyle.glsBullet;
level.Target = 80;
alarm = new TsgcWinFormsLEDGauge { Bounds = new Rectangle(260, 130, 64, 64) };
alarm.OnColor = 0xFFE34948;
alarm.Blink = true;
// OnThreshold runs in the UI thread, whatever thread wrote the value
pressure.OnThreshold = (sender, threshold, value, rising) => alarm.Active = rising;
Controls.AddRange(new Control[] { pressure, level, alarm });
level.Value = 62;
pressure.Value = 6.5;
}
}dotnet add package esegece.sgcGauges.WinFormsGallery, GalleryFMX, Headless, HMIPanel, DashboardGauges e MQTTLive per Delphi e C++ Builder. Le demo .NET sono Gallery (WinForms), GalleryWpf, GalleryAvalonia, ConsoleRender, HMIPanel e MQTTLive.
Dieci gauge con cambio di tema, animazione, una modalità di simulazione, una soglia a 200 km/h con LED di allarme, riconoscimento dell'annunciatore ed esportazione PNG a 2x, più i gauge di input manopola, cursore, interruttore e pulsante.
Due serbatoi con pompe, livelli, pressioni e allarmi dell'annunciatore, il layout di una tipica schermata di processo.
Sei gauge nei tile di sgcDashboard, che seguono il tema della dashboard. Compila con l'edizione Community.
Un programma console che scrive PNG e SVG su Win32, Win64 e Linux64.
La galleria su FireMonkey, per Windows e Android.
Sei gauge alimentati da MQTT tramite il ponte sgcGaugesWS. Richiede sgcWebSockets e un broker.
Eseguibili pronti all'uso di ogni prodotto sgcUI, senza nulla da installare.
Scarica sgcUI_bin.zip →Cinque demo QuickStart per Delphi (VCL) si trovano in Demos\Gauges\Delphi\00.QuickStart. La guida PDF le spiega passo dopo passo: un primo indicatore radiale, scale e intervalli colorati, allarmi di soglia, temi e skin, e un monitor per stazione di pompaggio.
sgcGauges è nelle edizioni sgcUI Professional ed Enterprise e si vende anche da solo. sgcGauges è incluso anche nel bundle All-Access.
€199 / sviluppatore, codice sorgente completo, 1 anno di aggiornamenti.
Acquista sgcGauges → Vedi i prezzi →L'edizione Community gratuita (esegece.sgcGauges.Community su NuGet) ha i gauge radiale, lineare, digitale a 7 segmenti, LED, barra LED e anello di avanzamento con intervalli, soglie, animazione, temi e output headless. Non ha VU meter, orologio, bussola o annunciatore, né scale o lancette aggiuntive, né il ponte sgcGaugesWS.
| Funzionalità | Community (gratuita) | Registered |
|---|---|---|
| Radiale, lineare, digitale a 7 segmenti, LED, barra LED e anello di avanzamento | ✓ | ✓ |
| Intervalli, soglie, animazione e temi | ✓ | ✓ |
| Output PNG e SVG headless | ✓ | ✓ |
| VU meter, orologio, bussola e annunciatore | − | ✓ |
| Più scale e lancette per gauge | − | ✓ |
| Display a 14 segmenti e a matrice di punti | − | ✓ |
| Ponte sgcGaugesWS (MQTT, WebSocket, SSE) | − | ✓ |
Ogni gauge ha un modello indipendente dal framework per il rendering headless, un controllo VCL (usato anche da C++ Builder), un controllo FireMonkey e controlli WinForms, WPF e Avalonia.
| Gauge | VCL e C++ Builder | FireMonkey | .NET |
|---|---|---|---|
| Radiale | TsgcVCLRadialGauge | TsgcFMXRadialGauge | TsgcWinFormsRadialGauge |
| Lineare (barra, termometro, bullet) | TsgcVCLLinearGauge | TsgcFMXLinearGauge | TsgcWpfLinearGauge |
| Digitale (7 segmenti, 14 segmenti, matrice di punti) | TsgcVCLDigitalGauge | TsgcFMXDigitalGauge | TsgcWinFormsDigitalGauge |
| LED | TsgcVCLLEDGauge | TsgcFMXLEDGauge | TsgcWinFormsLEDGauge |
| Barra LED | TsgcVCLLEDBarGauge | TsgcFMXLEDBarGauge | TsgcWinFormsLEDBarGauge |
| Anello di avanzamento | TsgcVCLProgressRingGauge | TsgcFMXProgressRingGauge | TsgcWinFormsProgressRingGauge |
| Serbatoio | TsgcVCLTankGauge | TsgcFMXTankGauge | TsgcWpfTankGauge |
| Simbolo di processo | TsgcVCLSymbolGauge | TsgcFMXSymbolGauge | TsgcAvaloniaSymbolGauge |
| VU meter | TsgcVCLVUMeterGauge | TsgcFMXVUMeterGauge | TsgcWinFormsVUMeterGauge |
| Orologio | TsgcVCLClockGauge | TsgcFMXClockGauge | TsgcWinFormsClockGauge |
| Bussola | TsgcVCLCompassGauge | TsgcFMXCompassGauge | TsgcWpfCompassGauge |
| Annunciatore | TsgcVCLAnnunciatorGauge | TsgcFMXAnnunciatorGauge | TsgcAvaloniaAnnunciatorGauge |
La colonna .NET mostra un esempio per gauge, ogni gauge esiste come TsgcWinForms, TsgcWpf e TsgcAvalonia. Tutti i gauge condividono la classe base TsgcCustomGauge con le collezioni Scales, Pointers, Thresholds e Ranges. I modelli indipendenti dal framework (TsgcRadialGauge, TsgcLinearGauge e così via) generano l'output senza finestra.
| Target | Componente | Piattaforme |
|---|---|---|
| Delphi 7 a 13, VCL | Gauge TsgcVCL | Win32, e Win64 da XE2 |
| Delphi XE6 a 13, FireMonkey | Gauge TsgcFMX | Windows, macOS, iOS e Android |
| C++ Builder 2007 a 13 | Gauge TsgcVCL | Header .hpp generati e librerie statiche |
| Delphi 10.2 a 13, indipendente dal framework | Modelli di gauge e output PNG e SVG headless | Linux64 (nessun controllo per Linux) |
| .NET Framework 4.7.2, .NET 8, 9 e 10 | Gauge WinForms, WPF e Avalonia | Desktop Windows, target Avalonia, rendering headless |
Sì. Imposta Value dal thread che riceve i dati. Le soglie vengono valutate al posto tuo e OnThreshold scatta sempre nel thread principale, quindi un gestore può aggiornare i controlli senza sincronizzazione aggiuntiva. Il ponte sgcGaugesWS fa lo stesso quando alimenta le lancette da MQTT, WebSocket o SSE.
I gauge radiale, lineare, digitale a 7 segmenti, LED, barra LED, anello di avanzamento, serbatoio e simbolo di processo, con intervalli, soglie, animazione, temi e output headless. VU meter, orologio, bussola, annunciatore, scale e lancette aggiuntive, cifre a 14 segmenti e a matrice di punti e il ponte sono Registered. Vedi Editions.
Sì, con l'edizione Registered e sgcWebSockets. Trascina un TsgcGaugeFeedSource_MQTT, collega il tuo client MQTT e aggiungi un collegamento per ogni gauge con il Topic e il ValuePath JSON. I filtri di topic con + e # funzionano, e FilterPath sceglie un dispositivo da un topic condiviso.
I controlli FireMonkey funzionano da Delphi XE6 e la demo GalleryFMX gira su Windows e Android. Su Linux64 sgcGauges è solo headless: i modelli si compilano e generano PNG e SVG da Delphi 10.2, ma non ci sono controlli per Linux.
Sì. Ogni scala ha i propri Minimum, Maximum, MajorInterval e segni secondari, e un numero qualsiasi di intervalli colorati con inizio, fine, colore, spessore e didascalia. Un gauge radiale ti permette anche di scegliere l'angolo di partenza e l'ampiezza dell'arco.
Sì. SaveToPNG e SaveToSVG funzionano su ogni controllo e su ogni modello, senza finestra, così un servizio o un server Linux64 può inserire le letture correnti in un PDF o in un'e-mail. La demo Gallery esporta anche PNG a 2x.
Il gauge digitale si dimensiona in base alla scala: con Digits a 0 riserva tutte le cifre che servono al massimo della scala, e la scala predefinita va da 0 a 100. Imposta Scales[0].Maximum al valore più grande che prevedi, oppure imposta Digits in modo esplicito.
Introduzione, Tipi di gauge, Quick Start VCL, Soglie, Animazione, Intervalli, Gauge radiale, Ponte sgcGaugesWS, Rendering headless, Edizioni.
Delphi, C++ Builder e .NET, che coprono ogni prodotto sgcUI.
Metti i gauge nei tile della dashboard accanto alle schede KPI; la demo DashboardGauges mostra come.
Scopri sgcDashboard →
Mostra l'andamento dietro ogni lettura con un grafico live accanto al gauge.
Scopri sgcCharts →
Lascia che gli operatori impostino limiti e valori di riferimento con cursori e spin edit.
Scopri sgcEditors →Alimenta i gauge da MQTT, WebSocket o SSE con il ponte sgcGaugesWS.
Scopri sgcWebSockets →