Sie sind hier: Home » Datenlogger V2 » Programm V2 » Prg Main V2

'*******************************************************************************
'*******      Test-Version des DATENLOGGER V2   V0.97 mit 2 x I2C    ***********
'*******************************************************************************

'name                     : Datenlogger V0.96x2.bas
'copyright                : (c) 09.07.2017 jep
'purpose                  : Datenlogger für Temperaturen und Zustände
'micro                    : Mega1284P-PU
'
'Changelog:
'
'_______________________________________________________________________________
'Vorversions-Changelog:
'Changelog:           V0.1: Initalversion
'                     V0.2: Menuepunkte z.T. ausprogrammiert
'                     V0.3: lauffähige Version mit Fehlern bei der Anzeige
'                     V0.4: Fehler korrigiert, besser strukturiert
'                     V0.5: Programmvereinfachungen, Vorbereitungen für SD-Karte
'                     V0.6: zusätzlich mit schreiben auf SD-Karte
'                     V0.7: kleine Korrekturen
'                     V0.8: erste lauffähige Version mit SD-Karte mit Fehlern
'                     V0.9: korrigierte Version, fixer Filename
'                     V0.92:DCF77-Empfang über einen Pin deaktivieren; währen I2C-Transfer kein Interrupt
'                     V0.93:TWI-Interruptroutine aus dem Internet integriert
'                     V0.93a:wie 0.93 ohne die vielen Printbefehle und Ausschlüsse
'                     V0.94: reformatted, bedingte Printerausgabe
'                     V0.94b: Bei TWI-Empfang geändert um TWI sofort freizugeben
'                     V0.95:Erste gebrauchsfähige Version; DCF-Sync nachgeführt
'                     V0.95a:Mit Funküberwachung
'                     V0.95a_Test: um den I2C-Bus zu überwachen
'                     V0.95b_Test: wieder vereinfacht
'                     V0.96:Vereinfachungen
'                     V0.96x2: mit 2 I2C-Bussen
'                     V0.97: 2 I2C-Busse und Feuchte
'_______________________________________________________________________________
'_______________________________________________________________________________

$regfile = "m1284Pdef.dat"                                  'ATMEL Mega128P-PU
$crystal = 20000000                                         'mit 20 MHz-Clock
$hwstack = 100                                              'default use 32 for the hardware stack
$swstack = 60                                               'default use 10 for the SW stack
$framesize = 80                                             'default use 40 for the frame space

Config Com1 = 19200 , Synchrone = 0 , Parity = None , Stopbits = 1 , Databits = 8 , Clockpol = 0       'Printerausgabe
Open "com1:" For Binary As #1

$include "Logger_FATfree_SD_lib_decl.bas"                   '
$include "MyTWI.bas"
$include "Datenlogger2_Definitionen V0.97.bas"

'Für Printausgabe bei Tests
Const Printerausgabe = 0                                    '1 = Printerausgabe; 0 = keine Ausgabe
'Für die Anzeige des I2C-Buszustands
Const I2C_Anzeige = 1                                       '1 = Anzeige; 0 = keine Anzeige


'                                     *
'                                ***********
'                        ****************************
'                ********************************************
'        *************************************************************
'    **********************************************************************
'********************************  PROGRAMMSTART   *****************************
'*******************************************************************************

Print
Print "************************************************"
Print "************   Programmstart   *****************"
Print "********  Datenlogger2 V0.97.bas  **************"
Print "************************************************"

For v = 1 to 100                                            'Funkzustandspuffer löschen
   Funkzust(v) = 0
next

Enable Interrupts
Gosub Twi_sense                                             'Aktivieren Slave-Funktion

PgStart:                                                    'Initialisierung
Gbuffer = Chr(27) + "YH" + Chr(Helligkeit)                  '60% brightness
Gosub Write_edip
Gbuffer = Chr(27) + "TA"                                    'Terminal ausschalten
Gosub Write_edip
Gbuffer = Chr(27) + "DL" + Chr(13)                          'Display löschen
Gosub Write_edip
Gbuffer = Chr(27) + "ZF" + Chr(3) + Chr(13)                 '3 = FONT 7x12
Gosub Write_edip
Gbuffer = Chr(27) + "ZL" + Chr(1) + Chr(z2) + "Datenlogger Version 2 mit SD-Karte" + Chr(13)
Gosub Write_edip
Gbuffer = Chr(27) + "ZL" + Chr(1) + Chr(z3) + "File: Datenlogger_V2 V0.96x2.bas" + Chr(13)
Gosub Write_edip
Gbuffer = Chr(27) + "ZL" + Chr(1) + Chr(z4) + "mit 2 I2C-Bussen" + Chr(13)
Gosub Write_edip
gosub getDatumZeit                                          'interne Zeit mit RTC synchronisieren
Gbuffer = Chr(27) + "ZL" + Chr(30) + Chr(z5) + Date$ + "  " + Time$ + Chr(13)
Gosub Write_edip
wait 3

PgStart1:
Gosub SD_Init                                               'SD-Karte initialisieren
waitms 500
If Sdstatus <> 0 then
   Gbuffer = Chr(27) + "ZB2" + Chr(13) + Chr(27) + "ZL" + Chr(1) + Chr(z6) + "Keine SD-Karte / schreibgesch" + chr(129) + "tzt" + Chr(13) + Chr(27) + "ZB0" + Chr(13)
   Gosub Write_edip
   Gbuffer = Chr(27) + "ZB2" + Chr(13) + Chr(27) + "ZL" + Chr(1) + Chr(z8) + "Mit OK " + chr(129) + "berspringen" + Chr(13) + Chr(27) + "ZB0 " + Chr(13)
   Gosub Write_edip
   For n = 1 to 255
      Debounce Ok , 0 , Ueberspringen
      waitms 20
   next n
   goto PgStart1
  Else
   Gbuffer = Chr(27) + "RL" + Chr(1) + Chr(71) + Chr(240) + Chr(113) + Chr(13)       'Zeile 6 - 8 löschen
   Gosub Write_edip
   Gbuffer = Chr(27) + "ZL" + Chr(1) + Chr(z6) + "SD-Karte initialisiert" + Chr(13)
   Gosub Write_edip
End if

Ueberspringen:

'Zeiten vorbesetzen
h_WP_ein = makebcd(_hour)
m_WP_ein = makebcd(_min)
h_WP_aus = makebcd(_hour)
m_WP_aus = makebcd(_min)
h_Roebby_ein = makebcd(_hour)
m_Roebby_ein = makebcd(_min)
h_Roebby_aus = makebcd(_hour)
m_Roebby_aus = makebcd(_min)

Wait 3
For n = 1 to Max_daten                                      'Eingangsarray überschreiben
    Daten_in(n) = 99                                        'damit beim Start nichts angezeigt wird
next n
Daten_in(6) = 0                                             'alle STATISCHEN Signale auf 0 setzen
Gbuffer = Chr(27) + "DL" + Chr(13)                          'Display löschen
Gosub Write_edip
Syncanzeige = "0"

Gosub Read_adress_pointer                                   'zuerst wird der Adresspointer auf den letzten Stand gesetzt
Gosub Test_WP                                               'dann die unteren 2 Zeilen
Gosub Test_Roebby                                           'vorbereitet


