summaryrefslogtreecommitdiff
path: root/app/gs.process/1.02/src/ls-Prozess 2
blob: 11cb4e702b14746784e1e365cd0dd651acf3a571 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
(* 
        
         ********************************************************** 
         ********************************************************** 
         **                                                      ** 
         **                     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{}