Dword

[Manfred]

Hi,

kann mir hierbei jemand mal auf die Sprünge helfen?

Für mich wäre die Spalte restriction_days interessant. Der Rest ist klar.

[georg]

Hallo, Manfred -


von der Beschreibung würde ich davon ausgehen, dass das Element aus neun Bytes besteht, die ersten vier für die "restrictions of operation", sowie fünf weitere Bytes, die ein bis fünf Indikatoren für diese Einschränkungen enthalten.

Oder habe ich Deine Frage falsch verstanden?

Für eine variable Länge würde ich irgendwo ein Feld erwarten, das die variable Länge definiert. Da ein solches Feld fehlt, würde ich von einer festen Satzlänge ausgehen.

[Martin Altmann]

Moin,
ist doch alles erklärt - und haben wir doch schon Mal per Skype gemacht gehabt
Du brauchst 4 Zeichen (4*8 Bit) und diese halt binär betrchten. Also
01111111111111111111111111111111
Würde bedeuten, dass der Monat 31 Tage hat und an jedem Tag gefahren wird.
Ist der erste Tag ein Samstag und die Linie fährt nur Mo-Fr, würde das ganze bei einem 31 Tage-Monat so aussehen:
01001111100111110011111001111100
Und das halt entsprechend als Byte ausgelesen - das erste Zeichen ist also
01001111
und somit ASCII 79.
Das zweite Zeichen ist
10011111
und somit ASCII 159.
Das dritte Zeichen ist
00111110
und somit ASCII 62.
Das vierte Zeichen ist
01111100
und somit ASCII 124.

Viele Grüße,
Martin

[brandelh]

Georg hat sich in der Zeile vertan, Martin hat prinzipiell Recht, allerding ist es nicht ganz einfach bei CHAR Werte BITS einzeln zu setzen.
Ich meine die XbTools hatten sowas. Daher verwenden die DWORD, das können wir auch:

nWert := 23423
U2bin( nWert ) => 4 Byte Zeichenkette ...

und es sind ja nicht nur 4-Byte je Monat, sondern als HEX Wert 8 Byte je Monat, das mal maximal 24 Monate ergibt die oben angegebenen 192 Byte maximal Länge.

was noch zu klären bleibt ist die Reihenfolge der Bytes in dem String, von links oder von rechts ... ( wenn man nur 12 Monate speichert, muss man dann links oder rechts auffüllen oder gar nur 96 Byte liefern ?)

Eben suchte ich wieder eine Funktion die so ein DWORD als 32 Byte 0/1 String ausgibt, bzw. als HEX Werte ... Pablo hat sowas und du brauchst HEX Werte !

[brandelh]

Was passiert eigentlich mit Monaten bei 28/29 oder 30 Tagen ?

[Martin Altmann]

Sorry Hubert,
Du irrst! Ein Monat sind 4 Byte (bzw. ein DWORD) und ein Jahr sind 12 DWORDs (bzw. 48 Byte).
Wenn der Monat nur 30 Tage hat, sind die beiden linken Bits 0, bei 29 bzw 28 entsprechend die drei bzw. 4 linken Bits.

Viele Grüße,
Martin

[Manfred]

Hm,

so richtig kann ich mich damit nicht zurechtfinden.

sowas steht da z.B. drin.

79f3e7c00f3e78f9003e7cf933e7cf805ce1f2e60f9f3e7c0007cf9f0000000027cf9f38

oder sowas

0000003e7ce000000f9f3e7c73e0001b3e7cf9f2000f3e7c79f3e7c0

[brandelh]

Sorry Hubert,
Du irrst! Ein Monat sind 4 Byte (bzw. ein DWORD) und ein Jahr sind 12 DWORDs (bzw. 48 Byte).

das habe ich doch gar nicht bestritten, aber oben steht, dass man in HEX dann 8 Byte je DWORD benötigt (3. oder 4. Absatz)
und dort steht dann die Rechnung 12 Monate * 8 Byte = 96 Byte, für max. 2 Jahre gibt 24*28 dann die maximale Feldlänge von 192 Byte.

Ob man aber immer 192 Byte übergeben muss, oder ob dort auch nur 96 Byte übergeben werden können, das steht da nicht.

