/********************************************************************

    AnaEin16.c2

    C2 programming language

    Erstellt am  : 14.09.2004
    Aenderung am : 16.01.2006
    Autor        : © Michael Gierschner
    Beschreibung :
      Erfassung und Berechnung von Temperaturen mit der Baugruppe
      Analog 16 x Ein

      Die berechneten Temperaturen werden als Integer bereit gestellt.
      Die Wertangabe ist in 10-tel Grad

********************************************************************/

//----------- Funktionen -------------------------------------------------------
//
// function Init ()
// function InitFuehlerTyp ()
// function InitFuehlerOffset ()
// function RT_FormelBerechnen ()
// function AnalogwertBerechnen (int adWert, int kanal) returns int
// thread Messen_AnaEin16_Werte
// function StartMessung ( )

const WARTEZEIT = 500;  // Zeit in Millisekunden zwischen der Abfrage von 2 Analogkanaelen
const ANZ_ANAEIN_16 = 4;

//--------- Konfigurierbare Variablen ------------------------------------------
byte AnaEing_CC2_Modul_0;        // Analogport für den die Werte ermittelt werden.
byte AnaEing_CC2_Modul_1;        // Analogport für den die Werte ermittelt werden.
byte AnaEing_CC2_Modul_2;        // Analogport für den die Werte ermittelt werden.
byte AnaEing_CC2_Modul_3;        // Analogport für den die Werte ermittelt werden.
//byte I2C_AdresseMultiplexer;     // Adresse I2C-Kanaleinstellung Analogmultiplexer
//===============================================================================
byte I2C_Adr_Modul_0;        // Adresse I2C-Kanaleinstellung Analogmultiplexer
byte I2C_Adr_Modul_1;        // Adresse I2C-Kanaleinstellung Analogmultiplexer
byte I2C_Adr_Modul_2;        // Adresse I2C-Kanaleinstellung Analogmultiplexer
byte I2C_Adr_Modul_3;        // Adresse I2C-Kanaleinstellung Analogmultiplexer

const ANA16xEIN_ND     = 0;  // Temperaturmodul nicht definiert
const ANA16xEIN_V1     = 1;  // Temperaturmodul 16xAnaEin Version 1.0: Ohne Hardwareabgleich
const ANA16xEIN_V2     = 2;  // Temperaturmodul 16xAnaEin Version 2.0: Mit Hardwareabgleich
const ANA16xEIN_V3     = 3;  // Temperaturmodul 16xAnaEin Version 3.0: geplante Version
const ANA16xEIN_PT1000 = 4;  // Temperaturmodul 16xAnaEin Version 3.0: geplante Version
const ANA_DIG_AUS      = 16; // Digital-Ausgangsmodul im Analogmodul fuer RT-Modul

byte I2C_Typ_Modul_0;        // Modultyp 16xAnaEin-Modul
byte I2C_Typ_Modul_1;        // Modultyp 16xAnaEin-Modul
byte I2C_Typ_Modul_2;        // Modultyp 16xAnaEin-Modul
byte I2C_Typ_Modul_3;        // Modultyp 16xAnaEin-Modul

//--------- Laufzeitvariablen --------------------------------------------------
int KanalAnalogMultiplexer; // Nummer des aktuell bearbeiteten Analogkanals
byte TemperaturKomplett;



//------------ Analogkanaldefinition -------------------------------------------

const ANA_PORT_NICHT_BELEGT = 64; // Erste ungueltige PCF8574-Adresse des AnaEin16-Moduls
const ANZ_ANALOGMODULE = 4;
const ANZ_ANALOG_MODULKANAELE = 16;
const ANZ_ANALOGPORTS = ANZ_ANALOGMODULE*ANZ_ANALOG_MODULKANAELE; // 4 Module mit je 16 Eingängen

int   PA_AnaEing         [ANZ_ANALOGPORTS];   // Prozessabbild der Analogkanaele
int   PA_AnaBerechnet    [ANZ_ANALOGPORTS];   // Fuehlertyp abhaengig berechnete Werte der Analogkanaele
int   AnaFuehlerOffset   [ANZ_ANALOGPORTS];   // Korrekturwert fuer Temperaturfuehler
byte  AnalogKanalTyp     [ANZ_ANALOGPORTS];   // Eingangskanaltyp des Analogkanals

int   StopTemperaturmessung;           // Stoppen der kontinuierlichen Temperaturmessung


//----------------------------------------------------------------------------------
// Analogmodul-Sensortypen
//----------------------------------------------------------------------------------

const ANA_KANAL_NICHT_BELEGT = 0;   // Definition der Fuehlertypen am Analog-Eingang
const ANA_KTY81_210          = 1;  // Temperaturmodul 16xAnaEin Version 1.0: Ohne Hardwareabgleich
const ANA_PT1000             = 2;  // PT-1000 Fühlertyp
const ANA_RT_SOLLWERT        = 3;  // Sollwertvorgabe mit RT-Modul Formel 1
const ANA_LICHTSENSOR_TYP1   = 4;  // Lichtsensor GDATA fuer Rolladenmodul
const ANA_LICHTSENSOR_TYP2   = 5;  // Lichtsensor im Windmesser
const ANA_ENDE               = 5;