'+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
'+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
'+++++++++++++++++++++++++++++   Hauptschleife   +++++++++++++++++++++++++++++++
'+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
'+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Do
   If Twi_slv_flag <> 0 Then                                'ZSE hat was gesendet

      #if I2C_Anzeige = 1
         Gbuffer = Chr(27) + "ZL" + Chr(198) + Chr(14) + "Slv " + Hex(Twi_slv_flag) + Chr(13)
         Gosub Write_edip
      #EndIf

      Y = TWI_slv_buff(1) + 1                               'totale Datenlänge = LEN +1
      u = memcopy(TWI_slv_buff(1) , TWI_Eingangspuffer(1) , Y)       'Daten umkopieren (retten)
      TWI_E_status = Twi_slv_flag                           'Statusflag kopieren (retten)
      Twi_slv_flag = 0                                      'TWI-Merker löschen
      Twi_slv_stat = 0                                      'TWI-Merker löschen
      Gosub Twi_sense                                       'TWI wieder enablen und Bus freigeben
      gosub TWI_Auswertung                                  'und nun auswerten was über TWI empfangen wurde
   End if

   If _hour = 2 and _min = 59 and _sec = 10 then            'ab dieser Zeit wird die interne Uhr synchronisiert
      Synchron = 0                                          'damit man sieht wenn auf Synchron gewechselt wird
      Syncanzeige = "0"                                     'Anzeige nachführen
'      Portb.3 = 1                                           'DCF-Eingang freigeben /  wird durch die DCF-Routine freigegeben
   End if

   if _sec = 30 and Funkttest_erfolgt = 0 then gosub Test_Funk       'Prüfen ob Funk noch aktiv

   If _sec = 55 and Startmessung_erfolgt = 0 Then Gosub Startmessung       'Temperaturmessung anstossen (ohne Erdsonde)

   If _sec = 59 Then Synchron = Dcf_status.2                'DCF Synchronität feststellen
   If Synchron = 1 and PinB.3 = 1 Then                      'synchron während Messperiode?
      Syncanzeige = "1"                                     'Anzeige nachführen
      gosub SetDatum                                        'intern Datum/Zeit synchronisieren
      gosub SetTime
      PortB.3 = 0                                           'DCF-Eingang blockieren
   End if

   Debounce Ok , 0 , Menueauswahl                           'Springt nach Menue wenn gedrückt
   Debounce Up , 0 , Beleuchtung_ein , sub                  'Beleuchtung einschalten
   Debounce Down , 0 , Beleuchtung_ein , sub                'Beleuchtung einschalten
   Debounce Links , 0 , Beleuchtung_ein , sub               'Beleuchtung einschalten
   Debounce Rechts , 0 , Beleuchtung_ein , sub              'Beleuchtung einschalten
   Goto Displayanzeige

Menuerueckkehr:
   Gosub Displaybody
   WP_Laufzeit = WP_Laufzeit - 1                            'wird direkt in der folgenden
   gosub Test_WP                                            'Routine wieder erhöht
   Roebby_Laufzeit = Roebby_Laufzeit - 1                    'wird direkt in der folgenden
   Gosub Test_Roebby                                        'Routine wieder erhöht

Displayanzeige:
   Waitms 50
   If Neue_sekunde = 1 Then
      Neue_sekunde = 0
      gosub Displaykopf
      If Alte_minute <> _min Then
         Alte_minute = _min
         Gosub Mintic
      End If
   End If
Loop

'+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
'+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
'++++++++++++++++++++++++++   Ende Hauptschleife   +++++++++++++++++++++++++++++
'+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
'+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

'===============================================================================
'======================   Alles was pro Sekunde abläuft   ======================
'===============================================================================

Sectic:
   If Beleuchtung_aktiv = 1 then                            'Beleuchtungsdauer überprüfen
      Beleuchtungsdauer_rest = Beleuchtungsdauer_rest - 1
      If Beleuchtungsdauer_rest = 0 then
         Gbuffer = Chr(27) + "YH" + chr(Helligkeit_minimal) + chr(13)       'Displaybeleuchtung auf minimum
         Gosub Write_edip
         Beleuchtung_aktiv = 0                              'Beleuchtung ist auf minimum
      End if
   End if
   Neue_sekunde = 1
   If Timeout = 0 Then Return
   Timeout = Timeout - 1
Return

'===============================================================================
'====================   Ende alles was pro Sekunde abläuft   ===================
'===============================================================================


'###############################################################################
'#################   Alles was einmal pro Minute abläuft  ######################
'###############################################################################

Mintic:
   Startmessung_erfolgt = 0                                 'zu jeder vollen Minute zurücksetzen
   Funkttest_erfolgt = 0                                    'zu jeder vollen Minute zurücksetzen

   Gosub Test_WP
   Gosub Test_Roebby

   'Speicherintervall prüfen
   T = T - 1                                                'Speichervall herunterzählen
   If T = 0 Then                                            'abgelaufen?
      T = Speicherintervall                                 'Intervall wieder setzen
      Speichern_merker = 0                                  'wird jetzt sowieso gespeichert
      Gosub Messwerte_abholen                               'Messung mit Erdsonde durchführen
      Goto Abspeichern                                      'und in EEPROM speichern
     else                                                   'sonst
      Gosub Messwerte_abholen                               'Messung jede Minute ohne Erdsonde
      if Speichern_merker = 1 then                          'trotzdem speichern
         Speichern_merker = 0                               'Merker zurücksetzen
         goto Abspeichern
        else
         gosub Displaybody                                  'und ohne abzuspeichern, nur anzeigen
         Return                                             'und direkt zurück in die Hauptschleife
      end if
   End If

Abspeichern:                                                'und ins EEProm speichern
   Speicheradresse = Adresspointer
   Gosub Write_eeprom
   waitms 10
   Speicheradresse = Adresspointer                          'EEPROM braucht "Speicheradresse"
   Gosub Read_eeprom                                        'letzter Datensatz aus Eeprom holen
   Adresspointer = Adresspointer + 32                       'Pointer auf den nächsten Datensatz
   If Maxspeicher < Adresspointer Then Adresspointer = Startspeicher       'Überlauf, beginnt wieder von vorne
   Gosub Write_adress_pointer

   'und auf SD-Karte abspeichern

   gosub SD_Ausgabefile_erstellen
   gosub sd_append
   gosub Displaybody
Return


'###############################################################################
'###################   Ende Alles was einmal pro Minute abläuft  ###############
'###############################################################################

'-------------------------------------------------------------------------------
'------------------     Unterprogramme für Hauptanzeige     --------------------
'-------------------------------------------------------------------------------

Displaykopf:
   Speicherintervall1 = Str(Speicherintervall)
   Speicherintervall1 = Format(Speicherintervall1 , "  ")
   Anzahldatensaetze = Adresspointer - Startspeicher        'Startwert vom Adresspointer abziehen
   Anzahldatensaetze = Anzahldatensaetze / 32               'stellt so die Anzahl Datensätze zu 32 Bytedar
   Anzahldatensaetze1 = str(Anzahldatensaetze)
   Anzahldatensaetze1 = Format(Anzahldatensaetze1 , "    ")
   Gbuffer = Chr(27) + "ZL" + Chr(1) + Chr(1) + Date$ + " " + Time$ + "  DCF77: " + Syncanzeige + " D:" + Anzahldatensaetze1 + Chr(13)
   Gosub Write_edip
   Gbuffer = Chr(27) + "ZL" + Chr(1) + Chr(14) + "Intervall: " + Speicherintervall1 + " Min  I2C-Bus: " + Chr(13)
   Gosub Write_edip
Return

'________________________________________

'Aufbereitung der Temperaturanzeigen erfolgt jede Minute, Daten werden aus Daten_in genommen