Dass die ungültigen Tage wie auch der 32. immer auf 0 stehen ist wohl richtig, aber das bedeutet, dass die Berechnung für z.B. MO-FR nicht einfach wird das Jahr über

@Manfred,

versuche doch Beispieldaten für ein bekanntes Jahr zu erhalten.

[Martin Altmann]

Manfred,
ja und? Dann musst Du halt meine o.a. ASCII-Codierung als Hex ansehen - FF ist 255, weißt Du ja.
In meinem Beispiel wäre also die Folge 79 - 159 - 62 - 124 als hexadezimale Schreibweise 4F - 9F - 3E - 7C (bzw. in einem Fluß 4F9F3E7C).
Jetzt musst Du nur noch anhand der Spezifikation sehen, ab welcher Stelle in einer Zeile das beginnt.

Viele Grüße,
Martin

[brandelh]

Hallo Manfred,

ich denke mit 4 Byte Strings wird das zu umständlich, insbesondere wenn du für ein/zwei Jahr oder 24 Monate die Werte berechnen sollst.
Man muss auch an die Wartung denken ...

Das Jahr und der Monat fangen nunmal nicht immer mit dem gleichen Wochentag an. Nimm ein Array mit 12/24 Zahlenwerten, alle auf 0

Code: Alles auswählen

aMonate := array(24)
aFill( aMonate, 0 ) // alle auf 0 setzen - soweit ich mich erinnere ;-)

dVon := ctod("01.01."+nJahr)
dBix := ctod("31.12."+nJahr)
aFahrTage := { 2,3,4,5,6 } // 1 = Sonntag, 7 Sammstag oder wie du es brauchst.
for dDat := dVon to dBis
   nMon := month(dDat)
   if JahresWechsel()
      nMon += 12
   endif 
   nDay := day(dDat)
   if DoW(dDat) $ aFahrTage // soll an diesem Wochentag gefahren werden ?
      aMonat[nMon][nDay] := .t.   // bei Xbase ist das kleinste Bit 1 , nicht 0 ! Also Tag 1 bis max 31, und 32 bleibt 0
   endif
next

Wenn alles gefüllt ist, hast du 24 Monate in DWORDs ... da das höchste Bit nicht gesetzt ist, geht das gut.
Diese muss man nun in einen HEX-String bringen, irgendwo habe ich sowas auch noch, bei Pablo gibt es HEX Funktionen,
vermutlich muss man diese aber mit U2BIN(nWert) füttern ... aber oben sieht es aus als ob du auch sowas hättest.

Nun stellt sich die Frage ob von links oder rechts füllen ?

Code: Alles auswählen

cBuffer := space(192)
for i := 1 to len(aMonat) 
    cBuffer[i] := NumToHex(aMonat[i],8)
    oder
    cBuffer[193-i] := NumToHex(aMonat[i],8)
next

[brandelh]

Ich wußte ich habe sowas ...

Code: Alles auswählen

*----------------------------------------------------
function NumToHex(nWert,nLen)
   // Formel kann man unter www.wikipedia.de -> Hexadezimalsystem nachlesen.
   local cHex := "", x
   local cH   := "0123456789ABCDEF"
   DEFAULT nLen TO 0
   do while .t.
      x := nWert % 16         // Divisionsrest ergibt HEX-Ziffer der höchsten Stelle
      cHex  := cH[x+1]+cHex   // Rest 0 -> "0", da dies aber das 1. Zeichen im String ist +1
      nWert := int(nWert/16)  // nächste Potenz prüfen.
      if nWert <= 0
         exit
      endif
   enddo
   if nLen > 0
      cHex := Replicate("0",nLen-len(cHex))+cHex
   endif
return cHex

[AUGE_OHR]

hi,

hatten wir nicht schon mal das Thema bei "Bold Days" ?

es ging ja um den M$ Calender ( MonthCal ) wo man Tage in "Bold" darstellen konnte.
hierzu musste nun das betreffende Datum als Bit-String übergeben werden.
Pablo hat nun das auf der Devcon 2012, während unserem Vortrag "native Controls" ausgeführt und diesen Code geschrieben.

Code: Alles auswählen

