Wie würden Sie dieses Gerät modellieren?

Question

Ich erstelle eine interne Diagnoseanwendung für ein Produkt, das eine Reihe von einzeln adressierbaren Geräten an einem I2C-Bus hat.

Die allgemeine Idee ist, dass ich jedes Gerät auf dem Bus abfragen und ein Byte-Array von "Rohdaten" erhalten. Die Länge des Byte-Arrays hängt vom jeweiligen Gerät ab.

Ich habe eine abstrakte Klasse namens 'FormattedData' mit einer einzigen Eigenschaft namens 'RawData' erstellt.

public abstract class FormattedData { 

    protected byte[] _rawData; 

    public FormattedData(int rawDataLength) { 
     _rawData = new byte[rawDataLength]; 
    } 

    public byte[] RawData { 
     get { return _rawData; } 
     set { 
      if (value.Length != _rawData.Length) { 
       throw new ArgumentOutOfRangeException("RawData", 
        "The Raw Data byte array for a " + this.GetType().Name + 
        " must be " + _rawData.Length.ToString() + "-bytes long." + 
        Environment.NewLine + 
        "Length of supplied array: [" + value.Length.ToString() + "]"); 
      } 

      _rawData = value; 
     } 
    } 
} 

Jedes Gerät am I2C-Bus erhält sein eigenes Modell, indem es von FormattedData erbt.

Ich kann dann eine Reihe von Eigenschaften für das Gerät verfügbar machen, indem Sie Daten aus dem RAWDATA-Byte-Array nach Bedarf bearbeiten. Für meine Zwecke sind die Daten alle schreibgeschützt. Zum Beispiel:

public class MyTestDevice : FormattedData { 

    public MyTestDevice() 
     : base(256) { 
    } 

    public string VendorName { 
     get { return (ASCIIEncoding.ASCII.GetString(_rawData, 20, 16)); } 
     set { ;} 
    } 

    public bool LossOfSignal { 
     get { return ((_rawData[110] & 0x02) == 0x02); } 
     set { ;} 
    } 
} 

Also, auf meine Frage.

Ich erstelle ein Modell für einen SFP-Transceiver basierend auf der SFF-8472 Spezifikation.

Kurz gesagt, ein einzelnes physikalisches SFP-Gerät hat 2 Rohdatentabellen (AO und A2). Jede Datentabelle muss unabhängig abgefragt werden und kann bis zu 256 Byte zurückgeben.

Das Problem ist, dass einige der Eigenschaften aus der A2-Tabelle von Werten aus der A0-Tabelle abhängen (einige Analogwerte aus der A2-Tabelle werden abhängig von einem in der A0-Tabelle gesetzten Flag unterschiedlich skaliert).

Was wäre der beste Weg, ein Gerät wie dieses mit mehr als einem 'Raw Data' Byte-Array zu modellieren, und wo es möglich ist, dass Werte von einem Array von Werten eines anderen abhängen?

Ich würde gerne eine Art von Standard-Schnittstelle für alle Geräte pflegen, wenn möglich.

Answer 1

• Erstellen Sie eine Klasse, die Daten als eines ihrer Mitglieder formatiert hat.
• Es sollte genau wie MyTestDevice aussehen.
• Erweitern Sie diese Klasse um 2 formatierteDatenelemente für lokale Geräte.
• Ändern Sie die VendorName-Funktionen usw., um beide Tabellen zu verwenden.

Answer 2

Ich endete Formatieren von FormtedData, so dass es eine variable Anzahl von RawData Byte-Arrays enthalten kann.

Der Konstruktor nimmt eine Liste von KeyValuePairs. Jeder Schlüssel stellt eine Beschreibung für ein RawData-Array dar und jeder Wert gibt die Länge dieses Arrays an.

Dann kann ich jedes RawData-Array mit seiner Beschreibung indizieren.

public abstract class FormattedData { 

    protected Dictionary<string, byte[]> _rawData = new Dictionary<string, byte[]>(); 

    public FormattedData(IEnumerable<KeyValuePair<string, int>> rawDataConfigs) { 
     rawDataConfigs.ToList() 
      .ForEach(kvp => _rawData.Add(kvp.Key, new byte[kvp.Value])); 
    } 

    public IEnumerable<string> RawDataNames { 
     get { 
      foreach (var kvp in _rawData) { 
       yield return kvp.Key; 
      } 
     } 
    } 

    public byte[] this[string rawDataName] { 
     get { 
      return _rawData[rawDataName]; 
     } 
     set { 
      if (value.Length != _rawData[rawDataName].Length) { 
       throw new ArgumentOutOfRangeException("RawData", 
        "The Raw Data byte array for a " + this.GetType().Name + 
        " must be " + _rawData[rawDataName].Length.ToString() + "-bytes long." + 
        Environment.NewLine + 
        "Length of supplied array: [" + value.Length.ToString() + "]"); 
      } 

      _rawData[rawDataName] = value; 
     } 
    } 
} 

Meine aktualisiert Testgerät sieht wie folgt aus (zwei RawData Arrays - ein namens ‚A0‘ und eine namens ‚A2‘:

public class MyTestDevice: FormattedData { 

    const string A0 = "A0"; 
    const string A2 = "A2"; 
    const int _rawDataLength_A0 = 256; 
    const int _rawDataLength_A2 = 256; 

    static readonly Dictionary<string, int> _rawDataConfigs = 
     new Dictionary<string, int> { 
      {A0, _rawDataLength_A0}, 
      {A2, _rawDataLength_A2}  
     }; 

    public MyTestDevice() 
     : base(_rawDataConfigs) { 
    } 

    public string VendorName { 
     get { return (ASCIIEncoding.ASCII.GetString(_rawData[A0], 20, 16)); } 
     set { ;} 
    } 

    public bool LossOfSignal { 
     get { return ((_rawData[A0][110] & 0x02) == 0x02); } 
     set { ;} 

    } 
} 

Ich denke, ich sollte fast jeder modellieren können I2C-Gerät mit diesem Ansatz - jedes Gerät mit mehreren Seiten (dh ein EEPROM oder XFP) oder mehr Rohdaten-Tabellen (. dh ein SFP) sollte passen

Kommentare oder Kritik