Displaybody:
   For N = 1 to 13                                          'max. 13 Temperaturen möglich
      Temperatursingle(n) = Te(n) / 10                      'Werte werden von TE genommen
      Tempkomma = Fusing(temperatursingle(n) , "##.#")      'Komma festlegen
      Text_aus(n) = Format(tempkomma , "+0000") + Chr(248)  'Zahlenausgabe formatieren und Gradzeichen anhängen
      If Temperatursingle(n) > 100 Then Text_aus(n) = " --.- "
      If Temperatursingle(n) < -100 Then Text_aus(n) = " --.- "
   Next N

   Gbuffer = Chr(27) + "GD" + Chr(1) + Chr(28) + Chr(240) + Chr(28)       'horiz. Gerade
   Gosub Write_edip
   Gbuffer = Chr(27) + "GD" + Chr(1) + Chr(30) + Chr(240) + Chr(30)       'horiz. Gerade
   Gosub Write_edip
   Gbuffer = Chr(27) + "GD" + Chr(120) + Chr(30) + Chr(120) + Chr(102)       'senkrechte Gerade
   Gosub Write_edip
   Gbuffer = Chr(27) + "ZL" + Chr(1) + Chr(32) + "S.Vorl: " + S_Vor + Chr(13)
   Gosub Write_edip
   Gbuffer = Chr(27) + "ZL" + Chr(134) + Chr(32) + "S.R" + Chr(129) + "ck: " + S_Ruck + Chr(13)
   Gosub Write_edip
   Gbuffer = Chr(27) + "ZL" + Chr(1) + Chr(46) + "H.Vorl: " + H_Vor + Chr(13)
   Gosub Write_edip
   Gbuffer = Chr(27) + "ZL" + Chr(134) + Chr(46) + "H.R" + Chr(129) + "ck: " + H_Ruck + Chr(13)
   Gosub Write_edip
   Gbuffer = Chr(27) + "ZL" + Chr(1) + Chr(60) + "A.Nord: " + A_Nord + Chr(13)
   Gosub Write_edip
   Gbuffer = Chr(27) + "ZL" + Chr(134) + Chr(60) + "A.S" + Chr(129) + "d:  " + A_Sud + Chr(13)
   Gosub Write_edip
   Gbuffer = Chr(27) + "ZL" + Chr(1) + Chr(74) + "WohnZi: " + W_Zi + Chr(13)
   Gosub Write_edip
   Gbuffer = Chr(27) + "ZL" + Chr(134) + Chr(74) + "SchlZi: " + S_Zi + Chr(13)
   Gosub Write_edip
   Gbuffer = Chr(27) + "ZL" + Chr(1) + Chr(88) + "WiGa:   " + Text_aus(7) + Chr(13)
   Gosub Write_edip
   Gbuffer = Chr(27) + "ZL" + Chr(134) + Chr(88) + "Zioben: " + oben + Chr(13)
   Gosub Write_edip
   Gbuffer = Chr(27) + "GD" + Chr(1) + Chr(102) + Chr(240) + Chr(102)       'horiz. Gerade
   Gosub Write_edip
Return

'_______________________________________________

'Fusszeilen

Test_WP:
   'Wärmepumpenstatus prüfen und Anzeige vorbereiten
   If Wp <> Wpstatus_alt Then                               'Wenn WP Status gewechselt hat
      Wpstatus_alt = Wp                                     'WPstatus neu setzen
      If WPstatus_alt = 1 then                              'WP hat abgeschaltet (aus = high/open)
         WP_Laufzeit_vorher = str(WP_Laufzeit)              'Laufzeit übertragen und in String konvertiren
         WP_Laufzeit_vorher = Format(WP_Laufzeit_vorher , "   ")       'und auf 3 Stellen formatieren
         h_WP_aus = makebcd(_hour) : m_WP_aus = makebcd(_min)       'Stopzeitpunkt der WP merken
        else                                                'WP hat eingeschaltet (aktiv = 0)
         h_WP_ein = makebcd(_hour)                          'Startzeitpunkt der WP merken
         m_WP_ein = makebcd(_min)
         WP_Laufzeit = 0                                    'Laufzeit starten
         WP_Laufzeit1 = str(WP_Laufzeit)                    'in String konvertieren
         WP_Laufzeit1 = Format(WP_Laufzeit1 , "   ")        'und auf 3 Stellen formatieren
      End if
      Speichern_merker = 1                                  'Merker dass abgespeichert wird
   End If

   'Wärmepumpenstatus anzeigen
   If WPStatus_alt = 1 then
      Gbuffer = Chr(27) + "RL" + Chr(1) + Chr(104) + Chr(240) + Chr(116) + Chr(13)       'unteren Bereich löschen
      Gosub Write_edip
      Gbuffer = Chr(27) + "ZL" + Chr(1) + Chr(104) + "WP lief:" + Chr(13) + Chr(27) + "ZL" + Chr(107) + Chr(104) + WP_Laufzeit_vorher + " Min bis:  " + hex(h_WP_aus) + ":" + hex(m_WP_aus) + Chr(13)
      Gosub Write_edip
    else
      WP_Laufzeit = WP_Laufzeit + 1
      WP_Laufzeit1 = str(WP_Laufzeit)                       'in String konvertieren
      WP_Laufzeit1 = Format(WP_Laufzeit1 , "   ")           'und auf 3 Stellen formatieren
      Gbuffer = Chr(27) + "RL" + Chr(1) + Chr(104) + Chr(240) + Chr(116) + Chr(13)       'unteren Bereich löschen
      Gosub Write_edip
      Gbuffer = Chr(27) + "ZL" + Chr(1) + Chr(104) + "WP l" + chr(132) + "uft:" + chr(13) + Chr(27) + "ZL" + Chr(107) + Chr(104) + WP_Laufzeit1 + " Min seit: " + hex(h_WP_ein) + ":" + hex(m_WP_ein) + Chr(13)
      Gosub Write_edip
   end if

Return

'___________________________________________