Every month is represented as a 32 bit number, so the array use 4 bytes for each month
INLINE METHOD OnGetDayState(lp)
local ds := NMDAYSTATE():New()
local ts := FileTime64():New()
local ym1,sh,d,d1,d2,n,nn,p
ds:_link_(lp,.F.)
//
p := ds:prgDayState // copy the pointer to local just for fast access
@kernel32:SystemTimeToFileTime(ds:stStart,ts)
d1 := ts:dDate
//
// ym1 will contain the month number starting January 0000
ym1 := (ts:Year() * 12) + ts:Month()
ts:AddMonths( ds:cDayState )
//
// d2 will containt the upper date range
d2 := ts:dDate – 1
DEFAULT ::aBoldDays := Array(0)
nn := Len( ::aBoldDays )
//
// ds:prgDayState may contain data so the first step will be put all bits to 0
@ot4xb:_bset(p,0,4*ds:cDayState )
// reset existing
// and now will walk our ::aBoldDays Array to switch on the bits into the range that the control was query
//
for n := 1 to nn
   d := ::aBoldDays[n]
   //
   // first check if the date is inside the requested range and if not just ignore the entry
   if d >= d1 .and. d <= d2
      //
      // now we need to know wich int32 will store our month
      // so will rest the ym1 value from our month number
      // and because a int32 takes 4 bytes multiply x 4 to get the offset of our int32
      sh := (((Year(d)* 12) + Month(d)) - ym1) * 4

      // ------------------------------------------
      // so now will retrieve the previous value for the month
      // nMonthMask := PeekDWord(p,sh)
      // calculate the new mask by shift the number 1 ( nDay-1) positions to the left
      // nDayMask := , nLShift(1,Day(d)-1)
      // and combine the month and day masks
      // nMonthMask := nOr( nMonthMask , nDayMask)
      // and of course store in the right place at our array
      // PokeDWord(p,sh,nMonthMask)
      // ------------------------------------ 

      // next line is equivalent to the steps on the prev commented block

      PokeDWord(p,sh,nOr( PeekDWord(p,sh) , nLShift(1,Day(d)-1)))
   End
Next

[Manfred]

Martin hat Recht, jeder gefahrene Tag ist eine 1. Von 1-31. Und geschrieben wird von rechts nach links.

[Manfred]

Merkwürdig,

welche Funktion von Pablo z.B. müßte ich denn nehmen um das in hex umzurechnen? Irgendwie kommen da nur recht komische Ergebnisse zum Vorschein.

[Martin Altmann]

Ich hatte Dir doch was geschickt, um Dualzahlen in Dezimalzahlen umzurechnen. Und das kannst Du ja mit Huberts Funktion in Hexadezimal umrechnen.
Viele Grüße,
Martin

[Martin Altmann]

Hier mal auf die Schnelle eine kleine Funktion, um Dualzahlen direkt in Hex umrechnen zu lassen - als Parameter wird einfach die Zeichenkette bestehend aus Nullen und Einsen übergeben. Ist sie zu kurz (also nicht ganze Bytes lang), wird sie entsprechend links mit Nullen aufgefüllt.
Lässt sich garantiert noch beschleunigen - ist ja auch nur auf die Schnelle aus der Hüfte:

Code: Alles auswählen

function dual2hex( cDualstring )
local cHex := "", cDual := "", nX, lOk := .t., nY
local nI := Mod( len( alltrim( cDualstring ) ), 8 ), cHexsigns := "123456789ABCDEF"
if nI > 0
	cDual := replicate( "0", 8 - nI )
endif
cDual += alltrim( cDualstring )
nX := len( cDual )
for nI := 1 to nX
	if .not. ( substr( cDual, nI, 1 ) $ "10" )
		lOk := .f.
	endif
next
if lOk
	for nI := 1 to nX step 4
		nY := ( val( substr( cDual, nI, 1 ) ) * 2^3 ) + ( val( substr( cDual, nI + 1, 1 ) ) * 2^2 ) +  ( val( substr( cDual, nI + 2, 1 ) ) * 2^1 ) + ( val( substr( cDual, nI + 3, 1 ) ) * 2^0 )
		cHex += iif( nY == 0, "0", substr( cHexsigns, nY, 1 ) )
	next
endif
return cHex

Viele Grüße,
Martin

[brandelh]

Wenn du gleich mit DWORD rechnest (wie ich oben geschrieben habe), passt das alles