//--------- KTY-Temperatur-Sollwert-Formel ----------------------------------
//
// Temperatur = Steigung * x + Offset
//

//-----------------------------------------------------------------------
// AD-Wandler-Grenzwerte fuer die Auswahl der Linearisierungsfunktion
// zur Temperaturberechnung.
// Es wird jeweils der Digitalwert, dessen Grenze zur Wahl der Funktion
// unterschritten werden muss, angegeben.
// Bei einem 10-Bit-Wandler sind Werte zwischen 0-1023 möglich.
//-----------------------------------------------------------------------

//-------------------------------------------------------
// Hardware Version 1.0 : ohne Hardwareabgleich
//-------------------------------------------------------

const KTY1_TEMP_1 = 436;  // entspricht  Grad
const KTY1_TEMP_2 = 533;  // entspricht  Grad
const KTY1_TEMP_3 = 727;  // entspricht  Grad
const KTY1_TEMP_4 = 1024; // entspricht  Grad
const KTY1_TEMP_5 = 1024; // entspricht  Grad

const KTY1_OFFSET_1 = -657.57554;
const KTY1_STEIGUNG_1 = 1.6618705;
const KTY1_OFFSET_2 = -636.643564;
const KTY1_STEIGUNG_2 = 1.61386139;
const KTY1_OFFSET_3 = -713.989474;
const KTY1_STEIGUNG_3 = 1.75789474;
const KTY1_OFFSET_4 = -713.989474;
const KTY1_STEIGUNG_4 = 1.75789474;

//-------------------------------------------------------
// Hardware Version 2.0 : Mit Hardwareabgleich
//-------------------------------------------------------
const KTY2_TEMP_1 = 436;  // entspricht  Grad
const KTY2_TEMP_2 = 533;  // entspricht  Grad
const KTY2_TEMP_3 = 727;  // entspricht  Grad
const KTY2_TEMP_4 = 1024; // entspricht  Grad
const KTY2_TEMP_5 = 1024; // entspricht  Grad

const KTY2_OFFSET_1 = -355.2;
const KTY2_STEIGUNG_1 = 1.6;
const KTY2_OFFSET_2 = -358.064516;
const KTY2_STEIGUNG_2 = 1.61290323;
const KTY2_OFFSET_3 = -346.315789;
const KTY2_STEIGUNG_3 = 1.57894737;
const KTY2_OFFSET_4 = -364.516129;
const KTY2_STEIGUNG_4 = 1.61290323;

//-------------------------------------------------------
// Hardware Version 3.0 : in Planung
//-------------------------------------------------------
const KTY3_TEMP_1 = 436;  // entspricht  Grad
const KTY3_TEMP_2 = 533;  // entspricht  Grad
const KTY3_TEMP_3 = 727;  // entspricht  Grad
const KTY3_TEMP_4 = 1024; // entspricht  Grad
const KTY3_TEMP_5 = 1024; // entspricht  Grad

const KTY3_OFFSET_1 = -355.2;
const KTY3_STEIGUNG_1 = 1.6;
const KTY3_OFFSET_2 = -358.064516;
const KTY3_STEIGUNG_2 = 1.61290323;
const KTY3_OFFSET_3 = -346.315789;
const KTY3_STEIGUNG_3 = 1.57894737;
const KTY3_OFFSET_4 = -364.516129;
const KTY3_STEIGUNG_4 = 1.61290323;

//--------- Pt1000-Temperatur-Sollwert-Formel ----------------------------------
//
// Temperatur = a * x + b
//


//--------- Raumtemperatur-Sollwert-Formel -------------------------------------
//
// Temperatur = a * x + b
//

const ANZ_RT_KENNLINIEN = 3;

float RT1_TempStandard;// Temperatur in 10tel Grad  bei Stellung Punkt BJ-Temperaturblende
float RT1_ADStandard;  // AD-Wert bei bei Stellung Punkt BJ-Temperaturblende
float RT1_Steigung;    // Steigung der Kennlinie

float RT2_TempStandard;// Temperatur in 10tel Grad  bei Stellung Punkt BJ-Temperaturblende
float RT2_ADStandard;  // AD-Wert bei bei Stellung Punkt BJ-Temperaturblende
float RT2_Steigung;    // Steigung der Kennlinie

float RT3_TempStandard;// Temperatur in 10tel Grad  bei Stellung Punkt BJ-Temperaturblende
float RT3_ADStandard;  // AD-Wert bei bei Stellung Punkt BJ-Temperaturblende
float RT3_Steigung;    // Steigung der Kennlinie