Test_Roebby:
   'Roebbystatus prüfen und Anzeige vorbereiten
   If Roebbystatus <> Roebbystatus_alt Then                 'Wenn Roebby Status gewechselt hat
      Roebbystatus_alt = Roebbystatus                       'Roebbystatus neu setzen
      If Roebbystatus_alt = 0 then                          'Roebbyakku wird geladen
         Roebby_Laufzeit_vorher = str(Roebby_Laufzeit)      'letzte Laufzeit speichern und als string speichern
         Roebby_Laufzeit_vorher = Format(Roebby_Laufzeit_vorher , "   ")       'und auf 3 Stellen formatieren
         h_Roebby_aus = makebcd(_hour) : m_Roebby_aus = makebcd(_min)       'Stopzeitpunkt von Roebby merken
        else                                                'oder Roebby beginnt zu mähen (aktiv = 1)
         h_Roebby_ein = makebcd(_hour)                      'Startzeitpunkt von Roebby merken
         m_Roebby_ein = makebcd(_min)
         Roebby_Laufzeit = 0                                'und Roebby_Laufzeit starten
         Roebby_Laufzeit1 = str(Roebby_Laufzeit)            'in String wandeln
         Roebby_Laufzeit1 = Format(Roebby_Laufzeit1 , "   ")       'und formatiert auf 3 Stellen
      End if
      Speichern_merker = 1                                  'Merker dass abgespeichert wird
   End If

   'Roebbystatus anzeigen
   If Roebbystatus_alt = 0 then
      Gbuffer = Chr(27) + "RL" + Chr(1) + Chr(116) + Chr(240) + Chr(128) + Chr(13)       'unteren Bereich löschen
      Gosub Write_edip
      Gbuffer = Chr(27) + "ZL" + Chr(1) + Chr(116) + "R" + chr(148) + "bby lief:" + Chr(13) + Chr(27) + "ZL" + Chr(107) + Chr(116) + Roebby_Laufzeit_vorher + " Min bis:  " + hex(h_Roebby_aus) + ":" + hex(m_Roebby_aus) + Chr(13)
      Gosub Write_edip
    else
      Roebby_Laufzeit = Roebby_Laufzeit + 1
      if Roebby_Laufzeit > 99 then                          'ist wahrscheinlich irgendwo stehen geblieben
         Roebby_Laufzeit = 99
         Gbuffer = Chr(27) + "ZV" + Chr(5) + Chr(13)        'Invers einschalten
         Gosub Write_edip
         Gbuffer = Chr(27) + "ZL" + Chr(1) + Chr(116) + "R" + chr(148) + "bby: FEHLER IST NICHT IN GARAGE " + Chr(13)
         Gosub Write_edip
         Gbuffer = Chr(27) + "ZV" + Chr(4) + Chr(13)        'Invers aus
         Gosub Write_edip
        else
         Roebby_Laufzeit1 = str(Roebby_Laufzeit)            'in String wandeln
         Roebby_Laufzeit1 = Format(Roebby_Laufzeit1 , "   ")       'und formatiert auf 3 Stellen
         Gbuffer = Chr(27) + "ZL" + Chr(1) + Chr(116) + "R" + chr(148) + "bby l" + chr(132) + "uft:" + Chr(13) + Chr(27) + "ZL" + chr(107) + chr(116) + Roebby_Laufzeit1 + " Min seit: " + hex(h_Roebby_ein) + ":" + hex(m_Roebby_ein) + Chr(13)
         Gosub Write_edip
      End if
   End if
Return

'-------------------------------------------------------------------------------
'----------------    Ende Unterprogramme für Hauptanzeige     ------------------
'-------------------------------------------------------------------------------

'+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
'++++++++++++++++++++++++++   Temperaturmessungen   ++++++++++++++++++++++++++++
'+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

'die Temperaturmessungen 3 sec vor jeder Minute anstossen (Konvertierung starten)

Startmessung:
   1wreset                                                  '1-Wire-Bus zurücksetzen und Messung starten
   1wwrite &HCC                                             'Adressromīs überspringen
   1wwrite &H44                                             'Temperaturkonversion anstossen, startet Konvertierung von ALLEN T am 1w-bus
   If T = 1 then                                            'nur 1 x pro Messintervall, 1 Min. vor Speicherung
      Gosub Erdsondentemperatur                             'zuerst Erdsondenmessung anstossen
      Set Es_merker                                         'Merker für ES-Werte abholen setzen
   End if
   Startmessung_erfolgt = 1
Return

'-------------------------------------------------------------------------------

Dim Tempnr As Byte

Messwerte_abholen:                                          'Messung ohne Erdsonde

   Daten_in(1) = _day                                       'Zeit der Messung in den ersten 5 Bytes abspeichern
   Daten_in(2) = _month
   Daten_in(3) = _year
   Daten_in(4) = _hour
   Daten_in(5) = _min

Stat_signal:                                                'dann die statischen Signale abfragen
   Wpstatus_alt = Wp                                        'WPstatus neu setzen, falls er gerade gewechselt hat
   If Wp = 1 Then                                           'WPzustand
      Daten_in(6).0 = 0                                     'Bit0: ist 0 = AUS
    Else
      Daten_in(6).0 = 1                                     'Bit0: ist 1 = EIN
   End If

   Roebbystatus_alt = Roebbystatus                          'Roebbystatus neu setzen, falls er gerade gewechselt hat
   If Roebbystatus = 1 Then                                 'Roebbyzustand
      Daten_in(6).1 = 0                                     'Bit1: ist 0 = OUT / mähen
    Else
      Daten_in(6).1 = 1                                     'Bit1: ist 1 = IN  / laden
   End If

   Gosub Temp_messung_1w                                    '1-Wire-Sensoren abfragen
   If Es_merker = 1 Then
      Gosub Erdsondentemperatur                             'die Werte von vorher abholen
      Reset Es_merker
   End If
Return

'_________________________________________________________

'1-Wire-Sensoren, Wert abholen
'Die 1-wire-Sensoren müssen am Anfang stehen da die 1-wire-Sensor-Nr(x) die gleiche ist wie TE(x) resp. Ta(x)

Temp_messung_1w:
   For Sensor_nr = 1 To Max18s20_sensoren
      Tempnr = Sensor_nr * 8                                '8 Byte Adressen pro Sensor
      Tempnr = Tempnr - 7
      1wverify Dsid(tempnr)                                 'sendet "Match ROM "
   If Err = 1 Then                                          'Error = 1 Fehler aufgetreten
      Te(sensor_nr) = 9999                                  'damit die Stelle nicht leer bleibt
   Elseif Err = 0 Then                                      'Sensor hat geantwortet
      1wwrite &HBE
      Sc(1) = 1wread(9)                                     '9 Bytes in Array einlesen
      If Sc(9) = Crc8(sc(1) , 8) Then
         Te(sensor_nr) = Decigrades(sc(9))                  'Umwandlung in ein Integer-Word (-32768...32767) zum abspeichern
      End If
   End If
   Next Sensor_nr
Return

'-----------------------

Function Decigrades(byval Sc(9) As Byte)
   Dim Tmp As Byte , T0 As Integer , T1 As Integer

   Tmp = Sc(1) And 1                                        '0.1C Genauigkeit, Bit 0 ausmaskieren
   If Tmp = 1 Then Decr Sc(1)                               'wenn 1 dann 1 abziehen
      T0 = Makeint(sc(1) , Sc(2))                           'Umwandeln in Integerwert, Anzahl 1/2° (Temp-Schritt ist 0.5°C)
      T0 = T0 * 50                                          'x50, da 1/100°-Schritte
      T0 = T0 - 25                                          'gemäss DS18S20 data sheet 0.25(*100) abziehen
      T1 = Sc(8) - Sc(7)
      T1 = T1 * 100
      T1 = T1 / Sc(8)
      T0 = T0 + T1
      Decigrades = T0 / 10
End Function

'_____________________________________________


'Erdsondentemperaturen abfragen

Erdsondentemperatur:

   Twi_mst_addr = Es_adr_r                                  'Deviceaddresse
   Twi_mt_cntr = 0                                          '0 Byte senden
   Twi_mr_cntr = 4                                          '4 Byte empfangen
   Twi_mr_data = Varptr(twi_msr_buff(1))                    'Startadresse der Empfangsdaten
   Gosub Mst_start                                          'und los
   Select Case Twi_mst_flag                                 'Ergebnis ?
      Case Twi_m_recv:                                      'abgeholt
         Daten_in(29) = twi_msr_buff(1)                     'umkopieren
         Daten_in(30) = twi_msr_buff(2)                     'umkopieren
         Daten_in(31) = twi_msr_buff(3)                     'umkopieren
         Daten_in(32) = twi_msr_buff(4)                     'umkopieren
         Twi_mst_flag = 0
      Case Else:                                            'irgendein Problem
         #If Printerausgabe = 1
            Print Hex(twi_mst_addr) ; " Problem 01    "
            Call Twi_show_state(twi_mst_flag)
            Print : print
         #EndIf
   End Select
   Twi_mst_flag = 0
Return


