(* 
        
         ********************************************************** 
         ********************************************************** 
         **                                                      ** 
         **                     ls-Prozess 2                     ** 
         **                                                      ** 
         **                     Version 1.02                     ** 
         **                                                      ** 
         **                  (Stand : 06.06.89)                  ** 
         **                                                      ** 
         **                                                      ** 
         **                                                      ** 
         **         Autoren: Bruno Pollok, Bielefeld             ** 
         **                  Wolfgang Weber, Bielefeld           ** 
         **                                                      ** 
         **                                                      ** 
         **    Copyright (C) 1988  Eva Latta-Weber, Bielefeld    ** 
         **    Copyright (C) 1990  ERGOS GmbH, Siegburg          ** 
         ********************************************************** 
         ********************************************************** 
 
                                                                           *) 
PACKET ls prozess 2 DEFINES                   
       wert an analogausgang ausgeben,
       spannungswert ausgeben,
       bitsymbol ausgeben,
       bitmuster ausgeben,
       dezimalwert ausgeben,
       bitmuster gleich,
       bit ist gesetzt,
       wert von analogeingang,
       spannungswert,
       bitsymbol,
       bitmuster,
       dezimalwert:
LET    eins   = "I",
       null   = "O",
       invers = "T",
       egal   = "X";
REAL CONST maximalwert :: real (ganzzahl obergrenze - 1);
(********************* A U S G A B E - B E F E H L E *********************)

PROC wert an analogausgang ausgeben (INT CONST kanal, wert):
  pruefe kanal (kanal, analog aus);
  ausgeben (kanal, wert MOD ganzzahlobergrenze)
END PROC wert an analogausgang ausgeben;
PROC spannungswert ausgeben (INT  CONST kanal, REAL CONST wert):
  pruefe kanal (kanal, analog aus);
  pruefe spannungswert;
  ausgeben (kanal, gewandelte spannung).
  pruefe spannungswert:
    REAL VAR u min, u max;
    hole spannungsbereich (kanal, u min, u max);
    IF wert < u min OR wert > u max
       THEN errorstop ("Der Spannungswert " + text (wert) +

                       " ist nicht zulaessig!")
    FI.
  gewandelte spannung:
    int (((wert - u min) * maximalwert) / (u max - u min) + 0.5).
END PROC spannungswert ausgeben;
PROC bitsymbol ausgeben (INT  CONST kanal, bitnummer, TEXT CONST zeichen):
  pruefe kanal (kanal, digital aus);
  pruefe bitnummer (bitnummer);
  ausgeben (kanal, relativer dezimalwert (zeichen, bitnummer, kanal))
END PROC bitsymbol ausgeben;
PROC bitmuster ausgeben (INT  CONST kanal, TEXT CONST zeichenkette):

  pruefe kanal (kanal, digital aus);
  ausgeben (kanal, relativer dezimalwert (zeichenkette, kanal))
END PROC bitmuster ausgeben;
PROC dezimalwert ausgeben (INT CONST kanal, wert):
  pruefe kanal (kanal, digital aus);
  ausgeben (kanal, wert MOD ganzzahl obergrenze)
END PROC dezimalwert ausgeben;
(********************* E I N G A B E - B E F E H L E *********************)
BOOL PROC bitmuster gleich (INT CONST kanal, TEXT CONST zeichenkette):
  INT CONST eingabewert :: dezimalwert (kanal);

  pruefe zeichenkette;
  eingabe passt zur zeichenkette.
  pruefe zeichenkette:
    IF length (zeichenkette) <> kanalbreite
       THEN errorstop ("Das Bitmuster '" + zeichenkette +
                       "' hat eine unzulaessige Laenge!")
    FI.
  eingabe passt zur zeichenkette:
   INT VAR stelle;
   BOOL VAR abweichung gefunden :: FALSE;
   FOR stelle FROM 1 UPTO kanalbreite REP
     teste bit an dieser stelle
   UNTIL abweichung gefunden PER;
   NOT abweichung gefunden.
 teste bit an dieser stelle:

   TEXT CONST einzelbit :: zeichenkette SUB stelle;
   IF   einzelbit = eins
        THEN teste eingabebit auf eins
   ELIF einzelbit = null
        THEN teste eingabebit auf null
   ELIF einzelbit = egal
        THEN eingabebit ist beliebig
   ELSE errorstop ("'" + einzelbit + "' ist unzulaessiges " +
                   "Bitsymbol in '" + zeichenkette + "'!")
   FI.
 teste eingabebit auf eins:
   IF NOT bit (eingabewert, kanalbreite - stelle)
      THEN abweichung gefunden := TRUE
   FI.

 teste eingabebit auf null:
   IF bit (eingabewert, kanalbreite - stelle)
      THEN abweichung gefunden := TRUE
   FI.
 eingabebit ist beliebig:
   .