type anaEinDat_typ
{
  byte dummy1;
  byte dummy2;
  
  //-----------------------------------------------
  // PT1000-Temperaturmodul - Kennliniendefinition
  //-----------------------------------------------

  float Pt1000_a;   // Steigung
  float Pt1000_b;   // Offset
  
  //--------------------------------------------
  // Raumtemperaturmodul - Kennliniendefinition
  //--------------------------------------------
  int RT1_T2;   // Temperatur in 10tel Grad  bei Stellung 2 BJ-Temperaturblende
  int RT1_T6;   // Temperatur in 10tel Grad  bei Stellung 6 BJ-Temperaturblende
  int RT1_AD2;  // AD-Wert bei Stellung 2 BJ-Temperaturblende
  int RT1_AD6;  // AD-Wert bei Stellung 6 BJ-Temperaturblende

  int RT2_T2;   // Temperatur in 10tel Grad  bei Stellung 2 BJ-Temperaturblende
  int RT2_T6;   // Temperatur in 10tel Grad  bei Stellung 6 BJ-Temperaturblende
  int RT2_AD2;  // AD-Wert bei Stellung 2 BJ-Temperaturblende
  int RT2_AD6;  // AD-Wert bei Stellung 6 BJ-Temperaturblende

  int RT3_T2;   // Temperatur in 10tel Grad  bei Stellung 2 BJ-Temperaturblende
  int RT3_T6;   // Temperatur in 10tel Grad  bei Stellung 6 BJ-Temperaturblende
  int RT3_AD2;  // AD-Wert bei Stellung 2 BJ-Temperaturblende
  int RT3_AD6;  // AD-Wert bei Stellung 6 BJ-Temperaturblende

  //-----------------------------------------------
  // Lichtsensor 1 - Kennliniendefinition
  //-----------------------------------------------

  float Lichtsensor1_a;   // Steigung
  float Lichtsensor1_b;   // Offset

  //-----------------------------------------------
  // Lichtsensor 2 - Kennliniendefinition
  //-----------------------------------------------

  float Lichtsensor2_a;   // Steigung
  float Lichtsensor2_b;   // Offset
  
} 

anaEinDat_typ AnaEin16;

const KENNLINIE_EE_OFFSET  = 120;
const SIZE_KENNLINIEN      = 18 + ANZ_RT_KENNLINIEN*2*4 + 32;

//-----
//  dummy + PT1000+ X * RT-Modul + 2x Lichtsensor
//
// Variable vom Datentyp float umfasst 8Byte Speicher
//-----

// Korrektur von Temperaturfuehler-Toleranzen:
//--------------------------------------------------
//
// byte FuehlerOffset[ANZ_ANALOGPORTS];
// FuehlerOffset [x] = 0  // Standardwert
//                   < 0  // wenn angezeigte Temp. zu hoch
//                   > 0  // wenn angezeigte Temp. zu niedrig



function RT_FormelBerechnen ()
{
  RT1_TempStandard = (AnaEin16.RT1_T6 + AnaEin16.RT1_T2)/2;
  RT1_ADStandard   = (AnaEin16.RT1_AD6+ AnaEin16.RT1_AD2)/2;
  RT1_Steigung     = AnaEin16.RT1_T6;
  RT1_Steigung     = (RT1_Steigung - AnaEin16.RT1_T2)/(AnaEin16.RT1_AD6 - AnaEin16.RT1_AD2);

  RT2_TempStandard = (AnaEin16.RT2_T6 + AnaEin16.RT2_T2)/2;
  RT2_ADStandard   = (AnaEin16.RT2_AD6+ AnaEin16.RT2_AD2)/2;
  RT2_Steigung     = AnaEin16.RT2_T6;
  RT2_Steigung     = (RT2_Steigung - AnaEin16.RT2_T2)/(AnaEin16.RT2_AD6 - AnaEin16.RT2_AD2);

  RT3_TempStandard = (AnaEin16.RT3_T6 + AnaEin16.RT3_T2)/2;
  RT3_ADStandard   = (AnaEin16.RT3_AD6+ AnaEin16.RT3_AD2)/2;
  RT3_Steigung     = AnaEin16.RT3_T6;
  RT3_Steigung     = (RT3_Steigung - AnaEin16.RT3_T2)/(AnaEin16.RT3_AD6 - AnaEin16.RT3_AD2);

}