'(
   I2cstart
   I2cwbyte Es_adr_r                                        'Device-write
   I2crbyte Daten_in(29) , Ack                              'MSB holen  Temperatur Erdsdonde unten  = T12
   I2crbyte Daten_in(30) , Ack                              'LSB holen  Temperatur Erdsdonde unten  = T12
   I2crbyte Daten_in(31) , Ack                              'MSB holen  Temperatur Erdsdonde oben   = T13
   I2crbyte Daten_in(32) , Nack                             'LSB holen  Temperatur Erdsdonde oben   = T13
   I2cstop
Return
')
'______________________________________________________________

'über TWI hereingekommen (Funktemperatursonden und ZSE)

TWI_Auswertung:

   'zuerst CRC prüfen
   Y = TWI_Eingangspuffer(1) - 1                            'Datenlänge über alles ohne CRC16
   Crc_16e = Crc16(TWI_Eingangspuffer(1) , Y )
'(
   #If Printerausgabe = 1
      Y = TWI_Eingangspuffer(1)
      Print hex(CRC_16e)                                    'CRC-Vergleich gerechnet
      Print hex(TWI_Eingangspuffer(y + 1)) ; hex(TWI_Eingangspuffer(y))       'mit Empfang
      Print
   #EndIf
')
   If TWI_Eingangspuffer(TWI_Eingangspuffer(1)) <> Low(crc_16e) Then goto CRC_Fehler
   If TWI_Eingangspuffer(TWI_Eingangspuffer(1) + 1) <> High(crc_16e) Then goto CRC_Fehler

   #If Printerausgabe = 1
       Print "TWI-Eingang von: " ; Hex(TWI_Eingangspuffer(3)) ; "   ";
       for v = 1 to 12
           Print Hex(TWI_Eingangspuffer(v)) ; " ";
       Next
       Print
   #EndIf

   Select Case Twi_E_status
      Case &H60
         If TWI_Eingangspuffer(3) = SlZi then gosub SchlZi  'vom Schlafzimmer
         If TWI_Eingangspuffer(3) = Ziob then gosub Zimob   'vom Zimmer oben
         If TWI_Eingangspuffer(3) = aSued then gosub ausSued       'von aussen Süd
         If TWI_Eingangspuffer(3) = WiGa then gosub WinGa   'vom Wintergarten
         If TWI_Eingangspuffer(3) = WoZi then gosub WohnZi  'vom Wohnzimmer
         If TWI_Eingangspuffer(3) = Reserve then gosub ResSend       'Reservesender
      Case Else:
         #If Printerausgabe = 1
            Print Chr(7) ;                                  'Irgendein Fehler
            Call Twi_show_state(Twi_E_status)               'Print Status-Text
         #EndIf
   End Select
   #If Printerausgabe = 1
      Print
   #EndIf
CRC_Fehler:                                                 'verwerfen
Return

'____________________________________


SchlZi:
    TE(6) = makeint(TWI_Eingangspuffer(5) , TWI_Eingangspuffer(6))       'ins Inputarray übertragen
    Funkzust(1) = TWI_Eingangspuffer(3)                     'Adresse umkopieren
    LL = memcopy(TWI_Eingangspuffer(5) , Funkzust(4) , 6)   'umkopieren
    Funkzust(2) = _hour                                     'und noch die aktuelle Zeit
    Funkzust(3) = _min
Return


Zimob:
    TE(9) = makeint(TWI_Eingangspuffer(5) , TWI_Eingangspuffer(6))       'ins Inputarray übertragen
    Funkzust(11) = TWI_Eingangspuffer(3)                    'Adresse umkopieren
    LL = memcopy(TWI_Eingangspuffer(5) , Funkzust(14) , 6)  'umkopieren
    Funkzust(12) = _hour                                    'und noch die aktuelle Zeit
    Funkzust(13) = _min
Return


ausSued:
    TE(8) = makeint(TWI_Eingangspuffer(5) , TWI_Eingangspuffer(6))       'ins Inputarray übertragen; ist schon Integer !!!!!!!
    Funkzust(21) = TWI_Eingangspuffer(3)                    'Adresse umkopieren
    LL = memcopy(TWI_Eingangspuffer(5) , Funkzust(24) , 6)  'umkopieren
    Funkzust(22) = _hour                                    'und noch die aktuelle Zeit
    Funkzust(23) = _min
Return


WinGa:
    TE(7) = makeint(TWI_Eingangspuffer(5) , TWI_Eingangspuffer(6))       'ins Inputarray übertragen
    Funkzust(31) = TWI_Eingangspuffer(3)                    'Adresse umkopieren
    LL = memcopy(TWI_Eingangspuffer(5) , Funkzust(34) , 6)  'umkopieren
    Funkzust(32) = _hour                                    'und noch die aktuelle Zeit
    Funkzust(33) = _min
Return


WohnZi:
    TE(10) = makeint(TWI_Eingangspuffer(5) , TWI_Eingangspuffer(6))       'ins Inputarray übertragen
    Funkzust(41) = TWI_Eingangspuffer(3)                    'Adresse umkopieren
    LL = memcopy(TWI_Eingangspuffer(5) , Funkzust(44) , 6)  'umkopieren
    Funkzust(42) = _hour                                    'und noch die aktuelle Zeit
    Funkzust(43) = _min
Return


ResSend:
    TE(11) = makeint(TWI_Eingangspuffer(5) , TWI_Eingangspuffer(6))       'ins Inputarray übertragen
    Funkzust(51) = TWI_Eingangspuffer(3)                    'Adresse umkopieren
    LL = memcopy(TWI_Eingangspuffer(5) , Funkzust(54) , 6)  'umkopieren
    Funkzust(52) = _hour                                    'und noch die Zeit
    Funkzust(53) = _min
Return


'Kontrolle und Alarm wenn Funksender ausfallen

Test_Funk:
   #If Printerausgabe = 1
      Print "Ausfallzeit: ";
   #EndIf
   If _min >= Funkzust(3) Then
      x = _min - Funkzust(3)
     else
      x = 60 - Funkzust(3)
      x = x + _min
   end if
   #If Printerausgabe = 1
      Print x
      Print
   #EndIf
   If x > Funktimeout then
      TE(6) = 9999                                          'damit Wert gelöscht wird
      Funk_Fehler = "Funkausfall Adr.1 Schlafzimmer"
      Fehlermeldung = "Funk 1 "
   End if

   If _min >= Funkzust(13) Then
      x = _min - Funkzust(13)
    else
      x = 60 - Funkzust(13)
      x = x + _min
   end if
   If x > Funktimeout then
      TE(9) = 9999                                          'damit Wert gelöscht wird
      Funk_Fehler = "Funkausfall Adr.2 Zimmer oben "
      Fehlermeldung = "Funk 2 "
   End if

   If _min >= Funkzust(23) Then
      x = _min - Funkzust(23)
    else
      x = 60 - Funkzust(23)
      x = x + _min
   end if
   If x > Funktimeout then
      TE(8) = 9999                                          'damit Wert gelöscht wird
      Funk_Fehler = "Funkausfall Adr.3 aussen Sued "
      Fehlermeldung = "Funk 3 "
   End if

   If _min >= Funkzust(33) Then
      x = _min - Funkzust(33)
    else
      x = 60 - Funkzust(33)
      x = x + _min
   end if
   If x > Funktimeout then
      TE(7) = 9999                                          'damit Wert gelöscht wird
      Funk_Fehler = "Funkausfall Adr.4 Wintergarten"
      Fehlermeldung = "Funk 4 "
   End if

   If _min >= Funkzust(53) Then
      x = _min - Funkzust(53)
    else
      x = 60 - Funkzust(53)
      x = x + _min
   end if
   If x > Funktimeout then
      TE(11) = 9999                                         'damit Wert gelöscht wird
      Funk_Fehler = "Funkausfall Adr.6 Funk Reserve"
      Fehlermeldung = "Funk 6 "
   End if
   Funkttest_erfolgt = 1