END PROC bitmuster gleich;
BOOL PROC bit ist gesetzt (INT CONST kanal, bitnummer):
  pruefe kanal (kanal, digital ein);
  pruefe bitnummer (bitnummer);
  IF bit (eingabe (kanal), bitnummer)
     THEN TRUE
     ELSE FALSE
  FI
END PROC bit ist gesetzt;
INT PROC wert von analogeingang (INT CONST kanal):
  pruefe kanal (kanal, analog ein);

  eingabe (kanal)
END PROC wert von analogeingang;
REAL PROC spannungswert (INT CONST kanal):
  INT CONST dezimalwert :: wert von analogeingang (kanal);
  REAL  VAR u min, u max;
  hole spannungsbereich (kanal, u min, u max);
  round (real (dezimalwert) * (u max - u min) / maximalwert + u min, 3)
END PROC spannungswert;
TEXT PROC bitsymbol (INT CONST kanal, bitnummer):
  pruefe kanal (kanal, digital ein);
  pruefe bitnummer (bitnummer);
  IF bit (eingabe (kanal), bitnummer)
     THEN eins

     ELSE null
  FI
END PROC bitsymbol;
TEXT PROC bitmuster (INT CONST kanal):
  TEXT VAR   zeichenkette :: "";
  INT  CONST wert         :: dezimalwert (kanal);
  wandle wert;
  zeichenkette.
  wandle wert:
    INT VAR zeiger;
    FOR zeiger FROM kanalbreite - 1 DOWNTO 0 REP
      IF bit (wert, zeiger)
         THEN zeichenkette CAT eins
         ELSE zeichenkette CAT null
      FI
    PER.
END PROC bitmuster;
INT PROC dezimalwert (INT CONST kanal):
  pruefe kanal (kanal, digital ein);

  eingabe (kanal)
END PROC dezimalwert;
(******************** H I L F S - P R O Z E D U R E N ********************)
INT PROC relativer dezimalwert (TEXT CONST zeichenkette, INT CONST kanal):
   INT VAR wert := letzte ausgabe (kanal);
   pruefe zeichenkette auf korrekte laenge;
   veraendere alten wert;
   wert.
   pruefe zeichenkette auf korrekte laenge:
     IF length (zeichenkette) <> kanalbreite
        THEN errorstop ("Bitmuster '" + zeichenkette + "' hat "
                                      + "unzulaessige Laenge!")

     FI.
   veraendere alten wert:
     INT VAR zeiger;
     FOR zeiger FROM 1 UPTO kanalbreite REP
       veraendere dieses bit
     PER.
   veraendere dieses bit:
     TEXT CONST einzelbit :: zeichenkette SUB zeiger;
     IF   einzelbit = eins   THEN setze bit
     ELIF einzelbit = null   THEN loesche bit
     ELIF einzelbit = invers THEN invertiere bit
     ELIF einzelbit = egal   THEN lasse bit
     ELSE errorstop ("'" + einzelbit + "' ist unzulaessiges " +
                     "Bitsymbol in '" + zeichenkette + "'!")

     FI.
   setze bit:
     set bit (wert, kanalbreite - zeiger).
   loesche bit:
     reset bit (wert, kanalbreite - zeiger).
   invertiere bit:
     IF bit (wert, kanalbreite - zeiger)
        THEN loesche bit
        ELSE setze bit
     FI.
   lasse bit:
     .
  END PROC relativer dezimalwert;
INT PROC relativer dezimalwert (TEXT CONST bitzeichen,
                                INT  CONST bitnummer, kanal):
    INT VAR wert :: letzte ausgabe (kanal);
    IF   bitzeichen = eins   THEN setze bit

    ELIF bitzeichen = null   THEN loesche bit
    ELIF bitzeichen = invers THEN invertiere bit
    ELIF bitzeichen = egal   THEN lasse bit
    ELSE errorstop ("'" + bitzeichen + "' ist ein unzulaessiges " +
                                       "Bitsymbol!")
    FI;
    wert.
   setze bit:
     set bit (wert, bitnummer).
   loesche bit:
     reset bit (wert, bitnummer).
   invertiere bit:
     IF bit (wert, bitnummer)
        THEN loesche bit
        ELSE setze bit
     FI.
   lasse bit:

     .
END PROC relativer dezimalwert;
PROC pruefe bitnummer (INT CONST bitnummer):
  IF bitnummer < 0  OR  bitnummer > kanalbreite - 1
     THEN errorstop ("Bitnummer " + text (bitnummer) +
                     " ist nicht zulaessig!")
  FI
END PROC pruefe bitnummer
END PACKET ls prozess 2