function AnalogwertBerechnen (int adWert, int modultyp, int kanal) returns int
{
  //-------------------------------------------------------------
  // Funktion zur Temperaturberechnung der Multiplexerkanaele
  // Das Ergebnis der Berechnung ist ein Integer-Wert, der
  // die Temperatur in 10tel Grad angibt.
  // Integer - Operationen koennen schneller ausgefuehrt werden.
  //-------------------------------------------------------------
  
  int messwert_berechnet;
  float f_messwert;
  float f_lichtSensorTyp1;
  float f_lichtSensorTyp2;
  float istwert;
  
  messwert_berechnet = adWert + AnaFuehlerOffset[kanal];
  f_messwert = messwert_berechnet;

  //----------------------------------------------------------------------------

  if ( modultyp == ANA16xEIN_V1)
  {
    if AnalogKanalTyp[kanal] == ANA_KTY81_210  // Fuehlertyp KTY81-210
    {
      if (messwert_berechnet < KTY1_TEMP_1 )
      { // Linearisierung Temperaturbereich unter 5°C
        return (f_messwert * KTY1_STEIGUNG_1 + KTY1_OFFSET_1);
      }
      if (messwert_berechnet < KTY1_TEMP_2)
      { // Linearisierung Temperaturbereich unter 21°C
        return (f_messwert * KTY1_STEIGUNG_2 + KTY1_OFFSET_2);
      }
      if (messwert_berechnet < KTY1_TEMP_3 )
      { // Linearisierung Temperaturbereich unter 58°C
        return (f_messwert * KTY1_STEIGUNG_3 + KTY1_OFFSET_3);
      }
      else // Linearisierung Temperatur ueber 58 °C
      {
        return (f_messwert * KTY1_STEIGUNG_4 + KTY1_OFFSET_4);
      }
    }
    else if AnalogKanalTyp[kanal] == ANA_RT_SOLLWERT
    {
      // Fuehlertyp Raumtemperatur-Sollwerteinstellung
      return  (RT1_TempStandard + (f_messwert-RT1_ADStandard) * RT1_Steigung);

    }
    else if AnalogKanalTyp[kanal] == ANA_LICHTSENSOR_TYP1 // Standard-Lichtsensor fuer Beschattung
    {
      f_lichtSensorTyp1 = (AnaEin16.Lichtsensor1_a * f_messwert + AnaEin16.Lichtsensor1_b );
      return f_lichtSensorTyp1;
    }
    else if AnalogKanalTyp[kanal] == ANA_LICHTSENSOR_TYP2  // Sensor im Windmesser
    {
      f_lichtSensorTyp1 = (AnaEin16.Lichtsensor1_a * f_messwert + AnaEin16.Lichtsensor1_b );
      return f_lichtSensorTyp1;
    }

    else if AnalogKanalTyp[kanal] == ANA_PT1000  // Fuehlertyp PT1000
    {
      return (AnaEin16.Pt1000_a * f_messwert + AnaEin16.Pt1000_b );
    }

  }
  //----------------------------------------------------------------------------
  else if ( modultyp == ANA16xEIN_V2)
  {
    if AnalogKanalTyp[kanal] == ANA_KTY81_210  // Fuehlertyp KTY81-210
    {
      if (messwert_berechnet < KTY2_TEMP_1 )
      { // Linearisierung Temperaturbereich unter 5°C
        return (f_messwert * KTY2_STEIGUNG_1 + KTY2_OFFSET_1);
      }
      if (messwert_berechnet < KTY2_TEMP_2)
      { // Linearisierung Temperaturbereich unter 21°C
        return (f_messwert * KTY2_STEIGUNG_2 + KTY2_OFFSET_2);
      }
      if (messwert_berechnet < KTY2_TEMP_3 )
      { // Linearisierung Temperaturbereich unter 58°C
        return (f_messwert * KTY2_STEIGUNG_3 + KTY2_OFFSET_3);
      }
      else // Linearisierung Temperatur ueber 58 °C
      {
        return (f_messwert * KTY2_STEIGUNG_4 + KTY2_OFFSET_4);
      }
    }
    else if AnalogKanalTyp[kanal] == ANA_RT_SOLLWERT
    {
      // Fuehlertyp Raumtemperatur-Sollwerteinstellung
      return  (RT2_TempStandard + (f_messwert-RT2_ADStandard) * RT2_Steigung);
    }
    else if AnalogKanalTyp[kanal] == ANA_LICHTSENSOR_TYP1 // Standard-Lichtsensor fuer Beschattung
    {
      f_lichtSensorTyp1 = (AnaEin16.Lichtsensor1_a * f_messwert + AnaEin16.Lichtsensor1_b );
      return f_lichtSensorTyp1;
    }
    else if AnalogKanalTyp[kanal] == ANA_LICHTSENSOR_TYP2  // Sensor im Windmesser
    {
      f_lichtSensorTyp1 = (AnaEin16.Lichtsensor1_a * f_messwert + AnaEin16.Lichtsensor1_b );
      return f_lichtSensorTyp1;
    }

    else if AnalogKanalTyp[kanal] == ANA_PT1000  // Fuehlertyp PT1000
    {
      return (AnaEin16.Pt1000_a * f_messwert + AnaEin16.Pt1000_b );
    }
  }
  //----------------------------------------------------------------------------
  
  else if ( modultyp == ANA16xEIN_V3)
  {
    if AnalogKanalTyp[kanal] == ANA_KTY81_210  // Fuehlertyp KTY81-210
    {
      if (messwert_berechnet < KTY3_TEMP_1 )
      { // Linearisierung Temperaturbereich unter 5°C
        return (f_messwert * KTY3_STEIGUNG_1 + KTY3_OFFSET_1);
      }
      if (messwert_berechnet < KTY3_TEMP_2)
      { // Linearisierung Temperaturbereich unter 21°C
        return (f_messwert * KTY3_STEIGUNG_2 + KTY3_OFFSET_2);
      }
      if (messwert_berechnet < KTY3_TEMP_3 )
      { // Linearisierung Temperaturbereich unter 58°C
        return (f_messwert * KTY3_STEIGUNG_3 + KTY3_OFFSET_3);
      }
      else // Linearisierung Temperatur ueber 58 °C
      {
        return (f_messwert * KTY3_STEIGUNG_4 + KTY3_OFFSET_4);
      }
    }
    else if AnalogKanalTyp[kanal] == ANA_RT_SOLLWERT
    {
      // Fuehlertyp Raumtemperatur-Sollwerteinstellung
      return  (RT3_TempStandard + (f_messwert-RT3_ADStandard) * RT3_Steigung);
    }
    else if AnalogKanalTyp[kanal] == ANA_LICHTSENSOR_TYP1 // Standard-Lichtsensor fuer Beschattung
    {
      f_lichtSensorTyp1 = (AnaEin16.Lichtsensor1_a * f_messwert + AnaEin16.Lichtsensor1_b );
      return f_lichtSensorTyp1;
    }
    else if AnalogKanalTyp[kanal] == ANA_LICHTSENSOR_TYP2  // Sensor im Windmesser
    {
      f_lichtSensorTyp1 = (AnaEin16.Lichtsensor1_a * f_messwert + AnaEin16.Lichtsensor1_b );
      return f_lichtSensorTyp1;
    }

    else if AnalogKanalTyp[kanal] == ANA_PT1000  // Fuehlertyp PT1000
    {
      return (AnaEin16.Pt1000_a * f_messwert + AnaEin16.Pt1000_b );
    }


  }

  //----------------------------------------------------------------------------

  //----------------------------------------------------------------------------
  
  else if AnalogKanalTyp[kanal] == ANA_LICHTSENSOR_TYP1
  {
     f_lichtSensorTyp1 = (AnaEin16.Lichtsensor1_a * f_messwert + AnaEin16.Lichtsensor1_b );
     return f_lichtSensorTyp1;
  }
  
  else if AnalogKanalTyp[kanal] == ANA_PT1000  // Fuehlertyp PT1000
  {
     return (AnaEin16.Pt1000_a * f_messwert + AnaEin16.Pt1000_b );
  }
  
}