Return


'+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
'++++++++++++++++++++++   Ende Temperaturmessungen   +++++++++++++++++++++++++++
'+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++


'===============================================================================
'===========================   EEProm-Subroutinen   ============================
'===============================================================================

'Lesen des Adresspointers aus dem EEProm, die fixe Speicheradresse dafür ist &b01010000_00000000_00001000

Read_adress_pointer:
   Disable Interrupts
   I2CBus = 0
   I2cinit
   I2cstart                                                 'Startbedingung
   I2cwbyte &B10100000                                      'Deviceadresse schreiben
   I2cwbyte &B00000000                                      'High-Byte
   I2cwbyte &B00001000                                      'Low Byte (Startadresse ist &h8)
   I2crepstart                                              'repeated start
   I2cwbyte &B10100001                                      'Deviceadresse für lesen
   I2crbyte Aph_h , Ack                                     'highDWord high \
   I2crbyte Aph_l , Ack                                     'highDWord low   > Adresspointer-
   I2crbyte Apl_h , Ack                                     'lowDWord high   > DWord
   I2crbyte Apl_l , Nack                                    'lowDWord low   /
   I2cstop                                                  'Stopbedingung
   Enable Interrupts
Return


'(
Read_adress_pointer:

   Twi_mst_addr = &B10100000                                'Deviceadresse für Schreiben
   twi_mst_buff(1) = &B00000000                             'High-Byte
   twi_mst_buff(2) = &B00001000                             'Low Byte (Startadresse ist &h8)
   Twi_mt_cntr = 2                                          '2 Byte senden
   Twi_mt_data = Varptr(twi_mst_buff(1))                    'Startadresse des Sendepuffers
   Twi_mr_cntr = 4                                          '4 Byte empfangen
   Twi_mr_data = Varptr(twi_msr_buff(1))                    'Startadresse des Empfangspuffers
   Gosub Mst_start                                          'auf gehts
   #if I2C_Anzeige = 1
      Gbuffer = Chr(27) + "ZL" + Chr(198) + Chr(14) + "RAP " + Hex(Twi_mst_flag) + Chr(13)
      Gosub Write_edip
   #EndIf
   Select Case Twi_mst_flag                                 'Ergebnis ?
      Case Twi_m_recv:                                      'abgeholt
         Aph_h = twi_msr_buff(1)                            'highDWord high \
         Aph_l = twi_msr_buff(2)                            'highDWord low   > Adresspointer-
         Apl_h = twi_msr_buff(3)                            'lowDWord high   > DWord
         Apl_l = twi_msr_buff(4)                            'lowDWord low   /
         Twi_mst_flag = 0
      Case Else:                                            'irgendein Problem
         #If Printerausgabe = 1
            Print Hex(twi_mst_addr) ; " Problem 02    "
            Call Twi_show_state(twi_mst_flag)
            Print
         #EndIf
   End Select
   Twi_mst_flag = 0
Return
')
'-------------------------------------------------------------------------------
'Schreiben des Adresspointers in das EEProm, die fixe Adresse dafür ist &b01010000_00000000_00001000

Write_adress_pointer:
   Disable Interrupts
   I2CBus = 0
   I2cinit
   I2cstart                                                 'Startbedingung
   I2cwbyte &B10100000                                      'Deviceadresse, für schreiben
   I2cwbyte &B00000000                                      'High Byte der EEPROM-Adresse)
   I2cwbyte &B00001000                                      'Low Byte der EEPROM-Adresse)
   I2cwbyte Aph_h                                           '\
   I2cwbyte Aph_l                                           ' > aktueller Adresspointer
   I2cwbyte Apl_h                                           ' > Reset ist hex 00500020
   I2cwbyte Apl_l                                           '/
   I2cstop                                                  'Stopbedingung
   Waitms 10                                                'wird nun in die Zellen geschrieben
   Enable Interrupts
Return

'(
Write_adress_pointer:

   Twi_mst_addr = &B10100000                                'Deviceadresse für schreiben
   twi_mst_buff(1) = &B00000000                             'High Byte der EEPROM-Adresse
   twi_mst_buff(2) = &B00001000                             'Low Byte (Startadresse ist &h8)
   twi_mst_buff(3) = Aph_h                                  '\
   twi_mst_buff(4) = Aph_l                                  ' > aktueller Adresspointer
   twi_mst_buff(5) = Apl_h                                  ' > Reset ist hex 00500020
   twi_mst_buff(6) = Apl_l                                  '/
   Twi_mt_cntr = 6                                          '6 Byte senden
   Twi_mr_cntr = 0                                          'nichts lesen
   Twi_mt_data = Varptr(twi_mst_buff(1))                    'Startadresse der Sendedaten
   Gosub Mst_start                                          'und los
   #if I2C_Anzeige = 1
      Gbuffer = Chr(27) + "ZL" + Chr(198) + Chr(14) + "WAP " + Hex(Twi_mst_flag) + Chr(13)
      Gosub Write_edip
   #EndIf
   Select Case Twi_mst_flag                                 'Ergebnis ?
      Case Twi_m_sent:                                      'abgeholt
         Twi_mst_flag = 0
      Case Else:                                            'irgendein Problem
         #If Printerausgabe = 1
            Print Hex(twi_mst_addr) ; " Problem 03    "
            Call Twi_show_state(twi_mst_flag)
            Print
         #EndIf
   End Select
   Twi_mst_flag = 0
Return
')
'-------------------------------------------------------------------------------
'Lesen vom 24LC1025; die Adresse steht in "Speicheradresse"

Read_eeprom:
   Temp = 0                                                 '<------------------------------------- brauchts das?????????????????
   Eeprom_dev_adr = Low(eeprom_dev_adresse)
   Shift Eeprom_dev_adr , Left , 1                          'da 0 eingeschoben wird = schreiben
   H = High(eeprom_adresse)                                 'High Byte
   L = Low(eeprom_adresse)                                  'Low Byte
   Disable Interrupts
   I2CBus = 0
   I2cinit
   I2cstart                                                 'Startbedingung
   I2cwbyte Eeprom_dev_adr                                  'Write Deviceaddress
   I2cwbyte H                                               'MSB
   I2cwbyte L                                               'LSB
   I2crepstart                                              'repeated start
   Eeprom_dev_adr.0 = 1                                     'Bit0 auf 1 setzen = lesen
   I2cwbyte Eeprom_dev_adr                                  'Write Deviceaddress
   If Maxdaten > 1 Then                                     'wenn mehr als 1 Byte gelesen werden soll,
      Temp1 = Maxdaten - 1                                  'Anzahl der Bytes minus 1
      For Temp = 1 To Temp1                                 'alle Bytes mit Ausnahme des letzten
         I2crbyte Daten_out(temp) , Ack                     'mit Acknowledge einlesen und ins Array kopieren
      Next Temp
      I2crbyte Daten_out(maxdaten) , Nack                   'das letzte Byte ohne Acknowledge einlesen
   Else                                                     'falls nur 1 Byte gelesen werden soll,
      I2crbyte Daten_out(1) , Nack                          'dann dieses Byte gleich ohne Acknowledge einlesen
   End If
   I2cstop                                                  'Stopbedingung
   Enable Interrupts
Return


