Modulo Fast Message Producer "fmproducer"
Descrizione
Quasi tutte le fonti di dati nella tecnica di processo trasmettono i dati in campi di dati compattati di byte. Il contenuto ed eventualmente anche la lunghezza di questi pacchetti sono identificabili tramite un messageKey (o anche "ID"). Nella tabella seguente sono riportati alcuni esempi.
| Protocollo | Message Key | Lunghezza della chiave |
|---|---|---|
| CAN-Bus | CAN-ID | 11 o 29 bit |
| MVB-Bus | Numero di porta | 12 bit |
| ProfiBus | Slave-Node ID | 7 bit |
| Modbus | Register, Coil, Input, Status | 2 + 16-bit |
Diversi plug-in smartCORE (ad es. fmudp, canbus, smartmvb) realizzano il collegamento dell'hardware tramite interfacce dedicate, ricevono o inviano pacchetti di dati e con i pacchetti ricevuti alimentano il cosiddetto Fast Message Dispatcher (FMD). Questo mette a disposizione in smartCORE una tecnologia efficiente per estrarre, da fonti di dati qualsiasi e secondo uno schema sempre ricorrente, dati di misura e informazioni di stato e produrli in singoli canali smartCORE (da cui il nome "fm Producer").
I moduli di interfaccia creano almeno un'istanza di un FMD con il proprio nome. Questo viene collegato nell'fmProducer tramite la proprietà fmd.
Nei pacchetti ricevuti sono contenuti, oltre al MessageID e a un timestamp, i dati in un campo di dati composto da byte. Per un canale, i dati si trovano al suo interno a partire da un determinato bitOffset con una bitLength definita. Hanno inoltre rilevanza la disposizione dei byte byteOrder nel buffer e (purtroppo) la addressSpec(ification), con cui viene stabilito come vengono contati i bit nel buffer.
Dopo che i byte dei dati grezzi sono stati portati nell'ordine corretto e il valore è stato correttamente spostato e mascherato, avviene l'interpretazione tramite l'imageType. Il numero ha il segno oppure no? Il numero va letto come BCD (Binary Coded Decimal) o come valore polare (virgola fissa)? Intero, virgola mobile o addirittura testo?
Dopo una scalatura opzionale a una grandezza di misura fisica (scale, offset, physicalUnit) secondo
avviene la produzione del valore dei dati nel canale smartCORE con il timestamp (di ricezione) trasmesso anch'esso dal modulo di interfaccia.
Interfacce e protocolli utilizzati
- Fast Message Dispatching
Configurazione JSON
Nella sezione seguente viene descritta l'intera configurazione JSON del modulo e vengono illustrati i singoli parametri.
Configurazione di esempio (minima)
{
"module":"FmProducer",
"factory":"fmproducer",
"config":{
"fmd":"FastMessageDispatcher",
"channels":[
{
"name":"Channel",
"messageKey":42,
"bitOffset":0,
"bitLength":32,
"imageType":"float"
},
[...]
]
}
}
Configurazione di esempio (massima)
{
"module":"FmProducerSmartMVB",
"factory":"fmproducer",
"config":{
"fmd":"smartmvb0",
"bufferSize":1024,
"namespace":["directory","subDirectory"],
"channelPrefix":"SmartMVB",
"addressSpec": "EN61375_MVB",
"byteOrder": "bigEndian",
"channels":[
{
"name":"SmartMVBmessageData",
"bufferSize":1024,
"scale":3.14,
"offset":2.72,
"physicalDimension":"Length",
"physicalUnit":"m",
"messageKey":10012,
"bitOffset":0,
"bitLength":20,
"imageType":"unsigned",
"addressSpec": "AscendingFirstBit",
"byteOrder": "littleEndian",
"absoluteTolerance":0.5
},
[...]
]
}
}
Parametri globali del modulo
| Nome del parametro | Obbligatorio | Tipo di dati | Intervallo di valori sensato | Default | Descrizione |
|---|---|---|---|---|---|
| fmd | SÌ | STRING | Fast Message Dispatcher del modulo di invio | ||
| bufferSize | No1 | INT | 1 - | 1024 | (default) Dimensione del buffer dei canali creati |
| channelPrefix | No | STRING | Prefisso del canale (opportuno se vengono utilizzati più moduli fmproducer e le configurazioni hanno nomi di canale sovrapposti) | ||
| namespace | No | ARRAY [STRING] | Prefisso del canale sotto forma di namespace concatenati gerarchicamente | ||
| addressSpec | No | STRING | "EN61375_MVB" | Schema di indirizzamento predefinito | |
| byteOrder | No | STRING | "BigEndian" | Ordine dei byte predefinito | |
| channels | SÌ | JSON Array | Elenco di JSON Object dei canali configurati |
Configurazione di un canale (JSON Object)
| Nome del parametro | Obbligatorio | Tipo di dati | Intervallo di valori sensato | Default | Descrizione |
|---|---|---|---|---|---|
| Filter | |||||
| messageKey | No2 | UINT | ID del messaggio ricevuto (ad es. Message ID del CAN-Bus, porta MVB, ...) | ||
| Process Image | |||||
| addressSpec | No | STRING | (valore dall'impostazione globale) | Schema di indirizzamento, vedere la descrizione seguente | |
| byteOrder | No | STRING | "BigEndian", "LittleEndian", "[A-Z]+" | (valore dall'impostazione globale) | Ordine dei byte del valore memorizzato, vedere la descrizione seguente |
| imageType | SÌ | STRING | tipo di dati di origine supportato del valore memorizzato (vedere sotto) | ||
| bitOffset | SÌ | UINT | Offset in bit del valore memorizzato nel messaggio | ||
| bitLength | No3 | UINT | Lunghezza in bit del valore memorizzato nel messaggio | ||
| stringHint | No4 | STRING | Indicazione per la determinazione della lunghezza della stringa (vedere sotto) | ||
| stringEncoding5 | No4 | STRING | nome IANA, ad es. "UTF-8", "windows-1252" | 6 | Codifica dei caratteri della stringa nel pacchetto di dati (vedere sotto) |
| timeFix5 | No7 | STRING | "RFC4330", "RFC5905" | "RFC4330" | Gestione del superamento di time64 nel 2036 (vedere sotto) |
| scale | No8 | FLOAT | 1 | Fattore di scalatura del valore prodotto | |
| offset | No8 | FLOAT | 0 | offset additivo del valore prodotto | |
| smartCORE | |||||
| name | SÌ | STRING | Nome del canale | ||
| dataType | No9 | STRING | Tipo di dati del canale | ||
| bufferSize | No1 | INT | 1 - | 1024 | Dimensione del buffer del canale creato |
| physicalDimension | No | STRING | grandezza fisica | ||
| physicalUnit | No | STRING | unità fisica | ||
| noFilter | No | BOOL | false | Disattiva il filtro DataReduction | |
| absoluteTolerance | No | FLOAT | 0.0 | Tolleranza assoluta per il filtro DataReduction | |
| cacheSize | No10 | INT | 0 | Numero di campioni di dati che vengono memorizzati in una cache locale del canale prima di essere pubblicati per altri moduli. | |
| Riservato | |||||
| debug | No | BOOL | false | Abilita le uscite di debug per il canale. | |
| numElements | No | INT | 1 | Lunghezza di un campo di dati in multipli dell'elemento di base |
Specifiche di indirizzo 'addressSpec'
Perché deve essere stabilito uno schema di indirizzamento?
L'fmproducer scompone il pacchetto di dati ricevuto da un dispositivo esterno. La specifica di questo dispositivo e dell'interfaccia utilizzata stabilisce come localizzare i singoli canali di dati nel flusso di dati. Esistono purtroppo molte varianti, perché, nonostante la standardizzazione, in determinati ambiti esistono ancora numerose implementazioni proprietarie.
La specifica di indirizzo addressSpec stabilisce con quale modalità di conteggio il MSBit o il LSBit sono indicati nel bitOffset. Per motivi storici (l'fmProducer è stato sviluppato dapprima per l'MVB) l'impostazione EN61375_MVB è anche l'impostazione predefinita.
Valori impostabili
Se non diversamente indicato, viene indirizzata la posizione del primo bit (Msb/Lsb a seconda del byteOrder). L'indicazione della addressSpec non ha alcuna funzione se come byteOrder viene selezionato un mapping libero.
| Enum | Alias | Descrizione |
|---|---|---|
| EN61375_MVB | MVB EN61375 RevNum ReversedNum ReversedForMsbNumerics | Segue rigorosamente la EN61375 per quanto riguarda ByteOrder, tipi di dati, allineamento e conteggio dei bit. - Il bitOffset è byteOffset * 8 + rightShift - Le configurazioni non conformi vengono rifiutate. |
| ReversedForMsb | Rev Reversed | 11 Per tutti i segnali i bit vengono contati in ordine inverso (Motorola). |
| AscendingFirstBit | DBC | Per tutti i segnali i bit vengono contati con significato crescente. |
| AscendingLSBit | positionLsb | Per tutti i segnali i bit vengono contati con significato crescente. Viene sempre indirizzata la posizione del LSBit. |
| AscendingMSBit | positionMsb | Per tutti i segnali i bit vengono contati con significato crescente. Viene sempre indirizzata la posizione del MSBit. |
Definizione della posizione dell'immagine per EN61375_MVB
Nella norma EN 61375-2-1, a partire dal §6.4.2, sono presenti diverse indicazioni su come devono essere trasmessi i dati sull'MVB. Determinati casi sono esclusi a priori. I canali con una configurazione non conforme vengono segnalati dall'fmproducer, a partire da smartCORE 2.10.1, come errore nel file di log e bloccati per l'elaborazione.
-
(ipotesi e zona grigia)12 La norma non definisce tipi di dati che non abbiano una lunghezza pari a una potenza di 2 esatta. Un valore numerico con un'altra bitLength viene elaborato, ma segnalato all'avvio con un avviso nel file di log. Sono esclusi gli imageType la cui lunghezza è definita dal tipo stesso (ad es. timedate48).
-
Il bitOffset non si riferisce quindi in modo coerente al MSBit o al LSBit di una variabile, ma o al primo byte (intero) oppure al LSbit in un byte per
-
La rappresentazione è sempre BigEndian. Le disposizioni LittleEndian sono pertanto escluse.
-
La posizione dell'immagine deve essere sempre allineata a un multiplo della sua dimensione nel buffer dei dati. I tipi di dati con lunghezza di 1, 2 o 4 bit possono quindi trovarsi esclusivamente all'interno di un byte. Tutti gli altri con lunghezza di 8, 16, 32, 64 bit devono essere obbligatoriamente allineati a un byte. Uno spostamento dell'immagine non è ammesso! => a partire da .
-
Un valore inferiore a 8 bit inizia e termina nello stesso byte. Ciò vale anche per una bitLength che non è una potenza di 2: un valore di 3 bit con supera il limite del byte e viene rifiutato.
Un valore inferiore a 8 bit che supera il limite del byte viene rifiutato. Una bitLength che non è una potenza di 2 viene segnalata.
Se una decodifica con questo schema EN61375_MVB non è possibile, per un singolo canale può comunque essere scelto uno degli altri schemi e si può quindi provare anche uno spostamento e un riallineamento dei bit e dei byte.
Conteggio della posizione dei bit
La distinzione più importante per tutti gli altri schemi è anzitutto l'ordine in cui vengono contati i bit.
Con le impostazioni Ascending* i bit vengono contati secondo il significato crescente. Ciò è tipico delle configurazioni CANbus o Profibus e corrisponde anche alle implementazioni nei linguaggi di programmazione.
Con l'impostazione ReversedForMsb i bit nel byteOrder BigEndian (Motorola, MSB, Network) vengono contati rigorosamente da sinistra a destra. Ciò corrisponde alla modalità di conteggio a livello fisico nei protocolli di trasmissione dati seriali, come ad es. CANbus, SPI o anche MVB.
La grafica mostra le diverse modalità di conteggio per 3 byte a titolo di esempio.
Definizione del bit di ancoraggio per la posizione dell'immagine
Nelle impostazioni Ascending* si distingue quale bit del valore dei dati viene indirizzato con il bitOffset. Di solito è il primo bit (AscendingFirstBit), quindi con byteOrder bigEndian il MSBit e con littleEndian il LSBit. Esistono tuttavia anche eccezioni in cui, indipendentemente dal byteOrder, viene sempre indirizzato il MSBit o il LSBit.
Nel diagramma seguente, da un telegramma di dati con conteggio Ascending* vengono estratti due valori interi a 18 bit, trasmessi una volta con byteOrder littleEndian e una volta con bigEndian.
E questo diagramma integra un valore intero a 18 bit con conteggio ReversedForMsb:
La tabella riporta possibili varianti di indirizzamento per i valori int18 mostrati sopra.
| addressSpec | byteOrder | bitOffset | bitLength |
|---|---|---|---|
| ReversedForMsb AscendingFirstBit AscendingLSBit | LittleEndian | 11 | 18 |
| AscendingMSBit | LittleEndian | 28 | 18 |
| (senza funzione) | "CBA" | 1113 | 18 |
| ReversedForMsb | BigEndian | 13 | 18 |
| AscendingFirstBit AscendingMSBit | BigEndian | 34 | 18 |
| AscendingLSBit | BigEndian | 49 | 18 |
| (senza funzione) | "ABC" | 3314 | 18 |
Segnali booleani
Non da ultimo, nei segnali booleani il bit selezionato è determinato esclusivamente dal verso di conteggio:
| addressSpec | byteOrder | bitOffset | bitLength |
|---|---|---|---|
| ReversedForMsb | BigEndian | 13 | 1 |
| (tutti gli altri) | BigEndian LittleEndian | 10 | 1 |
| (senza funzione) | "A" | 1015 | 1 |
Disposizione dei byte 'byteOrder'
| Enum | Alias | Descrizione |
|---|---|---|
| BigEndian | Big, MSB, Motorola, Network | Il byte con il bit più significativo (MSBit) si trova all'inizio del pacchetto di dati trasmesso |
| LittleEndian | Little, LSB, Intel | Il byte con il bit meno significativo (LSBit) si trova all'inizio del pacchetto di dati trasmesso |
| Sequenza A-Z | Se viene utilizzata una stringa di mapping, i byte possono essere portati nell'ordine corretto a partire da una disposizione mista arbitraria. addressSpec è quindi senza funzione. |
Utilizzo di una stringa di mapping
I byte nel buffer di ricezione vengono indicizzati in ordine crescente a partire da bitOffset / 8, iniziando con 'A'. L'ordine dei byte in significato decrescente è stabilito dalla stringa. bitOffset MODULO 8 determina di quanti bit il valore estratto deve essere spostato verso destra, affinché il bit meno significativo (LSBit) si trovi alla posizione .
Con questo mapping libero è in genere possibile interpretare tutti i telegrammi che hanno percorso una lunga strada da un morsetto di misura, attraverso accoppiatori di bus, controllori, gateway, ecc., subendo diversi riordinamenti e interpretazioni dell'ordine dei byte. Ogni sistema offre proprie possibilità di impostazione e queste vengono anche ampiamente utilizzate. Potrebbe essere così semplice...
Esempio:
bytes: 0_______ 1_______ 2_______ 3_______ 4_______ 5_______ 6_______
bits: 76543210 76543210 76543210 76543210 76543210 76543210 76543210
bitOffset: --------------------->|
Indizierung: A B C D E ...
Extraktion für "CDBA"
value = ((((byte[4] << 8) // alias 'C' (bitOffset / 8) + 2
| byte[5] << 8) // alias 'D' (bitOffset / 8) + 3
| byte[3] << 8) // alias 'B' (bitOffset / 8) + 1
| byte[2]) // alias 'A' (bitOffset / 8) + 0
>> (bitOffset % 8);
Tipi di dati di origine 'imageType'
| Enum | Alias | Descrizione |
|---|---|---|
| bool | boolean | bitLength fissa di 1 e dataType Bool. |
| unsigned | Intero senza segno con bitLength 2..64. Può essere combinato con scale e offset in una grandezza fisica scalata. | |
| antivalent, antivalent2 | => unsigned con bitLength = 2, usato per lo più nel contesto MVB per valori booleani protetti: 0: ERROR 1: FALSE 2: TRUE 3: UNDEFINED | |
| signed | Intero con segno con bitLength 2..64, il bit più significativo è il bit di segno. Può essere combinato con scale e offset in una grandezza fisica scalata. | |
| bcd | Numeri decimali codificati in binario, ciascuno con 4 bit per la rappresentazione di una cifra 0..9 | |
| float | 16 bitLength fissa di 32, IEEE 754 | |
| double | 16 bitLength fissa di 64, IEEE 754 | |
| timedate48 | bitLength fissa di 48, EN 61375-2-1 §6.4.6.2 (TCN, WTB, MVB), vedere Marche temporali | |
| time64 | bitLength fissa di 64, RFC 1305, vedere Marche temporali | |
| bytearray | Ulteriori proprietà stabiliscono come viene calcolata la lunghezza dell'array | |
| string | Ulteriori proprietà stabiliscono come viene calcolata la lunghezza della stringa | |
UniPolar<M>.<N> | Numero a virgola fissa senza segno con <M> bit interi e una bitLength fissa di <N> bit.Può essere combinato con scale e offset in una grandezza fisica scalata. EN 61375-2-1 §6.4.3.7 (TCN, WTB, MVB) | |
BiPolar<M>.<N> | Numero a virgola fissa con segno con <M> bit interi (segno incluso) e una bitLength fissa di <N> bit.Può essere combinato con scale e offset in una grandezza fisica scalata. EN 61375-2-1 §6.4.3.8 (TCN, WTB, MVB) |
Marche temporali 'timedate48' e 'time64'
time64 viene contato dal 1900, come stabilito dalla RFC 1305; in precedenza il valore era sfasato di 70 anni. Una marca temporale 0 viene inoltrata come 0.
Entrambi gli imageType vengono prodotti in nanosecondi dal 01.01.1970 (UTC) con dataType int64. La conversione avviene con aritmetica intera; la frazione di secondo viene arrotondata al nanosecondo più vicino.
| imageType | Struttura | Riferimento | valido fino al |
|---|---|---|---|
| timedate48 | secondi a 32 bit (senza segno) + frazione a 16 bit in s | 01.01.1970 | 07.02.2106 |
| time64 | secondi a 32 bit (senza segno) + frazione a 32 bit in s | 01.01.1900 | vedere timeFix |
Una marca temporale i cui bit sono tutti 0 viene inoltrata come 0 e indica così una marca temporale mancante.
Superamento di time64 nel 2036 'timeFix'
Il contatore dei secondi di time64 trabocca il 07.02.2036 alle 06:28:16 UTC. timeFix stabilisce a quale era si riferisce un valore ricevuto:
| timeFix | Procedimento |
|---|---|
| RFC4330 (predefinito) | RFC 4330 §3: se il bit più significativo dei secondi è impostato, l'ora è compresa tra il 1968 e il 2036, altrimenti tra il 2036 e il 2104. Assegnazione fissa senza riferimento all'ora di sistema. |
| RFC5905 | RFC 5905 §6: vale l'era più vicina alla marca temporale di ricezione. Presuppone un'ora di sistema corretta. |
Se una marca temporale si discosta di oltre 30 anni dalla marca temporale di ricezione, ciò viene segnalato una sola volta per canale nel file di log, con entrambi gli istanti. Una causa tipica è una controparte che invia secondi dal 1970 anziché dal 1900.
Indicazioni per la determinazione della lunghezza di una stringa 'stringHint' e 'numElements'
- Ogni stringa termina al primo carattere nullo, indipendentemente dallo stringHint.
- bitOffset e bitLength di string e bytearray devono essere multipli di 8; addressSpec e byteOrder non hanno effetto su di essi.
- Senza addressSpec (predefinito EN61375_MVB) le stringhe vengono lette come ISO-8859-1.
"stringEncoding": "UTF-8"ripristina il comportamento precedente.
Le stringhe e i campi di dati (imageType string e bytearray) si trovano sempre byte per byte nel pacchetto di dati:
-
bitOffset e bitLength devono essere multipli di 8. In caso contrario il canale viene bloccato all'avvio con un messaggio nel file di log.
-
bitOffset è la posizione del byte × 8. addressSpec e byteOrder non hanno effetto; byteOrder determina solo l'ordine dei byte di un campo di lunghezza (vedere sotto).
L'area riservata alla stringa nel buffer dei dati risulta da
-
la bitLength,
-
numElements × bitLength, se numElements è indicato. bitLength è allora la larghezza di un carattere (predefinito 8 bit, 16 bit per U8WLength fino a U32WLength e S7WLength), oppure
-
in assenza di entrambe, il resto del messaggio a partire da bitOffset.
Indipendentemente dallo stringHint, ogni stringa termina al primo carattere nullo (U+0000) dopo la decodifica. Quanto segue nell'area riservata viene scartato. Se servono tutti i byte, utilizzare l'imageType bytearray.
| Enum | Alias | Descrizione |
|---|---|---|
| FixedLengthInBits | bitLength | (predefinito) La stringa riempie l'area riservata. |
| NullTerminated | Equivalente a FixedLengthInBits, mantenuto per motivi di compatibilità | |
| FixedLength | numElements definisce il numero di caratteri nella stringa. | |
| U8Length | Un uint8 prima del testo ne indica la lunghezza in byte. | |
| U16Length | Un uint16 prima del testo ne indica la lunghezza in byte. | |
| U32Length | Un uint32 prima del testo ne indica la lunghezza in byte. | |
| U8WLength5 | Un uint8 prima del testo ne indica la lunghezza in parole (2 byte, ad es. UTF-16). | |
| U16WLength5 | Un uint16 prima del testo ne indica la lunghezza in parole. | |
| U32WLength5 | Un uint32 prima del testo ne indica la lunghezza in parole. | |
| S7Length5 | SIMATIC STRING, vedere sotto | |
| S7WLength5 | SIMATIC WSTRING, vedere sotto | |
| EndOfMessage | La stringa si estende sempre fino alla fine del messaggio. |
Stringhe con campo di lunghezza
Con U8Length fino a U32WLength, un campo di lunghezza precede il testo a partire da bitOffset. La larghezza riservata da bitLength o numElements vale per il testo; il campo di lunghezza si aggiunge. Un campo di lunghezza di 2 o 4 byte viene letto little endian con byteOrder LittleEndian, altrimenti big endian.
Se il campo di lunghezza indica più di quanto contengano l'area riservata o il messaggio, il testo viene troncato e ciò viene segnalato una sola volta per canale nel file di log. Se il campo di lunghezza manca nel messaggio, non viene prodotto alcun valore.
Esempio U16Length, byteOrder BigEndian, bitOffset 0:
00 02 41 42 43 → "AB"
Stringhe SIMATIC 'S7Length' e 'S7WLength'
I controllori SIMATIC memorizzano le stringhe con un'intestazione composta da lunghezza massima dichiarata e lunghezza attuale. Entrambe contano caratteri. Vengono letti solo i caratteri della lunghezza attuale; quanto segue nell'area riservata è irrilevante.
| stringHint | Tipo SIMATIC | Intestazione | Carattere | stringEncoding predefinito | Lunghezza massima |
|---|---|---|---|---|---|
| S7Length | STRING[n] | 1 byte lunghezza massima, 1 byte lunghezza attuale | 1 byte | windows-1252 | 254 |
| S7WLength | WSTRING[n] | 2 byte lunghezza massima, 2 byte lunghezza attuale, big endian | 2 byte | UTF-16BE | 16382 |
numElements corrisponde alla dichiarazione n ed è opzionale; senza indicazione vale il resto del messaggio. L'intestazione di S7WLength è sempre big endian, indipendentemente da byteOrder.
Se la lunghezza attuale supera la lunghezza massima, viene ridotta alla lunghezza massima. Ciò, così come una lunghezza massima superiore al limite o diversa da numElements, viene segnalato una sola volta per canale nel file di log; il valore viene comunque letto.
Esempio STRING[10] := 'abcdef' con numElements 10:
0A 06 61 62 63 64 65 66 xx xx xx xx → "abcdef"
Codifica dei caratteri 'stringEncoding'
Internamente smartCORE elabora tutte le stringhe come Unicode. stringEncoding indica la codifica dei byte nel pacchetto di dati. Senza indicazione vale "windows-1252" per S7Length, "UTF-16BE" per S7WLength, "ISO-8859-1" (Latin-1) per l'addressSpec EN61375_MVB, altrimenti "UTF-8".
Sono ammessi i nomi e gli alias del registro IANA "Character Sets". Maiuscole e minuscole non hanno importanza. Gli alias con prefisso cs (ad es. csUTF8) non sono supportati. Un nome sconosciuto viene segnalato all'avvio nel file di log e il canale viene bloccato.
Codifiche usate frequentemente e i byte di alcuni caratteri:
| stringEncoding | ä | Ä | ß | € | ° | µ | ² |
|---|---|---|---|---|---|---|---|
| UTF-8 | C3 A4 | C3 84 | C3 9F | E2 82 AC | C2 B0 | C2 B5 | C2 B2 |
| ISO-8859-1 (Latin-1) | E4 | C4 | DF | – | B0 | B5 | B2 |
| ISO-8859-15 (Latin-9) | E4 | C4 | DF | A4 | B0 | B5 | B2 |
| windows-1252 | E4 | C4 | DF | 80 | B0 | B5 | B2 |
| IBM437 (cp437) | 84 | 8E | E1 | – | F8 | E6 | FD |
| UTF-16BE (MVB UNICODE16) | 00 E4 | 00 C4 | 00 DF | 20 AC | 00 B0 | 00 B5 | 00 B2 |
| US-ASCII | – | – | – | – | – | – | – |
US-ASCII conosce solo i byte da 00 a 7F. Un carattere non presente nella codifica, o una sequenza di byte non valida, compare nel canale come carattere sostitutivo "�" (U+FFFD).
Ogni messaggio viene decodificato singolarmente. Una sequenza di byte troncata alla fine dell'area dei dati non viene unita al messaggio successivo, ma viene anch'essa restituita come "�".
Errori tipici in caso di impostazione errata:
| Visualizzato nel canale | Causa |
|---|---|
ä invece di ä | I dati sono UTF-8, l'impostazione è ISO-8859-1 o windows-1252. |
� invece di ä | I dati sono ISO-8859-1 o windows-1252, l'impostazione è UTF-8. |
„ invece di ä | I dati sono IBM437, l'impostazione è windows-1252. |
Indicazioni per la determinazione della lunghezza di un campo di dati 'numElements'
L'allineamento al byte di bitOffset e bitLength vale anche per i campi di dati (vedere sopra).
imageType: ByteArray
La funzione di decodifica dei campi di dati non è ancora verificata. Utilizzare solo previo accordo!
Tipi di dati dei canali (tipi di dati di destinazione) 'dataType'
Il dataType viene sempre determinato automaticamente dall'imageType, se non viene specificato. In tal caso viene impostato un formato di destinazione con cui si evita una perdita di informazioni con il minor fabbisogno di memoria possibile.
| Enum | Alias | Intervallo di valori | Applicazione |
|---|---|---|---|
| Boolean | bool | false/true | Segnali di stato/controllo |
| Float | fino a | Dati di misura | |
| Double | fino a | ||
| Integer8 | int8 | ||
| Integer16 | int16 | ||
| Integer32 | int32 | ||
| Integer64 | int64 | Timestamp | |
| UnsignedInteger8 | uint8 | Codici di stato | |
| UnsignedInteger16 | uint16 | ||
| UnsignedInteger32 | uint32 | ||
| UnsignedInteger64 | uint64 | ||
| ByteArray | |||
| String | Testo |
Tipi di dati imposti:
Se la bitLength == 1 o l'imageType == bool, anche il dataType è sempre automaticamente bool.
Per imageType == string o bytearray anche il dataType è sempre string o bytearray.
Gli imageType time64 o timedate48 impongono con int64 il dataType, per poter convertire i timestamp in modo corretto e completo in nanosecondi dal 01.01.1970.
Un'indicazione di numElements > 1 impone il dataType ByteArray, a meno che non sia impostato un imageType String.
Un imageType numerico non può alimentare un dataType String, ByteArray o GpsLocation; un tale canale viene disattivato all'avvio con un messaggio che indica entrambi i tipi.5
Tipi di dati automatici:
In tal caso i formati a virgola mobile float e double hanno la precedenza, se è soddisfatto uno dei seguenti criteri:
- la fonte di dati fornisce già, tramite l'imagetype (float, double, unipolar, bipolar), un valore a virgola mobile o fissa,
- oppure ,
- è specificata una physicalUnit.
Se , un float è sufficiente per una conversione senza perdite.
Anche i formati interi vengono selezionati, in base alla bitLength e alla presenza di un segno (signed) nell'imageType, per il più piccolo intervallo di dati possibile:
- (Unsigned)Integer8 per
- (Unsigned)Integer16 per
- (Unsigned)Integer32 per
- (Unsigned)Integer64 per
Il segno opzionale viene esteso dal bit più significativo dell'immagine fino alla larghezza del dataType.
Tipi di dati manuali e conversione:
La selezione manuale del dataType può comportare una perdita di precisione, di risoluzione o una limitazione significativa dell'intervallo di valori disponibile e deve quindi di norma essere evitata!
Se la fonte di dati fornisce un numero a virgola mobile secondo le regole citate in precedenza, per la conversione in un dataType intero si arrotonda: a partire da .50 al valore intero immediatamente superiore.
In ogni caso vengono considerati gli intervalli di valori dei tipi interi scelti. Se il valore dell'immagine si trova al di fuori dell'intervallo disponibile, viene sostituito con il minimo o il massimo rappresentabile e viene emesso un messaggio nel file di log.
Filtro di riduzione dei dati
Per ogni canale viene configurato un filtro di riduzione dei dati. Nell'impostazione di base esso fa in modo che i nuovi record di dati vengano scritti nel canale solo se il contenuto dei dati cambia (OnChange). Il timestamp di ricezione dei dati viene invece aggiornato a ogni record elaborato, in modo che sia possibile elaborare i dati (costanti) in altri plug-in fino all'istante più recente.
Con l'opzione absoluteTolerance viene posta una banda di tolleranza attorno all'ultimo valore scritto. Un nuovo record di dati viene pubblicato solo quando la differenza rispetto all'ultimo valore scritto si discosta di oltre questa banda di tolleranza. Questa impostazione è utile per segnali fortemente rumorosi, per ridurre in modo significativo la quantità di dati.
Se l'opzione noFilter viene impostata su true, non viene creato alcun filtro di riduzione dei dati. Questa impostazione è opportuna per dati veloci che non devono essere ridotti, perché ad es. per i segnali di vibrazione segue un'analisi nel dominio della frequenza.
Informazioni sul modulo
| Informazione | Valore |
|---|---|
| Autori | optiMEAS GmbH |
| da smartCORE | 0.103 |
| Tipo di modulo | Fast Message Receiver, Producer |
| Dipendenze | Modulo di invio Fast Message (ad es. fmudp, canbus, smartmvb, rawplayback, ...) |