thread Messen_AnaEin16_Werte
//----------------------------------------------------------------------
// Kontinuierliches Abfragen der Analogkanaele (z.B. Temperatur)
// Pro Durchlauf des Threads wird jeweils 1 Kanal eingelesen
//----------------------------------------------------------------------
{
  long messwert;
  int  ana_kanal;

/*
  if (StopTemperaturmessung)
    yield; // der Messvorgang wird zur Zeit nicht bearbeitet,
          // da eine andere Funktion auf die Hardware zugreift
*/
  while (StopTemperaturmessung == constant.TRUE)
    yield;
//    wait 1000;


  if KanalAnalogMultiplexer > 14
  {
    KanalAnalogMultiplexer = 0;
    TemperaturKomplett = 1;
  }
  else
    KanalAnalogMultiplexer = KanalAnalogMultiplexer+1;

  // Multiplexerkanal fuer bis zu 4 Module waehlen:
  //---------------------------------
  if ( I2C_Adr_Modul_0 < ANA_PORT_NICHT_BELEGT )
  {
    capture i2cmult.I2C_Sperren;
    i2cmult.out (I2C_Adr_Modul_0, KanalAnalogMultiplexer); // I2C : Multiplexerkanal einstellen
    if ( I2C_Adr_Modul_1 < ANA_PORT_NICHT_BELEGT )
    {
      i2cmult.out (I2C_Adr_Modul_1, KanalAnalogMultiplexer); // I2C : Multiplexerkanal einstellen
      if ( I2C_Adr_Modul_2 < ANA_PORT_NICHT_BELEGT )
      {
        i2cmult.out (I2C_Adr_Modul_2, KanalAnalogMultiplexer); // I2C : Multiplexerkanal einstellen
        if ( I2C_Adr_Modul_3 < ANA_PORT_NICHT_BELEGT )
        {
          i2cmult.out (I2C_Adr_Modul_3, KanalAnalogMultiplexer); // I2C : Multiplexerkanal einstellen
        }
      }
    }

    release;
  }
  sleep WARTEZEIT;
  //----------------------------------------------------------------------------
  // Die sleep-Zeit hat 2 Fuktionen:
  //   1. Einschwingzeit fuer Analog-Multiplexer und OP-Verstaerker abwarten,
  //      nach der Auswahl des Multiplexerkanals bekommt der Verstaerker die Zeit
  //      das Signal zu stabilisieren
  //   2. Es wird alle 0,5 Sekunden ein Kanal abgefragt. Nach 8 Sekunden sind alle
  //      Kanaele einer Baugruppe komplett und eine neue Abfrage beginnt.
  //      Bei der Traegheit von Temperatursystemen sollte das ausreichen.
  //----------------------------------------------------------------------------
  
  if ( anaein16.AnalogKanalTyp[KanalAnalogMultiplexer] != anaein16.ANA_KANAL_NICHT_BELEGT)
  {
     messwert = ports.adc (AnaEing_CC2_Modul_0);
     anaein16.PA_AnaEing    [KanalAnalogMultiplexer] = messwert;
     anaein16.PA_AnaBerechnet [KanalAnalogMultiplexer]  = anaein16.AnalogwertBerechnen (messwert, I2C_Typ_Modul_0, KanalAnalogMultiplexer);
     
     ana_kanal = KanalAnalogMultiplexer | 16; // 16 dazuaddieren! Oder schneller als Addition

     if ( anaein16.AnalogKanalTyp[ana_kanal] != anaein16.ANA_KANAL_NICHT_BELEGT)
     {
       messwert = ports.adc (AnaEing_CC2_Modul_1);
       anaein16.PA_AnaEing    [ana_kanal] = messwert;
       anaein16.PA_AnaBerechnet [ana_kanal] = anaein16.AnalogwertBerechnen (messwert, I2C_Typ_Modul_1, ana_kanal);
       
      ana_kanal = KanalAnalogMultiplexer | 32; // 32 dazuaddieren!
      if ( anaein16.AnalogKanalTyp[ana_kanal] != anaein16.ANA_KANAL_NICHT_BELEGT)
      {
        messwert = ports.adc (AnaEing_CC2_Modul_2);
        anaein16.PA_AnaEing    [ana_kanal] = messwert;
        anaein16.PA_AnaBerechnet [ana_kanal] = anaein16.AnalogwertBerechnen (messwert, I2C_Typ_Modul_2, ana_kanal);
       
        ana_kanal = KanalAnalogMultiplexer | 48; // 48 dazuaddieren!
        if ( anaein16.AnalogKanalTyp[ana_kanal] != anaein16.ANA_KANAL_NICHT_BELEGT)
        {
          messwert = ports.adc (AnaEing_CC2_Modul_3);
          anaein16.PA_AnaEing    [ana_kanal] = messwert;
          anaein16.PA_AnaBerechnet [ana_kanal] = anaein16.AnalogwertBerechnen (messwert, I2C_Typ_Modul_3, ana_kanal);
        }
      }
    }
  }
}