'(
Read_eeprom:

   Eeprom_dev_adr = Low(eeprom_dev_adresse)
   Shift Eeprom_dev_adr , Left , 1                          'da 0 eingeschoben wird = schreiben
   Twi_mst_addr = Eeprom_dev_adr                            'Write Deviceaddresse für schreiben
   twi_mst_buff(1) = High(eeprom_adresse)                   'High Byte
   twi_mst_buff(2) = Low(eeprom_adresse)                    'Low Byte

   Twi_mt_cntr = 2                                          '2 Byte senden
   Twi_mt_data = Varptr(twi_mst_buff(1))                    'Startadresse der Sendedaten
   Twi_mr_cntr = Maxdaten                                   'x Byte empfangen
   Twi_mr_data = Varptr(twi_msr_buff(1))                    'Startadresse der Empfangsdaten
   Gosub Mst_start                                          'und los
   #if I2C_Anzeige = 1
      Gbuffer = Chr(27) + "ZL" + Chr(198) + Chr(14) + "REP " + Hex(Twi_mst_flag) + Chr(13)
      Gosub Write_edip
   #EndIf
   Select Case Twi_mst_flag                                 'Ergebnis ?
      Case Twi_m_recv:                                      'abgeholt
         LL = memcopy(twi_msr_buff(1) , Daten_out(1) , Maxdaten)       'umkopieren      Twi_mr_cntr ersetzt durch Maxdaten    <<<<<<<<<<<<<<<<<<<<<<<<<
         Twi_mst_flag = 0
      Case Else:                                            'irgendein Problem
         #If Printerausgabe = 1
         Print Hex(twi_mst_addr) ; " Problem 04    "
         Call Twi_show_state(twi_mst_flag)
         Print : print
         #EndIf
   End Select
   Twi_mst_flag = 0
Return
')

'-------------------------------------------------------------------------------
'Schreiben zum 24LC1025; die Adresse steht in "Speicheradresse"

Write_eeprom:
   Temp = 1
   Eeprom_dev_adr = Low(eeprom_dev_adresse)
   Shift Eeprom_dev_adr , Left , 1                          'da 0 eingeschoben wird = schreiben
   H = High(eeprom_adresse)                                 'High Byte der EEPROM-Adresse
   L = Low(eeprom_adresse)                                  'Low Byte der EEPROM-Adresse
   Disable Interrupts
   I2CBus = 0
   I2cinit
   I2cstart                                                 'Startbedingung
   I2cwbyte Eeprom_dev_adr                                  'Deviceadresse schreiben
   I2cwbyte H                                               'MSB (High Byte der EEPROM-Adresse)
   I2cwbyte L                                               'LSB (Low Byte der EEPROM-Adresse)
   I2cwbyte Daten_in(temp)                                  'den ersten Wert schreiben
Beginn:                                                     'Bytezähler inkrementieren
   Incr Temp
   I2cwbyte Daten_in(temp)
   If Temp < Maxdaten Then Goto Beginn                      'die weiteren Werte schreiben
   I2cstop                                                  'Stopbedingung
   Waitms 10                                                'wird nun in die Zellen geschrieben
   Enable Interrupts
Return

 

'(
Write_eeprom:

   Eeprom_dev_adr = Low(eeprom_dev_adresse)
   Shift Eeprom_dev_adr , Left , 1                          'da 0 eingeschoben wird = schreiben
   twi_mst_buff(1) = High(eeprom_adresse)                   'High Byte der EEPROM-Adresse
   twi_mst_buff(2) = Low(eeprom_adresse)                    'Low Byte der EEPROM-Adresse
   LL = memcopy(Daten_in(1) , twi_mst_buff(3) , maxdaten , 3)       'Eingangsdaten in Sendepuffer umkopieren
   Twi_mst_addr = Eeprom_dev_adr                            'Deviceadresse schreiben
   Twi_mt_cntr = Maxdaten + 2                               'x Byte senden
   Twi_mr_cntr = 0                                          'nichts abholen
   Twi_mt_data = Varptr(twi_mst_buff(1))                    'Startadresse des Sendepuffers
   Gosub Mst_start                                          'auf gehts
   #if I2C_Anzeige = 1
      Gbuffer = Chr(27) + "ZL" + Chr(198) + Chr(14) + "WEP " + Hex(Twi_mst_flag) + Chr(13)
      Gosub Write_edip
   #EndIf
   Select Case Twi_mst_flag                                 'Ergebnis ?
      Case Twi_m_sent:                                      'abgeholt
         Twi_mst_flag = 0
      Case Else:                                            'irgendein Problem
         #If Printerausgabe = 1
            Print Hex(twi_mst_addr) ; " Problem 05    "
            Call Twi_show_state(twi_mst_flag)
            Print : Print
         #EndIf
   End Select
   Twi_mst_flag = 0
Return
')

'===============================================================================
'===========================   Ringpuffer-Routinen   ===========================
'===============================================================================
'ist für später, Ersatz für die EEProms

Ringbuffer_schreiben:
   Temp = 1
Ringbuffer_schreiben1:
   Ringbuffer(Wrindex) = Daten_in(Temp)
   gosub Incr_wrindex
   incr Temp
   if Temp <= 32 then goto Ringbuffer_schreiben1
return

Incr_wrindex:
   incr Wrindex
   if Wrindex > Buffer_Tiefe then
      wrindex = 1
   end if
return

Ringbuffer_lesen:
   Temp = 1
Ringbuffer_lesen1:
   Daten_out(Temp) = Ringbuffer(Rdindex)
   gosub incr_rdindex
   incr Temp
   if Temp <= 32 then goto Ringbuffer_lesen1
return

Incr_rdindex:
   incr rdindex
   if rdindex > Buffer_Tiefe then
      rdindex = 1
   end if
return

 

'===============================================================================
'===========================   SD-Kartenroutinen   =============================
'===============================================================================

'SD-Karteninitialisation

SD_init:

   Sdstatus = 0
   Gosub Sdinit
   Print "SD-Initialisierung: nach Sdinit " ; sdstatus

   If Sdstatus = 0 Then                                     ' Initialization succesful. Sdcardtype = 1 -> v1.x SDSC, 2 -> v2+ SDSC, 3 -> v2+ SDHC or SDXC
      Print "SD-Initialisierung: Kartentyp " ; sdcardtype
      Gbuffer = chr(27) + "ZL" + Chr(1) + Chr(z9) + "Kartentyp: " + str(sdcardtype) + chr(13)
      gosub Write_edip

      Gosub Sdrequestcsd
      Gosub Sdcalculatesize
      Gosub Sdrequeststatus
   End If

   Print "SD-Initialisierung: Sdstatus: " ; Sdstatus
   If Sdstatus = 0 Then
      Gosub Sdinitfs
      Print "File-Initialisierung: nach Sdinitfs"
   End If

   If Sdstatus = 0 then
      Print "SD-Initialisierung: Beendet"
     else
      Print "SD-Initialisierungsfehler, Sdstatus: " ; Sdstatus
   End if
Return


'_________________________________________________

