Zuviel Werbung? - > Hier kostenlos beim SPS-Forum registrieren

Seite 2 von 2 ErsteErste 12
Ergebnis 11 bis 17 von 17

Thema: libnodave - Float auf SPS schreiben

  1. #11
    Registriert seit
    25.07.2005
    Ort
    Vogelsbergkreis
    Beiträge
    1.717
    Danke
    48
    Erhielt 68 Danke für 60 Beiträge

    Standard


    Zuviel Werbung?
    -> Hier kostenlos registrieren
    Zitat Zitat von Zottel
    Zitat Zitat von seeba
    Ich will die 4 Bytes aus meinem Buffer zum Float umwandeln. Und du bietest ja keine Funktion zum lesen aus einem bestimmten Buffer an einer bestimmten Stelle.
    Das heißt, der Puffer ist mittels einer der Lesefunktionen, z.B. readBytes, mit Bytes aus der SPS gefüllt?
    Dann bräuchtest du ja dieselbe Funktion wie daveGetFloat, aber von einem eigenen Puffer?
    Genau! Diese Funktionen fehlen mir

  2. #12
    Registriert seit
    19.06.2003
    Beiträge
    2.200
    Danke
    85
    Erhielt 259 Danke für 175 Beiträge

    Standard

    Zitat Zitat von seeba
    Zitat Zitat von Zottel
    Zitat Zitat von seeba
    Ich will die 4 Bytes aus meinem Buffer zum Float umwandeln. Und du bietest ja keine Funktion zum lesen aus einem bestimmten Buffer an einer bestimmten Stelle.
    Das heißt, der Puffer ist mittels einer der Lesefunktionen, z.B. readBytes, mit Bytes aus der SPS gefüllt?
    Dann bräuchtest du ja dieselbe Funktion wie daveGetFloat, aber von einem eigenen Puffer?
    Genau! Diese Funktionen fehlen mir
    Die Funktionen sind in der C-Version (und damit in libnodave.dll) enthalten, z.B.
    daveGetFloatfrom(uc * buffer, int position);
    Du kannst durchaus versuchen, eine entsprechende Definition in libnodave.net.cs einzufügen.
    Aus den vorher genannten Gründen (Prüfung der Array-Grenzen durch die CLR) ist das nicht meine favorierte Lösung.
    Die Funktion in nodave.c tauscht die Bytes, falls sie auf einem little endian System (i386) läuft. In .NET gibt es glaube ich, keine bedingte Kompilierung. Eine Möglichkeit wäre, den Byte-Tausch in Abhängigkeit von BitConverter.IsLittleEndian auszuführen. Gefällt mir aber auch nicht, weil überall Fallunterscheidungen und Sprünge nötig sind. Daher suche ich noch nach der optimalen Lösung.

  3. #13
    Registriert seit
    19.06.2003
    Beiträge
    2.200
    Danke
    85
    Erhielt 259 Danke für 175 Beiträge

    Standard

    Hier die Funktionen unter Verwendung von BitConverter.IsLittleEndian:
    Code:
        public static int getS16from(byte[] b, int pos) {
    	if (BitConverter.IsLittleEndian) {
    	    byte[] b1=new byte[2];
    	    b1[1]=b[pos+0];
    	    b1[0]=b[pos+1];
    	    return BitConverter.ToInt16(b1, 0);
    	}    
    	else 
    	    return BitConverter.ToInt16(b, pos);
        }
        
        public static int getU16from(byte[] b, int pos) {
    	if (BitConverter.IsLittleEndian) {
    	    byte[] b1=new byte[2];
    	    b1[1]=b[pos+0];
    	    b1[0]=b[pos+1];
    	    return BitConverter.ToUInt16(b1, 0);
    	}    
    	else 
    	    return BitConverter.ToUInt16(b, pos);
        }
            
        public static int getS32from(byte[] b, int pos) {
    	if (BitConverter.IsLittleEndian) {
    	    byte[] b1=new byte[4];
    	    b1[3]=b[pos];
    	    b1[2]=b[pos+1];
    	    b1[1]=b[pos+2];
    	    b1[0]=b[pos+3];
    	    return BitConverter.ToInt32(b1, 0);
    	}    
    	else 
    	    return BitConverter.ToInt32(b, pos);
        }
        
        public static uint getU32from(byte[] b, int pos) {
    	if (BitConverter.IsLittleEndian) {
    	    byte[] b1=new byte[4];
    	    b1[3]=b[pos];
    	    b1[2]=b[pos+1];
    	    b1[1]=b[pos+2];
    	    b1[0]=b[pos+3];
    	    return BitConverter.ToUInt32(b1, 0);
    	}    
    	else 
    	    return BitConverter.ToUInt32(b, pos);
        }
        
        public static float getFloatfrom(byte[] b, int pos) {
    	if (BitConverter.IsLittleEndian) {
    	    byte[] b1=new byte[4];
    	    b1[3]=b[pos];
    	    b1[2]=b[pos+1];
    	    b1[1]=b[pos+2];
    	    b1[0]=b[pos+3];
    	    return BitConverter.ToSingle(b1, 0);
    	}    
    	else 
    	    return BitConverter.ToSingle(b, pos);
        }

  4. #14
    Registriert seit
    25.07.2005
    Ort
    Vogelsbergkreis
    Beiträge
    1.717
    Danke
    48
    Erhielt 68 Danke für 60 Beiträge

    Standard

    Zitat Zitat von Zottel
    Hier die Funktionen unter Verwendung von BitConverter.IsLittleEndian:
    Code:
        public static int getS16from(byte[] b, int pos) {
    	if (BitConverter.IsLittleEndian) {
    	    byte[] b1=new byte[2];
    	    b1[1]=b[pos+0];
    	    b1[0]=b[pos+1];
    	    return BitConverter.ToInt16(b1, 0);
    	}    
    	else 
    	    return BitConverter.ToInt16(b, pos);
        }
        
        public static int getU16from(byte[] b, int pos) {
    	if (BitConverter.IsLittleEndian) {
    	    byte[] b1=new byte[2];
    	    b1[1]=b[pos+0];
    	    b1[0]=b[pos+1];
    	    return BitConverter.ToUInt16(b1, 0);
    	}    
    	else 
    	    return BitConverter.ToUInt16(b, pos);
        }
            
        public static int getS32from(byte[] b, int pos) {
    	if (BitConverter.IsLittleEndian) {
    	    byte[] b1=new byte[4];
    	    b1[3]=b[pos];
    	    b1[2]=b[pos+1];
    	    b1[1]=b[pos+2];
    	    b1[0]=b[pos+3];
    	    return BitConverter.ToInt32(b1, 0);
    	}    
    	else 
    	    return BitConverter.ToInt32(b, pos);
        }
        
        public static uint getU32from(byte[] b, int pos) {
    	if (BitConverter.IsLittleEndian) {
    	    byte[] b1=new byte[4];
    	    b1[3]=b[pos];
    	    b1[2]=b[pos+1];
    	    b1[1]=b[pos+2];
    	    b1[0]=b[pos+3];
    	    return BitConverter.ToUInt32(b1, 0);
    	}    
    	else 
    	    return BitConverter.ToUInt32(b, pos);
        }
        
        public static float getFloatfrom(byte[] b, int pos) {
    	if (BitConverter.IsLittleEndian) {
    	    byte[] b1=new byte[4];
    	    b1[3]=b[pos];
    	    b1[2]=b[pos+1];
    	    b1[1]=b[pos+2];
    	    b1[0]=b[pos+3];
    	    return BitConverter.ToSingle(b1, 0);
    	}    
    	else 
    	    return BitConverter.ToSingle(b, pos);
        }
    Klasse, Zottel! Dickes Lob! Und anderstrum? Und: getBitFrom() fehlt mir noch...

  5. #15
    Anonymous Gast

    Standard

    Hallo,
    Mann seeba,
    Zitat Zitat von seeba
    Und: getBitFrom() fehlt mir noch...
    Also kaum wirft Zottel euch ein Würstchen hin, willst Du gleich danach noch ein Steak.
    Gruß
    Question_mark

  6. #16
    Registriert seit
    25.07.2005
    Ort
    Vogelsbergkreis
    Beiträge
    1.717
    Danke
    48
    Erhielt 68 Danke für 60 Beiträge

    Standard

    Zitat Zitat von Anonymous
    Hallo,
    Mann seeba,
    Zitat Zitat von seeba
    Und: getBitFrom() fehlt mir noch...
    Also kaum wirft Zottel euch ein Würstchen hin, willst Du gleich danach noch ein Steak.
    Gruß
    Question_mark
    Nagut ich bekomm's sicherlich auch so hin, allerdings denke ich, dass es für viele Anwender die mit .NET arbeiten wollen so besser ist!

  7. #17
    Registriert seit
    19.06.2003
    Beiträge
    2.200
    Danke
    85
    Erhielt 259 Danke für 175 Beiträge

    Standard


    Zuviel Werbung?
    -> Hier kostenlos registrieren
    Zitat Zitat von seeba
    Und anderstrum?
    Habe ich das nicht voraer ausführlich erläutert?
    Zitat Zitat von seeba
    Und: getBitFrom() fehlt mir noch...
    Je nachdem, wie du das Bit bekommst ( 1. daveReadBits() oder 2. du hast per daveReadBytes() z.B. ein MB gelesen) vergleichst du auf ungleich 0 oder du vergleichst mit der Bit-Maske:
    if ((MeineVariableDieEineKopieVomMB_XIst & 0x80) !=0) then MB_X_Punkt_7 =true, else MB_X_Punkt_7=false.
    Selbstverständlich könnte man getBitFrom() definieren. Auch getU8from. Aber getU8from(buffer, position) ist wirklich trivial: = buffer[position]!!!!
    Aber ich möchte auch nicht die Leute verführen, wirklich beschissen ineffizienten Code zu produzieren:
    Etwas wie:
    if ((MeineVariableDieEineKopieVomMB_XIst & 0x80) !=0) then MB_X_Punkt_7 =true, else MB_X_Punkt_7=false.
    setzt ein halbwegs effizienter Compiler für i386 so um:
    Code:
    MOV MeineVariableDieEineKopieVomMB_XIst,EAX
    AND EAX,00000080h
    JZ ok
    MOV EAX,TRUE
    ok: Nachfolgender Code
    Ein getBitfrom(buffer, position,BitNumber) sähe, mitsamt Bereichsprüfungen, eher so aus:
    Code:
    push buffer
    push position
    push bitNumber
    call getBitfrom
    //getBitfrom
    enter ParameterGröße
    MOV EAX,Buffer.Length
    CMP EA, Position
    JGT   DoArrayBoundsException
    MOV EDX,Buffer
    XOR EDX,EDX
    CMP EA, Position
    JLE  DoArrayBoundsException
    ADD EDX,BUFFER
    MOV EAX,[EDX]
    PUSH EAX
    MOV ECX,1
    MOV EDX,BitNumber
    SHL ECX,EDX
    AND EAX,ECX
    JZ ok
    MOV EAX,TRUE
    ok: leave ParameterGröße
    ret
    Ich habe das jetzt nicht ausprobiert und dissassembliert, aber selbst als handoptimierter Assemblercode wäre es so ganz in Ordnung.
    In .NET ist es natürlich kein i386-Assembler, sondern jede Anweisung hat entweder eine Entsprechung im Maschinencode der VM oder der JIT-Compiler macht es noch länger...

    Wenn du Bits aus einem Byte-Puffer lesen willst, ist es insbesondere günstig, zunächst das byte in eine einfache Variable zu kopieren, weil dadurch die Array-Indizierung und Prüfung der Grenzen einmal gemacht werden und du danach alle 8 Bits testen kannst.
    [/code]

Ähnliche Themen

  1. Libnodave PAW schreiben
    Von FeigeKalle im Forum Hochsprachen - OPC
    Antworten: 9
    Letzter Beitrag: 04.02.2011, 14:45
  2. [Libnodave] String ind SPS schreiben...
    Von paddy_cmd im Forum Hochsprachen - OPC
    Antworten: 9
    Letzter Beitrag: 08.07.2009, 17:43
  3. mit libnodave in db schreiben
    Von mike97714 im Forum Hochsprachen - OPC
    Antworten: 3
    Letzter Beitrag: 30.06.2009, 08:33
  4. 2 Bits schreiben mit LibNoDave
    Von Earny im Forum Hochsprachen - OPC
    Antworten: 7
    Letzter Beitrag: 23.11.2008, 18:00
  5. Libnodave Daten lesen/schreiben
    Von Acidic im Forum Simatic
    Antworten: 4
    Letzter Beitrag: 02.06.2008, 08:32

Lesezeichen

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •