Re: Solved: [de-users] Calc: Zeiten vereinfacht eingeben

Hallo Wolfgang,

als 1. möchte ich hierzu bemerken, dass ich in Zukunft nicht mehr weiter
zu diesem Thema schreiben werde; es sei denn, jemand hat eine direkte
Frage an mich. Derjenige darf mich dann direkt ansprechen. Der Rahmen
hier wird eindeutig gesprengt.

Wolfgang Jäth schrieb am 29.12.2019 um 15:32:
> Am 29.12.2019 um 10:35 schrieb Marino Salvalaggio:
> > > *Alle* Daten, sogar Texte, werden intern binär abgelegt. Und Calc selbst
> > > kennt überhaupt nur 3 Datentypen, nämlich String aka Text, Integer und
> > > Gleitkomma aka Double.
> >
> > Jep,
> > aber nur bedingt richtig "Wahrheitswert" (BOOL) hast Du unterschlagen...
>
> Nein; bool ist genauso nur ein Integerwert (0=falsch, alles
> andere=WAHR); probiers aus.
Das ist dann in etwa das selbe, wie wenn ich für jeden einzelne Fahrgast
einen Bus mit 60 Sitzplätzen auf die Reise schicke - wirklich sehr
effizient!
Kein Wunder,dass die Prozessoren immer schneller werden und am Ende die
Berechnungswartezeit trotzdem nicht kürzer wird...

> > Wenn das, was Du hier sagst richtig ist; das die Zeiten in Calc in
> > Fliesskomma-Werten hinterlegt sind; dann werden bei gewissen
> > Rechenoperationen unweigerlich Fehler auftrete.
>
> Tut es, ja. Allerdings so weit hinten, dass das nur sehr selten auf
> fällt. Aber gelegentlich tut es das; such mal im Archiv (siehe Footer)
> nach dem Thread "CALC: Uhrzeit wird beim Kopieren mit Maus falsch
> berechnet" vom 3.12.2019.
Auch das ist nur bedingt richtig. Wenn man kurze Zeiten zuerst dividiert
und erst anschliessend multipliziert, kann es schon es erheblichen
Rundungsfehler führen...

Für eben solches aber benutze ich z.B. Calc, da ich unter Anderem in der
Netzfrequenzen die Abweich-Toleranz im Drehfeld in Winkel° berechnen muss...
(Synchronisation von Generatoren)

> > Nicht gerade das Gesuchte. In INT würde solches nie auftreten. Auf
> > Leitsystemen mit Echtzeiteinträgen ist es Bedingung, dass die
> > Zeitstempel kohärent sind!
>
> Ähm; dir ist aber schon bewusst, was das Wort "kohärent" wirklich
> bedeutet, oder?

Im Zusammenhang mit Zeit sicherlich ein passender Begriff, wenn man
Gleichtakt, Phasengleichheit darunter versteht...

> > Meine Aussagen beruhen aber auf den Standard von den grundsätzlichen
> > ANY_INT Datentypen.
>
> Und was bitte hat das mit Calc zu tun? In Calc *gibt* es das alles
> nicht, bzw. nur als Abbildung in eine der 3 möglichen Datentypen.
>
> > Die Aufgliederung in BYTE ist darum zu berücksichtigen, weil die meisten
> > seriellen Transportmittel; CAN, PROFIBUS, MODBUS, Ethernet; Byte-weise
> > übertragen und die Speicher in Byte organisiert sind!
>
> Schon lange nicht mehr; sowohl die Übertragnung als auch die
> Speicherung. Die Speicherung innerhalb heutiger Hardware erfolgt fast
> ausschließlich 32-bitig oder 64-bitig, teilweise sogar schon 128-bitig;
> nur gaaaanz selten ist noch uralte 16-bit-Hardware in Gebrauch;
> 8-bit-Hardware gips bestenfalls noch im Museum. Und /serielle/
> Transportprotokolle wie die oben von dir aufgeführten heißen "seriell",
> weil sie die Bits einzeln, eines nach dem anderen, /hintereinander/
> übertragen, und nicht byteweise aka 8 bit parallel. Ob diese Bits
> anschließend wieder zu 8-, 16-, 32-, 64- oder 128-bit Ganz-, Festpunkt-
> oder Fließkommazahlen oder Strings oder noch was anderes zusammen
> gesetzt werden, ist dem Protokoll völlig wurscht.
Erzähl mir nun bitte über solche Protokolle keine Märchen...
 => C-Programm am Ende.
Wie willst Du den ohne Byte-Staffelung ein Transkript von seriell litle-
nach big-endian durchführen?

> Trotzdem muss ich mich wiederholen mit der Frage, was das alles mit Calc
> zu tun hat. Hint: Cals ist ein Tabellenkalkulationsprogramm, kein
> Transportprotokoll (und schon gar kein serielles).
> Die Frage ist immer noch die Selbe:
Warum wurde der Zeitstempel bei Calc in eine REAL hinterlegt?
Dar Programmiere muss doch einen triftigen Grund dafür gehabt haben...

> Wolfgang

Das folgende hat nun tatsächlich gar nichts mit Calc zu tun, ausser dass
die daraus resultierende Daten via OPC in eine Tabelle auf dem Server
eingetragen und als Graphik ausgegeben werden.

Das was ich hier einkopiert habe ist ein Konvertierungs-Funktionsblock,
welcher in eine übergeordnete System-Programmierung eingebunden wird.
Leider gibt es drei Konventionen für die serielle Übertragung die auf
das im Empfänger genutzte Protokoll umgeschrieben werden muss; das Rad
wird halt immer wieder mal neu erfunden.

Ist leider nicht sehr gut lesbar, da der Code mit mehr Zeichen je Zeile
aufgesetzt war.

(*SOFTCONTROL:
  VERSION:4.00.21*)
FUNCTION_BLOCK Cnv_LitleBigMixed_Endian
(**)
(**)
(*GroupPath='POUs'*)
        VAR_INPUT
                xEn: BOOL:=FALSE;
                        (*enable*)
                pModify: BOOL:=FALSE;
                        (*start to modify*)
                siCnvTyp: SINT:=0;
                        (*type of Convert
                        0 = 1 /1 Dut Copy no convert
                        1 = BigEnd <=> LtlEnd
                        2 = BigEnd <=> MxlEnd
                        3 = LtlEnd  <=> MxEnd*)
                uiInitSrc: UINT:=0;
                        (*first REAL to receive
                        = uiStartAddr_read_INT*)
                uiInitDst: UINT:=0;
                        (*first REAL to destination *)
                uiQntINT: UINT:=0;
                        (*number of INT to modify *)
        END_VAR
        VAR_IN_OUT
                dwSrcStart: DWORD;
                        (*Dut Start of recive*)
                dwDstStart: DWORD;
                        (*DUT Start of destination*)
                bDstEnd: BYTE;
                        (*Dut swaped *)
        END_VAR
        VAR_OUTPUT
                pErr: BOOL:=FALSE;
                        (*Eror of Copy*)
                QiErr: INT:=0;
                        (*Eror Code Copy
                        =  0  Loop Ready => "pMdfy"= TRUE
                        = >0 transfer is active
                        = -1 transfer is ended / 1 cycle active
                        = -2 transfer to break
                        reset to =0 set "pMdfy"= FALSE*)
        END_VAR
'C-CODE'
BODY
C_CODE_OBJECT_BODY
int     iSizeSrc, iSizeDst,     /* size of source,/-destination */
        iOfstSrc, iOfstDst,     /* offset source,/-destination  */
        iNmbrOfR, iCntLoop;     /* Number of REAL, loopcounter  */
char    *pSource, *pDstntn,     /* addresspointer -source,/-destination */
        iToTrim,                /* reduce modify                */
        b0 , b1, b2, b3;
                                /* Code of QiErr
                                =  0    Loop Ready
                                = >0 modifyed is run
                                = -1    modify is ended / 1 cycle active
                                = -2    modify is shorted
                                = -3    modifyed to break
                                = -4    INT-Source is odd =>
                                        REAL request even */

C_CODE_USER_AREA_BODY
if      (#LD(xEn)&&(#LD(pModify)||(iCntLoop >0)))
{       if      (iCntLoop >= 0)
        {       iOfstSrc        = #LD(uiInitSrc)*2;
                iOfstDst        = #LD(uiInitDst)*2;
                iSizeSrc        = #LD(uiQntINT)*2;
                iSizeDst        = ((char*)& #LD(bDstEnd)-(char*)& #LD(dwDstStart))-4;
        pSource = ((char*)& #LD(dwSrcStart)+4 +iOfstSrc);
        pDstntn = ((char*)& #LD(dwDstStart)+4 +iOfstDst);
        if      (iOfstSrc %4 == 0)
        {       if      (iSizeDst >= iSizeSrc)
                {       iNmbrOfR = iSizeSrc /4;#ST(pErr, FALSE);
                        iToTrim = 0;
                }
                else
                {       iNmbrOfR        = iSizeDst /4;
                        iToTrim = 1;
                }
                iCntLoop        = 0;
                while(iNmbrOfR > iCntLoop)
                {       memcpy (pDstntn +(4* iCntLoop)+b0, pSource +(4* iCntLoop)+0, 1);
                        memcpy (pDstntn +(4* iCntLoop)+b1, pSource +(4* iCntLoop)+1, 1);
                        memcpy (pDstntn +(4* iCntLoop)+b2, pSource +(4* iCntLoop)+2, 1);
                        memcpy (pDstntn +(4* iCntLoop)+b3, pSource +(4* iCntLoop)+3, 1);
                        ++ iCntLoop;
                                #ST(QiErr, iCntLoop);
                }
                if      (iToTrim == 0)
                {       iCntLoop        = -1;
                }
                else
                {       iCntLoop        = -2;
                        #ST(pErr, TRUE);
                }
                #ST(QiErr, iCntLoop);
                }
                else
                {       #ST(QiErr, -4);
                        #ST(pErr, TRUE);
                }
        }
}
else
{       iCntLoop        = 0;
        #ST(QiErr, iCntLoop);
        #ST(pErr, FALSE);
        switch(#LD(siCnvTyp))
        {       case    0 :     b0 = 0;
                                b1 = 1;
                                b2 = 2;
                                b3 = 3;
                case 1 :        b0 = 3;
                                b1 = 2;
                                b2 = 1;
                                b3 = 0;
                case 2 :        b0 = 1;
                                b1 = 0;
                                b2 = 3;
                                b3 = 2;
                case 3 :        b0 = 2;
                                b1 = 3;
                                b2 = 0;
                                b3 = 1;
        }
}

END_BODY
END_FUNCTION_BLOCK



--
Liste abmelden mit E-Mail an: users+unsubscribe@de.libreoffice.org
Probleme? https://de.libreoffice.org/hilfe-kontakt/mailing-listen/abmeldung-liste/
Tipps zu Listenmails: https://wiki.documentfoundation.org/Netiquette/de
Listenarchiv: https://listarchives.libreoffice.org/de/users/
Datenschutzerklärung: https://www.documentfoundation.org/privacy