function InitFuehlerTyp ()
{
  int n;

  // Temperaturmodul 1
  //---------------------------------
  AnalogKanalTyp[0] = ANA_KTY81_210;
  AnalogKanalTyp[1] = ANA_KTY81_210;
  AnalogKanalTyp[2] = ANA_KTY81_210;
  AnalogKanalTyp[3] = ANA_KTY81_210;
  AnalogKanalTyp[4] = ANA_KTY81_210;
  AnalogKanalTyp[5] = ANA_KTY81_210;
  AnalogKanalTyp[6] = ANA_KTY81_210;
  AnalogKanalTyp[7] = ANA_KTY81_210;
  AnalogKanalTyp[8] = ANA_KTY81_210;
  AnalogKanalTyp[9] = ANA_KTY81_210;
  AnalogKanalTyp[10] = ANA_KTY81_210;
  AnalogKanalTyp[11] = ANA_KTY81_210;
  AnalogKanalTyp[12] = ANA_KTY81_210;
  AnalogKanalTyp[13] = ANA_KTY81_210;
  AnalogKanalTyp[14] = ANA_KTY81_210;
  AnalogKanalTyp[15] = ANA_KTY81_210;

  // Temperaturmodul 2: Z.B. Raumtemperaturmodul
  //---------------------------------
  AnalogKanalTyp[16] = ANA_KTY81_210;
  AnalogKanalTyp[17] = ANA_RT_SOLLWERT;
  AnalogKanalTyp[18] = ANA_KTY81_210;
  AnalogKanalTyp[19] = ANA_RT_SOLLWERT;
  AnalogKanalTyp[21] = ANA_KTY81_210;
  AnalogKanalTyp[22] = ANA_RT_SOLLWERT;
  AnalogKanalTyp[23] = ANA_KTY81_210;
  AnalogKanalTyp[24] = ANA_RT_SOLLWERT;
  AnalogKanalTyp[25] = ANA_KTY81_210;
  AnalogKanalTyp[26] = ANA_RT_SOLLWERT;
  AnalogKanalTyp[27] = ANA_KTY81_210;
  AnalogKanalTyp[28] = ANA_RT_SOLLWERT;
  AnalogKanalTyp[29] = ANA_KTY81_210;
  AnalogKanalTyp[30] = ANA_RT_SOLLWERT;
  AnalogKanalTyp[31] = ANA_KTY81_210;
  AnalogKanalTyp[32] = ANA_RT_SOLLWERT;
  
  // Temperaturmodul 3
  //---------------------------------
  AnalogKanalTyp[33] = ANA_PT1000;
  AnalogKanalTyp[34] = ANA_PT1000;
  AnalogKanalTyp[35] = ANA_PT1000;
  AnalogKanalTyp[36] = ANA_PT1000;
  AnalogKanalTyp[37] = ANA_PT1000;
  AnalogKanalTyp[38] = ANA_PT1000;
  AnalogKanalTyp[39] = ANA_PT1000;
  AnalogKanalTyp[41] = ANA_PT1000;
  AnalogKanalTyp[42] = ANA_PT1000;
  AnalogKanalTyp[43] = ANA_PT1000;
  AnalogKanalTyp[44] = ANA_PT1000;
  AnalogKanalTyp[45] = ANA_PT1000;
  AnalogKanalTyp[46] = ANA_PT1000;
  AnalogKanalTyp[47] = ANA_PT1000;
  AnalogKanalTyp[48] = ANA_PT1000;

  // Temperaturmodul 4
  //---------------------------------
  for n=49 ... 63
    AnalogKanalTyp[n] = ANA_KANAL_NICHT_BELEGT;

}