SD_Ausgabefile_erstellen:

   If Daten_in(6).0 = 1 then                                'Ausscheidung der statischen Signale
      Statisch(1) = "1"
     else
      Statisch(1) = "0"
   end if
   If Daten_in(6).1 = 1 then
      Statisch(2) = "1"
     else
      Statisch(2) = "0"
   end if
   If Daten_in(6).2 = 1 then
      Statisch(3) = "1"
     else
      Statisch(3) = "0"
   end if
   If Daten_in(6).3 = 1 then
      Statisch(4) = "1"
     else
      Statisch(4) = "0"
   end if
   If Daten_in(6).4 = 1 then
      Statisch(5) = "1"
     else
      Statisch(5) = "0"
   end if
   If Daten_in(6).5 = 1 then
      Statisch(6) = "1"
     else
      Statisch(6) = "0"
   end if
   If Daten_in(6).6 = 1 then
      Statisch(7) = "1"
     else
      Statisch(7) = "0"
   end if
   If Daten_in(6).7 = 1 then
      Statisch(8) = "1"
     else
      Statisch(8) = "0"
   end if

   'Temperaturanzeige vorbereiten; abgelegt im Integer-Format (-32768....+32767) als Overlay über Daten_in
   For n = 1 to 13                                          'max. 13 Temperaturen möglich
      Temperatursingle(n) = Te(n) / 10                      'nimmt die Daten von Temperatur in
      Tempkomma = Fusing(temperatursingle(n) , "##.#")      'Komma festlegen
      Te_sd(n) = ";" + Format(tempkomma , "+0000")          'Zahlenausgabe formatieren, ; ist Trennzeichen
      If Temperatursingle(n) > 100 Then Te_sd(n) = "; --.- "
      If Temperatursingle(n) < -100 Then Te_sd(n) = "; --.- "
   Next n                                                   'nächste Temperatur im Anzeigeformat

   SD_buff = str(daten_in(1)) + "." + str(daten_in(2)) + "." + str(daten_in(3)) + ";" + str(daten_in(4)) + ":" + str(daten_in(5)) + "  ;"
   SD_buff = SD_buff + Statisch(1) + ";" + Statisch(2) + ";" + Statisch(3) + ";" + Statisch(4) + ";" + Statisch(5) + ";" + Statisch(6) + ";" + Statisch(7) + ";" + Statisch(8) + ";"
   SD_buff = SD_Buff + Te_sd(1) + Te_sd(2) + Te_sd(3) + Te_sd(4) + Te_sd(5) + Te_sd(6) + Te_sd(7) + Te_sd(8) + Te_sd(9) + Te_sd(10) + Te_sd(11) + Te_sd(12) + Te_sd(13) + Chr(13) + Chr(10)

   #If Printerausgabe = 1
      Print "SD Ausgabefile: " ; SD_buff
   #EndIf

Return

'_______________________________________

SD_write:

   Sdyear = _year + 2000                                    'für das Filedatum vorbereiten
   Sdmonth = _month
   Sdday = _day
   Sdhours = _hour
   Sdminutes = _min
   Sdseconds = _sec

   Sdstatus = 0
   #If Printerausgabe = 1
      Print
      Print "Start SD_write; Inhalt SD_buff: " ; SD_buff
      Print
   #EndIf
   w = 0
   For M = 1 To Len(SD_buff)
'      While Sdclosefile = 0 And w < 512
'         Incr w
         C = Mid(SD_buff , M , 1)
         Sdbyterw = asc(C)
         #If Printerausgabe = 1
             Print Sdbyterw ;
         #EndIf
         Gosub Sdwritebyte                                  'in SD-Buffer schreiben
'      Wend
   Next M
   #If Printerausgabe = 1
      Print
   #EndIf
   Gosub Sdfinalizeafterwriting                             ' After writing the last byte, close the file
   #If Printerausgabe = 1
      Print "erledigt, noch FSinfo nachführen"
   #EndIf
   Gosub Sdwritefsinfo                                      ' Save the updated fsinfo variables back
   #If Printerausgabe = 1
      Print "alles erledigt"
   #EndIf
Return

'___________________________________________

SD_Append:

   Sdentrynames = Filename
   Gosub Sdreadfsinfo

   Sdstartdirclusterd = 0
   Sdyear = _year + 2000                                    'für das Filedatum nachzuführen?
   Sdmonth = _month
   Sdday = _day
   Sdhours = _hour
   Sdminutes = _min
   Sdseconds = _sec

   Gosub Sdpreparetoappend
   For M = 1 To Len(SD_buff)
      If Sdclosefile = 0 Then
         C = Mid(SD_buff , M , 1)
         Sdbyterw = asc(C)
         Gosub Sdwritebyte
        Else
         Goto SD_Error
      End if
   Next M
   Gosub Sdfinalizeafterwriting                             'After writing the last byte, close the file
   Gosub Sdwritefsinfo                                      'Save the updated fsinfo variables back
Return


SD_Error:
   Print "SD-Karten Schreibfehler"
   SD_Fehler = "SD Schreibfehler beim Anhaengen"
   Fehlermeldung = "SDKarte"                                'Ausgabe auf 2.ter Zeile
Return

 

'===============================================================================
'==========================   Display-Subroutinen   ============================
'===============================================================================
'
Sub Write_edip
   Dat = 17                                                 'Startbyte DC1
   M = Len(gbuffer)
   Bcc = 17 + M
   Print #2 , Chr(dat) ;
   Print #2 , Chr(m) ;
   For M = 1 To Len(gbuffer)
      C = Mid(gbuffer , M , 1)

      Print #2 , C ;

'      Dat = Asc(c)                                          'ev. löschen?
'      Print #2 , Chr(dat) ;                                 'WIRKLICH???? ZUERST CHARAKTER IN ZAHL UND DANN ZAHL IN CHARAKTER??=
      Bcc = Bcc + Asc(c)                                    'Zahl wird für die Checksumme benötigt
   Next M
   Print #2 , Chr(bcc) ;                                    'und noch Checksumme senden

Quittungwarten:
   'hier eventuell noch Timer starten und herunterzählen
   M = Ischarwaiting(#2)
   If M = 0 Then Goto Quittungwarten
   Disp_quit = Inkey(#2)
'  Print #1 , "Quitung ist: " ; Hex(datein)
   Waitms 10                                                'Blindes zusätzliches Warten, erst dann gehts weiter
End Sub

'_______________________________________________

Beleuchtung_ein:
   Beleuchtung_aktiv = 1
   Beleuchtungsdauer_rest = Beleuchtungsdauer               'Startwert laden
   Gbuffer = Chr(27) + "YH" + chr(Helligkeit) + chr(13)     'Displayhelligkeit auf eingestellten Wert
   Gosub Write_edip
Return


'===============================================================================
'==========================   SPI-Transferroutinen   ===========================
'===============================================================================
'
Function Spitransfer(byval Dout As Word) As Word
   Ss = 0
   Dmiso = 0
   For Nspi = 1 To 16
       Dspi = Dout And &H8000
       If Dspi = 0 Then
          Mosi = 0
       Else
          Mosi = 1
       End If
       Dout = Dout * 2
       Dmiso = Dmiso * 2
       Dmiso = Dmiso + Miso
       Sck = 1
       Waitus 1
       Sck = 0
   Next Nspi
   Ss = 1
   Spitransfer = Dmiso
End Function


'(
Function Spitransfer(byval Dout As Word) As Word
   Ss = 0
   Cmd(2) = Low(dout)
   Cmd(1) = High(dout)
   Readin(1) = Spimove(cmd(1) , 2)
   Spitransfer = Makeint(readin(2) , Readin(1))
   Ss = 1
End Function
')
'_______________________________________________________________________________

 

Close #1
Close #2

End                                                         ' Programmende


$include "KokkeKat_FAT-free_SD_lib_code.bas"
$include "Twi_show_state.bas"
$include "Datenlogger2_menue V0.97.bas"

'
'*************************************************************************************************************
'        *********************************************************************************************
'                *****************************************************************************
'                        *************************************************************