function InitFuehlerOffset ()
{
    // Temperaturmodul 1
    //---------------------------------
    AnaFuehlerOffset[0]  = 0;
    AnaFuehlerOffset[1]  = 0;
    AnaFuehlerOffset[2]  = 0;
    AnaFuehlerOffset[3]  = 0;
    AnaFuehlerOffset[4]  = 0;
    AnaFuehlerOffset[5]  = 0;
    AnaFuehlerOffset[6]  = 0;
    AnaFuehlerOffset[7]  = 0;
    AnaFuehlerOffset[8]  = 0;
    AnaFuehlerOffset[9]  = 0;
    AnaFuehlerOffset[10] = 0;
    AnaFuehlerOffset[11] = 0;
    AnaFuehlerOffset[12] = 0;
    AnaFuehlerOffset[13] = 0;
    AnaFuehlerOffset[14] = 0;
    AnaFuehlerOffset[15] = 0;

    // Temperaturmodul 2
    //---------------------------------
    AnaFuehlerOffset[16] = 0;
    AnaFuehlerOffset[17] = 3;
    AnaFuehlerOffset[18] = 0;
    AnaFuehlerOffset[19] = 0;
    AnaFuehlerOffset[20] = 0;
    AnaFuehlerOffset[21] = 0;
    AnaFuehlerOffset[22] = 0;
    AnaFuehlerOffset[23] = 0;
    AnaFuehlerOffset[24] = 0;
    AnaFuehlerOffset[25] = 0;
    AnaFuehlerOffset[26] = 0;
    AnaFuehlerOffset[27] = 0;
    AnaFuehlerOffset[28] = 0;
    AnaFuehlerOffset[29] = 0;
    AnaFuehlerOffset[30] = 0;
    AnaFuehlerOffset[31] = 0;

    // Temperaturmodul 3
    //---------------------------------
    AnaFuehlerOffset[32] = 0;
    AnaFuehlerOffset[33] = 0;
    AnaFuehlerOffset[34] = 0;
    AnaFuehlerOffset[35] = 0;
    AnaFuehlerOffset[36] = 0;
    AnaFuehlerOffset[37] = 0;
    AnaFuehlerOffset[38] = 0;
    AnaFuehlerOffset[39] = 0;
    AnaFuehlerOffset[40] = 0;
    AnaFuehlerOffset[41] = 0;
    AnaFuehlerOffset[42] = 0;
    AnaFuehlerOffset[43] = 0;
    AnaFuehlerOffset[44] = 0;
    AnaFuehlerOffset[45] = 0;
    AnaFuehlerOffset[46] = 0;
    AnaFuehlerOffset[47] = 0;

    // Temperaturmodul 4
    //---------------------------------
    AnaFuehlerOffset[48] = 0;
    AnaFuehlerOffset[49] = 0;
    AnaFuehlerOffset[50] = 0;
    AnaFuehlerOffset[51] = 0;
    AnaFuehlerOffset[52] = 0;
    AnaFuehlerOffset[53] = 0;
    AnaFuehlerOffset[54] = 0;
    AnaFuehlerOffset[55] = 0;
    AnaFuehlerOffset[56] = 0;
    AnaFuehlerOffset[57] = 0;
    AnaFuehlerOffset[58] = 0;
    AnaFuehlerOffset[59] = 0;
    AnaFuehlerOffset[60] = 0;
    AnaFuehlerOffset[61] = 0;
    AnaFuehlerOffset[62] = 0;
    AnaFuehlerOffset[63] = 0;
}


function StartMessung ( )
{
//------------------------------------------------------------------------------
// Temperaturtread wird gestartet 
// vorher muss die Init-Funktion aufgerufen werden
//------------------------------------------------------------------------------

  if I2C_Adr_Modul_0 < 99
  {
    run Messen_AnaEin16_Werte;
    lcdext.goto (3,0);
    lcdext.print ("Adr. AD-Wandler: ");
    lcdext.zahl2 ( I2C_Adr_Modul_0);
    lcdext.goto (4,0);
    while (anaein16.TemperaturKomplett == 0)
    {
      sleep 500;
      lcdext.print (".");
    }
  }
}

function Init ( )


{

  //----------------------------------------------------------------------------
  // Definition des Modultyps vom Analog-Eingangsmodul
  //
  I2C_Typ_Modul_0 = ANA16xEIN_V2;  // Modultyp 16xAnaEin-Modul
  I2C_Typ_Modul_1 = ANA16xEIN_V2;  // ANA16xEIN_V1 // Version 1.0: Ohne Hardwareabgleich
  I2C_Typ_Modul_2 = ANA16xEIN_V2;  // ANA16xEIN_V2 // Version 2.0: Mit Hardwareabgleich
  I2C_Typ_Modul_3 = ANA16xEIN_V2;  // ANA16xEIN_V3 // Version 3.0: geplante Version




  //----------------------------------------------------------------------------
  // Definition der PCF-Adressen fuer maximal 4 Temperaturmodule
  //

  anaein16.I2C_Adr_Modul_0 = 15;
  anaein16.I2C_Adr_Modul_1 = anaein16.ANA_PORT_NICHT_BELEGT;
  anaein16.I2C_Adr_Modul_2 = anaein16.ANA_PORT_NICHT_BELEGT;
  anaein16.I2C_Adr_Modul_3 = anaein16.ANA_PORT_NICHT_BELEGT;


  //----------------------------------------------------------------------------
  // Definition fuer Verbindung mit Flachbandleitung zwischen 
  // CC2-Modul und Temperaturmodul (gemäß Jumperstellung)
  //
  AnaEing_CC2_Modul_0 = 0;    // Analog-Eingang der CC2 für 16xAnalog-Eing.-Modul
  AnaEing_CC2_Modul_1 = 1;    // Analog-Eingang der CC2 für 16xAnalog-Eing.-Modul
  AnaEing_CC2_Modul_2 = 2;    // Analog-Eingang der CC2 für 16xAnalog-Eing.-Modul
  AnaEing_CC2_Modul_3 = 3;    // Analog-Eingang der CC2 für 16xAnalog-Eing.-Modul

  //----------------------------------------------------------------------------
  // Folgende Variablen enthalten noch keine sinnvollen Werte
  // Um Fehler, z.B. Division durch 0, zu vermeiden, wird mit dem Wert 1 initialisiert.
  
  AnaEin16.Pt1000_a = 1;   // Steigung
  AnaEin16.Pt1000_b = 1;   // Offset

  //-------- Konfiguration Raumtemperatureinsteller -----------

  anaein16.AnaEin16.RT1_T2 = 200;   // Temperatur in 10tel Grad  bei Stellung 2 BJ-Temperaturblende
  anaein16.AnaEin16.RT1_T6 = 240;   // Temperatur in 10tel Grad  bei Stellung 6 BJ-Temperaturblende
  anaein16.AnaEin16.RT1_AD2= 380;  // AD-Wert bei Stellung 2 BJ-Temperaturblende
  anaein16.AnaEin16.RT1_AD6= 476;  // AD-Wert bei Stellung 6 BJ-Temperaturblende

  anaein16.AnaEin16.RT2_T2 = 200;   // Temperatur in 10tel Grad  bei Stellung 2 BJ-Temperaturblende
  anaein16.AnaEin16.RT2_T6 = 240;   // Temperatur in 10tel Grad  bei Stellung 6 BJ-Temperaturblende
  anaein16.AnaEin16.RT2_AD2= 380;  // AD-Wert bei Stellung 2 BJ-Temperaturblende
  anaein16.AnaEin16.RT2_AD6= 476;  // AD-Wert bei Stellung 6 BJ-Temperaturblende

  anaein16.AnaEin16.RT3_T2 = 200;   // Temperatur in 10tel Grad  bei Stellung 2 BJ-Temperaturblende
  anaein16.AnaEin16.RT3_T6 = 240;   // Temperatur in 10tel Grad  bei Stellung 6 BJ-Temperaturblende
  anaein16.AnaEin16.RT3_AD2= 380;  // AD-Wert bei Stellung 2 BJ-Temperaturblende
  anaein16.AnaEin16.RT3_AD6= 476;  // AD-Wert bei Stellung 6 BJ-Temperaturblende

  //----------------------------------------------------------------------------

  StopTemperaturmessung = constant.FALSE;
  
  InitFuehlerTyp ();
  InitFuehlerOffset ();
  TemperaturKomplett = 0;

}