5. Softwarebausteine Teil 3 (Stand: 23.2.2010)
(zurück
zu Teil_1 Teil_2)
Variable_in_RAM-Zelle freie Bytes nutzen NEU mit RANDOMIZE
z.B. Funkuhr Synchronisation neu starten
EEPROM_Variable Werte speichern und lesen, voll remanent, einfache direkte Lösung
Beispiele EEPROM-Variable bearbeiten und anzeigen,
Fester_Speicherplatz je Ereignis, Abschaltungen und Fehler speichern
Speicherplatz_je_Tag oder je Minute,
Betriebsstunden je Tag, je Woche oder
je Monat
Schieberegister word oder byte z.B. mit FOR.....NEXT - Schleife
Weiter zu Softwarebausteine_Teil_4
Tastatatur mit LED-Quittung der Station,
LED und LCD –Anzeigen des IO-Terminals
Einbindung Treiber IO-Teminal
Tastatur Applikationsboard, Methode der Fehleranalyse und Fehlerbeseitigung
LCD-Anzeige Applikationsboard mit Software Tastatur-Test und LCD
Fertige Programme: Tastatur, Zeichenvorrat LCD, byte , word, HEX-Zahl, ASCII ,
Relais schalten, Schrittsteuerung mit Wartezeit, Text- und Zahlenausgabe
5.3.4) Speicherwert (Variable) in RAM-Zelle
(Übernommen von D. Harlos und modifiziert).
Im RAM-Speicher wird eine Zelle (Hex-Adresse DC) vom Betriebssystem nicht benutzt. Sie kann als Variable genutzt werden. Wenn jedoch die Variablen-Erweiterung (siehe Stolpersteine) ausgeführt wurde, kann man diese Zelle wie andere Variable direkt als define NameXYZ byte [60] ansprechen.
Reichen die zusätzlichen Variablen der Erweiterung nicht aus, dann kann man die 15 Zellen Buffer der DCF77-Uhr nehmen. Sie liegen vor den User-Variablen ab byte [1] und können deshalb nur mit den folgenden Verfahren gelesen und beschrieben werden. Die Uhr läuft weiterhin; lediglich die Funkuhr DCF77 kann nicht mehr verwendet werden. Die Uhrendaten können von einem I2C-Baustein oder PC in die Variablen hour, day, usw. geladen werden oder die Uhr wird von Hand nachgestellt.
Meistens werden in den Programmen keine Zufallszahlen (RAND) gebraucht; dann sind die Zellen 9F und A0, also 2 Byte, frei. Diese Zellen kann man mit folgendem Verfahren nutzen:
1) Wert speichern (Beispiel Byte VariableA, sinngemäß VariableB)
Wert2 = Temperaturwert ' Wert-Übergabe muss mit wert2 erfolgen
Gosub writeA ' schreibt wert2 auf Adresse $9F
2) Wert holen
wert1 = VariableA ' den Wert von Adresse $9F holen und in z.B. wert1 speichern
3) Beispiel Zähler
wert2 = VariableA + 1 ' den Wert von RAM-Zelle holen, +1 und in wert2 speichern
Gosub writeA ' schreibt wert2 in RAM-Zelle
4) Wert speichern (Beispiel Word)
wert12 = Sollwert ' Wert bilden
Der folgende Befehl schreibt den Wert in das word an Adresse 9F und A0
RANDOMIZE wert12 ' (auch möglich RANDOMIZE Sollwert)
5) Wert holen (Word wert12 besteht aus Bytes wert1 und wert2)
wert1 = VariableA ' Byte-Wert von Adresse $9F in wert1 speichern
wert2 = VariableB ' Byte-Wert von Adresse $A0 in wert2 speichern
RANDOMIZE wert12 + 1 'Geholten Wert12 + 1 speichern, Beispiel Zähler
6) Beispiel: Funk-Uhr Synchronisation einschalten
Falls man die Synchronisation starten möchte, muss der Altwert der Funk-Uhr einmalig mit einer Zahl (60 bis 255) überschrieben werden.
Wert2 = 255 : gosub writeMinAlt
7) Unterprogramme
#writeA ' wert2 in RAM-Zelle schreiben
wert2 = wert2 ' durch diesen Trick wird der Wert auf den Stack gepusht
table RAMwriteA ' dann den Stackinhalt auf Adresse $9f schreiben
4501 '17*256+$9f-$a
tabend
return
#VariableA ' den Wert von Adresse $9f holen
table RAMreadA
2974 '11*256+$9f-1
tabend
return
#writeB ' wert2 in RAM-Zelle schreiben
wert2 =wert2 ' durch diesen Trick wird der Wert auf den Stack gepusht
table RAMwriteB ' dann den Stackinhalt auf Adresse $a0 schreiben
4502 '17*256+$a0-$a
tabend
return
#VariableB ' den Wert von Adresse $a0 holen
table RAMreadB
2975 '11*256+$a0-1
tabend
return
Die folgende RAM-Zelle ist define ... byte [60] bei Variablen-Erweiterung.
Nutzung ohne Variablen-Erweiterung wie oben bei 1) und 2) beschrieben:
#writeC ' wert2 in RAM-Zelle schreiben
wert2 =wert2 ' durch diesen Trick wird der Wert auf den Stack gepusht
table RAMwriteC ' dann den Stackinhalt auf Adresse $dc schreiben
4562 '17*256+$dc-$a
tabend
return
#VariableC ' den Wert von Adresse $dc holen
table RAMreadC
3035 '11*256+$dc-1
tabend
return
#ReadMinAlt ' RAM-Zelle Altwert Minute
table
readTabMA
2937
'11*256+$7A-1
tabend
return
#writeMinAlt
' RAM-Zelle Altwert Minute
wert2 =wert2 'var = var
table writetabMA
4464 'Hex7a 17*256+$7a-10
tabend
return
5.3.5) Speicherwerte
(Variable) im EEPROM , direkter Zugriff mit Zeiger
EEPROM-Variable sind
voll remanent, d.h. die gespeicherten Werte bleiben nach Reset und
Spannungsausfall erhalten.
Bei der folgenden Lösung sind die Variablen am Ende des
Speichers abgelegt und bleiben auch bei Neuladen eines geänderten Programms erhalten.
Lebensdauer des
Speichers
Das EEPROM verträgt 1 Million Schreibzugriffe.
Wird jede Minute in dieselbe Speicherzelle geschrieben, dann ist sie nach ca. 2 Jahren defekt. Bei einer Datenaufzeichnung je Minute beschreibt man jedoch jede Minute eine andere Speicherzelle. Bei einer Wiederholung je Tag wird die Speicherzelle nur einmal je Tag beschrieben.
Da die Speicherung am Ende des Speichers erfolgt, ist der Speicherbereich für das Programm nicht betroffen. Statt einer defekten Speicherstelle kann für die EEPROM-Variable eine andere Speicherzelle benutzt werden.
Bedingung für remanente Variable EEPROM
Nach einem Reset oder nach einem Spannungsausfall behalten die Variablen ihre Werte.
Bei Neuladen eines Programms wird das neue Programm nur auf Speicherzellen entsprechend der Länge des Programms geschrieben. Der Speicherbereich für die EEPROM-Variablen wird also nicht überschrieben. Die Länge des Programms wird nach Compilieren angezeigt und muss 4 byte kleiner als der Datei-Anfang sein.
Beispiel
Die Anfangsadresse der EEPROM-Variablen wird einmalig festgelegt (Beispiel 8000).
'Beispiel: 8000 bis 8178 = 178
Bytes für Variable. Durch word = 2 byte lautet der Zugriff mit Zeiger = 0 2
4...178. Bei Anfangsadresse 7900 stehen 278 byte zur Verfügung.
Programm und Datei dürfen sich natürlich nicht überschneiden.
Der Programmierer muss darauf achten, dass die Länge des
Programms + 4 Byte kleiner als die Anfangsadresse (8000) ist.
Die Datei darf bei dem üblichen 8
k-Speicher bis 8178 reichen.
Folgende Programmbausteine können kopiert werden.
Hierfür ist Variablen-Erweiterung notwendig. Siehe Kapitel Stolpersteine 1.11
' Definitionen zum Ansprechen der EEPROM-Datei
Define EEPROM_Anfang 8000 'Beispiel:
ab Adresse 8000 beginnen EEVariable bis 8178
Die Byte-Adressen 42 bis 45 sind die Datei-Adressen und liegen deshalb fest.
define ZeigerHigh byte [42] 'bleibt 0
define Zeiger byte [43]' (max 255) hier z.B. max 178
define DateiAnf1 byte [44]' Datei Anfangsadresse
define DateiAnf2 byte [45]' z.B. 8000
' sonstige Definitionen
define wert12 word [4] '
Zwischenspeicher für Schreiben und Lesen
define wert1 byte [7] ' Zwischenspeicher
Überlappung mit wert12
define wert2 byte [8] ' Zwischenspeicher
Überlappung mit wert12
define wert3 byte [ ] ' weiterer Zwischenspeicher
Vorbesetzung bzw. Initialisierung
' *** Initialisierung der Datei ***
Wert12 = EEPROM_Anfang ' Zugriff mit Zeiger = 0 (Speicherplatz 0)
DateiAnf1 = wert1
DateiAnf2 = wert2
ZeigerHigh = 0 ' nur das
Low-Byte Zeiger wird benutzt
' Befehle open# for write, usw. sind nicht notwendig und dürfen nicht verwendet werden.
' Abfragen filefree und eof können nicht genutzt werden. Der Programmierer darf nur richtige Werte des Zeigers programmieren.
Hauptprogramm
(1) Variable speichern (löschen)
wert12 = 0 : Zeiger = 4 : print# wert12 ' word Speicherplatz 4 Null setzen
(2) Bereich löschen
wert12 = 0 : Zeiger = 4 : print# wert12 ' Speicherplatz 4 beginnen
print# wert12 : print# wert12 : print# wert12 ' zusätzlich word Platz 6, 8, 10
(3) Variable speichern (z.B. Uhrzeit)
wert1 = hour : wert2 = minute
Zeiger = 4 : print# wert12 ' in Speicherplatz 4 schreiben
(4) Variable holen (gespeicherte Uhrzeit)
Zeiger = 4 : input# wert12 ' Speicherplatz 4 lesen und in Wert12 ablegen
wert1 enthält Speicherwert hour, wert2 enthält minute
Hierfür sind
Unterprogramme nicht notwendig.
weitere Beispiele siehe unten.
5.3.6)
Speicherwerte (Variable) im EEPROM, erweiterter Bereich
Bei dieser Lösung darf der Zeiger größer als 255 sein.
Zugriff mit Looktab und Tabellenwerte lesen und schreiben.
(in Arbeit)
5.3.7)
Beispiele für EEPROM-Variable (Fortsetzung)
(1) Mehrere Variable speichern
z.B. Uhrzeit, Datum und Messwert
wert1 = hour : wert2 = minute
Zeiger = 4 : print# wert12 ' Speicherplatz 4 beginnen
Nach Festlegung des Beginns kann man in Speicher 6, 8 usw. speichern, weil die Schreibposition um jeweils 2 erhöht ist.
wert1 = day : wert2
= month ' Daten zusammenfügen
print# wert12 ' Speicherplatz 6
print# Temperatur ' Wert von Variable Temperatur auf Speicherplatz 8
(2) Mehrere Variable holen
Zeiger = 4 : input# wert12 ' Speicherplatz 4 beginnen
wert1 enthält Speicherwert hour, wert2 enthält minute
Sofort nach der Auswertung von wert12 kann man Speicher 6, 8 usw. lesen, weil die Leseposition um jeweils 2 erhöht ist.
Input# wert12 ' Hole Speicher 6 nach wert12 oder mit Input# xyz in eine andere Variable.
(3) Variable versetzt holen
Im EEPROM liegen z.B. die Variablen hour und minute.
Nach Zeiger = 4 : print#
wert12
würden sie in wert1 und wert2
liegen.
Für die Ausgabe möchte man minute direkt in wert1 haben. Dafür gibt man eine Adresse
höher an.
Zeiger = 5 : print# wert12 ' Speicherplatz 5 holen
wert1 enthält Speicherwert minute, (wert2 enthält den Wert von Speicherplatz 6)
Der Wert liegt nun bereit für die Zahlenausgabe, die die Variable wert1 benutzt.
(4) Variable bearbeiten
Nach Abschalten des Brenners wird die Brennerzeit zur
gesamten Laufzeit addiert.
Dadurch wird nicht so häufig in das EEPROM geschrieben
(Lebensdauer!).
Außerdem bleibt die letzte Brennerzeit für eine Anzeige
erhalten.
Zeiger = 6 : input# wert12
' bisherige Laufzeit holen von Platz 6
wert12 = wert12 +
Brennerzeit
' neue Zeit dazu addieren
Zeiger = 6 : print# wert12 ' neue Laufzeit
speichern
(5) Variable anzeigen
Die Laufzeit hat hier 4-sec-Raster. Anzeige als Stunde : Minute
Zeiger = 6 : input# wert12
' Laufzeit nach wert12 holen von Platz 6
wert12 = wert12 / 15 '4 sec-Raster in Minuten umrechnen
print "Betriebsstunden: ";wert12 / 60;
":"; wert12 MOD 60;" Std.
";
(6) Ereigniszähler, Byte bearbeiten, fester Speicherplatz
Das Ereignis ist
einem Speicherplatz (Variablen-Nr.) fest zu geordnet.
Nach Abschalten des Brenners wird Abschalten und zusätzlich Abschalten durch Übertemperatur
gezählt.
Zeiger = 6: input# wert12 ' bisherigen Zählerstand holen von Platz 6
wert1 = wert1 + 1
' Abschaltung zählen
if UeberTemp then wert2 = wert2 + 1 'zusätzlich Fehler zählen
Zeiger = 6 : print# wert12 ' neue Zählerstände speichern
(7) Ereignis speichern,
Tag und Uhrzeit oder Uhrzeit und Messgröße
Das Ereignis ist
einem Speicherplatz (Variablen-Nr.) fest zu geordnet, z.B. „Letzte Abschaltung“
ist das Ereignis auf Platz 38.
Jedes Ereignis hat einen eigenen Speicherplatz.
Die Daten des Ereignisses werden
abgelegt: der Tag (ohne Monat) und
Uhrzeit oder Messwert und Uhrzeit. Siehe Beispiel weiter unten.
(8) Speicherplatz
abhängig von Datum oder Uhrzeit, Schreib- und Lese-Zeiger
Ist der Speicherplatz nicht fest einem Ereignis zugeordnet,
dann ist er zeitlich zugeordnet und es werden Datensätze z.B. die Messwerte einer
Messstelle gespeichert.
Die Speicherung erfolgt entweder zeitlich in der
Reihenfolge nacheinander (z.B. Abschalttemperaturen der Heizung) oder
periodisch nach Datum oder Uhrzeit. Diese Speicherorganisation nennt man
Ringspeicher. Nach Erreichen des letzten Speicherplatzes wird wieder von vorn
begonnen und der älteste Wert wird überschrieben.
Hierzu werden Schreib- und
Lese-Zeiger verwendet. Meist müssen sie wie in
den folgenden Beispielen errechnet werden.
Werden word gespeichert, müssen die Zeiger verdoppelt
werden.
Zeiger = hour SHL1 ergibt für
hour 0 bis 23 den Zeiger 0 bis 46.
Hierbei dient als Grundlage:
HOUR 0 bis 23 , DAY 1 bis 31 , MONTH 1 bis 12, Wochentag
DOW 0 bis 6 , Wochen-Nummer 1 bis 53 ,
Möchte man nur Werte z.B. der vergangenen 10 Tage sehen,
wird der Zeiger aus DAY MOD 11 gebildet. Der 11. ist nun 1, usw.
Jahrestag 1 bis 366 überschreitet 255, für Speicherung der
letzten 100 Tage, Zeiger = Jahrestag MOD 101 (Rest ist 1 bis 100)
(9) Monats-Speicher (fertiges Programm)
Beispiel: Monatlich sollen die Betriebsstunden gespeichert
werden.
In diesem Beispiel sind die vorderen Speicherplätze schon
mit anderen EEPROM-Variablen belegt, deshalb wird der Monatspeicher um 20
verschoben.
Der Speicherplatz wird aus der Monats-Nr des vergangenen
Monats am 1. Tag bestimmt.
Zunächst wird jedoch ein Minuten-Impuls gebraucht wie im
Kapitel Tipps und Tricks beschrieben.
' Bildung eines
Minuten-Impulses als Zeittakt (Definitionen
siehe Tipps und Tricks)
MinPuls = OFF ' (Minuten-Impuls Aus nach einem Programmdurchlauf)
if second < 5 then goto setz
Flanke = OFF ' Reset der
Flanke
Goto Ende11 '
#setz
if Flanke = ON then goto Ende11 'bei Ja, Minuten-Impuls bereits erfolgt
Flanke = ON 'Sperre
für einmalig je Minute
MinPuls = ON ' Minuten-Impuls einschalten
#Ende11
' Begrenzung
auf Monatswechsel
If not
MinPuls then goto ende3
if day >< 1
or hour >< 0 or minute >< 0 or year > 90 then goto ende3
Der folgende Programmteil wird am 1. Tag des Monats 00:00 also nach Mitternacht nur einmal durchlaufen. Dabei wird die Monats-Nr des abgelaufenen Monats bestimmt.
' Wert holen und
speichern ins EEPROM
Zeiger = 6: input# wert12
'Messwert z.B. bisherige Laufzeit holen von Platz 6 (siehe Beispiel
oben)
' bisherige Laufzeit liegt nun in Variable wert12 und wird
von dort „weggespeichert“.
Wert3 = month –1
if wert3 = 0 then wert3 = 12 ' Korrektur
am 1. Januar für Speicherplatz Dezember
Zeiger = wert3 * 2 + 20 ' Speicherplatz aus Monats-Nr bilden (22 bis 44)
Print# wert12 ' Laufzeit speichern
wert12 = 0 : Zeiger = 6 : Print# wert12 ' bisherige Laufzeit Null setzen
#ende3
Ansonsten wie vorige Beispiele.
(10)
Wochen-Speicher
Beispiel: Wöchentlich sollen die Betriebsstunden
gespeichert werden.
Der Speicherplatz wird aus der Wochen-Nummer 1 bis 53
(siehe Tipps und Tricks) bestimmt.
' Abspeichern in
EEPROM
If not MinutenImpuls then goto ende3 (siehe Kapitel Tipps und Steuerungstechnik)
if dow >< 0
or hour >< 23 or minute >< 59 or year > 90 then goto ende3
Der folgende Programmteil wird Sonntag vor Mitternacht nur einmal
durchlaufen und berechnet aus dem Datum die Wochen-Nr.
Hier ist Berechnung der Wochen-Nr einzufügen (siehe Tipps und Tricks).
Zeiger = 6: input# wert12
' bisherige Laufzeit holen von Platz 6 (siehe Beispiel oben)
' bisherige Laufzeit liegt nun in Variable wert12 und wird
von dort „weggespeichert“.
Zeiger = WochenNr * 2 + 20 ' Speicherplatz aus Wochen-Nr bilden (22 bis 126)
Print# wert12 ' Laufzeit speichern
wert12 = 0 : Zeiger = 6 : print# wert12 ' bisherige Laufzeit Null setzen
#ende3
Ansonsten wie vorige Beispiele.
(11)
Temperatur und Uhrzeit
in ein word packen
In einem Schieberegister word oder in einem
Ereignisspeicher kann eine Aufzeichnung der Abschalttemperatur einer Heizung
mit Uhrzeit erfolgen.
Nimmt man nur eine Uhrzeit
bis 12 Uhr (ohne Unterscheidung Vor- und Nachmittag), braucht man 4 Bit
für Stunde (bis 12) und 6 Bit für Minute (bis 59).
Dadurch hat man 6 Bit frei. 6 Bit
bedeutet 0 bis 63. Durch einen Sockel von 20 Grad können Temperaturen von 20
bis 83 Grad gespeichert werden.
Temp = Temperatur – 20
' für Abspeichern in EEPROM
wert12 = Temp SHL 10 + hour MOD 12 SHL 6 + minute
Zeiger = 4 : print#
wert12
' Umrechnen für Anzeige nach Holen
Zeiger = 4 : input# wert12
' Daten holen nach wert12
Print “;ZeigeStunde;“:“;ZeigeMinute;“ Uhr “;ZeigeTemperatur;“ Grad“
Anzeigewerte errechnet aus wert12
#ZeigeTemperatur Return (wert12 SHR 10 and
&H003F) + 20 'Maskierung Temperatur
#ZeigeStunde Return (wert12 SHR 6 and
&H000F) ' Maskierung Stunde (0-12)
#ZeigeMinute Return (wert12 and &H003F) ' Maskierung Minute
(12)
Tag und Uhrzeit in ein
word packen
Um die Abfragen zu minimieren, kann man Tag und Uhrzeit in
ein word packen (siehe auch Tipps und Tricks).
Verwendet wird dies, um ein Datum und Uhrzeit von einem
Ereignis zu speichern, z.B. Wann wurde der Grenzwert verletzt?
Hierbei werden für Tag (bis 31) 5 Bit , für Stunde (bis 23)
5 Bit und für Minute (bis 59) 6 Bit benötigt. Zusammen also 16 Bit = 1 word.
' für Abspeichern in EEPROM (wie vor)
wert12 = day SHL 11 + hour SHL 6 + minute
' Umrechnen für Anzeige nach
readEE (wie vor)
#ZeigeTag Return (wert12 SHR 11 and &H001F) 'Maskierung
Tag
#ZeigeStunde Return (wert12 SHR 6 and &H001F) '
Maskierung Stunde
#ZeigeMinute Return (wert12 and &H003F) ' Maskierung Minute
(13)
Byte statt word
speichern
Falls man Speicherplatz sparen muss,
kann man nur ein Byte je Messwert speichern. Minus-Temperaturen in einem Byte
siehe Kapitel Tricks.
Zum besseren Verständnis der
Byte-Belegung wird hier einzeln gespeichert. Der Schreibzeiger kann natürlich
direkt z.B. Zeiger = hour sein.
Wert1 = Messwert von 18 Uhr
Wert2 = 0
Zeiger = 18 : print# wert12 ' Schreiben auf 18 (und 19)
Wert1 = Messwert von 19 Uhr
Wert2 = 0
Zeiger = 19 : print# wert12 '
Schreiben auf 19 (und 20)
Wert1 = Messwert von 20 Uhr
Wert2 = 0
Zeiger = 20 : print# wert12 '
Schreiben auf 20 (und 21)
Das rechte Byte wird auch überschrieben und wird erst beim
nächsten Schreiben sinnvoll belegt.
Falls notwendig, kann man auch erst die
alten Werte lesen und dadurch den rechten alten Wert zurückschreiben:
Zeiger = 18 : input# wert12 ' Lesen alte Werte von 18 und 19 nach
wert1 und wert2
Wert1 = Messwert von 18 Uhr
setzen
Zeiger = 18 : print# wert12 ' Schreiben auf 18 (und 19)
(14)
Schieberegister
word Alte Werte jeweils schieben um 2 Byte nach rechts
Beim Schieberegister werden die Daten im EEPROM-Speicher
geschoben, d.h. es wird häufig geschrieben.
Nachteile: verminderte Lebensdauer, höhere Programm-Laufzeit
Vorteil: einfache Ausgabe auf
Bildschirm mit zeitlicher Reihenfolge Neu Richtung Alt oder umgekehrt.
(1) Programmiert mit einzelnen Anweisungen, Schieben
von links nach rechts
Zeiger = 56 : input# wert12 'Altwert von Platz 56
(Zeiger wird 58 nach input#)
Print# wert12 ' Schreiben
auf Platz 58, d.h. Ein word nach „hinten“ schieben
Nun ist Platz 56 „frei“ zum Überschreiben
Zeiger = 54 : input# wert12 : print# wert12 'von Platz 54 auf 56 schieben
Zeiger = 52 : input# wert12: print# wert12 'von Platz
52 auf 54 schieben
Zeiger = 50 : input# wert12: print# wert12 'schieben
Zeiger = 48 : input# wert12: print# wert12 'schieben
Zeiger = 46 : input# wert12: print# wert12 'schieben
Zeiger = 44 : input# wert12: print# wert12 'schieben
Zeiger = 42 : input# wert12: print# wert12 'schieben
Zeiger = 40 : input# wert12: print# wert12 'von Platz 40 auf 42 schieben
Nun ist Platz 40 „frei“ zum Speichern des Neuwerts
wert12 = VorlaufTemp ' neue Abschalttemp
Zeiger = 40 : print# wert12
(2) Der Baustein kann auch zeilenweise mit gosub programmiert
werden.
Zeiger = 54 gosub Schieben
Zeiger = 52 gosub Schieben
usw.
Zeiger = 40 gosub Schieben
Nun ist Platz 40 „frei“ zum Speichern des Neuwerts
wert12 = VorlaufTemp ' neue Abschalttemp
Zeiger = 40 : print# wert12 ' speichern
------- Unterprogramm
# Schieben
input# wert12: print# wert12 :
Return
(3) Der Baustein kann zweckmäßig mit „FOR... NEXT - Schleife mit STEP –2“ programmiert werden.
Das Schieben von links nach
rechts (z.B. Platz von 54 auf 56) ergibt sich dadurch, dass bei input# der
Zeiger (Platz) +2 erhöht wird und damit den richtigen Wert für print# hat. Der
Zeiger wird unmittelbar für NEXT benutzt und muss auf den letzten Wert (z.B.
54) restauriert werden. Der nächste Durchlauf erfolgt durch „STEP –2“ mit Zeigerwert 52.
FOR Zeiger = 54 to 40 STEP –2 '(Minus 2) 52, 50, ….40
input# wert12 ' Beispiel 54
(Zeiger wird 56) Lesen
print# wert12 ' mit Zeiger
56 speichern (Zeiger wird 58) Schreiben
Zeiger = Zeiger - 4
' Zeiger restauriert auf 54
Next
' Zeiger 54 wird im 2. Durchlauf 52 (STEP –2), usw. bis 40
Nun ist Platz 40 „frei“ zum Speichern des Neuwerts.
wert12 = VorlaufTemp ' z.B.neue Abschalttemp
Zeiger = 40 : print# wert12 ' speichern
(4) Ausgabe mit „FOR...NEXT
– Schleife (letzter Wert links)
der letzte Wert steht links auf Platz 40 und soll als
erster Wert ausgegeben werden. Die Ausgabe der Werte erfolgt in einer
Bildzeile.
print "Historie " ; ' semicolon bedeutet Bildzeile beibehalten
FOR Zeiger = 40 to 56 STEP 2 '(Plus 2) 42, 44, ....56
' print " Z ";Zeiger; ' Anzeige Zeiger nur für Kontrolle
aktivieren
input# wert12 ' Wert holen
mit z.B. Zeiger 40 (wird 42 durch input#)
print " ";wert12 ; 'Ausgabe
zeiger = Zeiger –2 '
Zeiger restauriert auf 40
NEXT ' Zeiger 40 wird im 2. Durchlauf 42, usw. bis
56
(5) Ausgabe mit „FOR...NEXT
– Schleife (letzter Wert rechts)
der älteste Wert steht rechts auf Platz 56 und soll als
erster Wert ausgegeben werden. Die Ausgabe der Werte erfolgt in einer
Bildzeile.
print "Historie " ; ' semicolon bedeutet Bildzeile beibehalten
FOR Zeiger = 56 to 40 STEP –2 '(Minus 2) 54, 52, ….40
' print " Z ";Zeiger; ' Anzeige Zeiger nur für
Kontrolle aktivieren
input# wert12 ' Wert holen
mit z.B. Zeiger 56 (wird 58 durch input#)
print " ";wert12 ; 'Ausgabe
zeiger = Zeiger –2 '
Zeiger restauriert auf 56
NEXT ' Zeiger 56 wird im 2. Durchlauf 54, usw. bis 40
(15)
Schieberegister word
Alte Werte jeweils schieben um 2
Byte nach links
Altwerte 1 word weiterschieben und speichern, schieben von
rechts nach links
Die Werte im Schieberegister werden
nach „vorne“ geschoben, dadurch liegen die ältesten Werte links. Dies ist bei
der Ausgabe mit input# ohne for..next vorteilhaft.
Zeiger = 12 : input# wert12 'Altwert von Platz 12
Zeiger = 10 : print# wert12 ' Ein word nach „vorne“ schieben
Nun ist Platz 12 „frei“ zum
Überschreiben
Zeiger = 14 : input# wert12 '
Zeiger = 12 : print# wert12 '
Zeiger = 16 : input# wert12 '
Zeiger = 14 : print# wert12 '
Zeiger = 18 : input# wert12 '
Zeiger = 16 : print# wert12 '
Zeiger = 20 : input# wert12 'Altwert
Zeiger = 18 : print# wert12 ' Ein word
nach „vorne“ schieben
Nun ist Speicherplatz 20 „frei“ für den Neuwert
Wert12 = Neuwert
Zeiger = 20 : print# wert12 ' Neuwert
speichern
Der Baustein kann zweckmäßig als „for... next- Schleife mit
Step programmiert werden oder
zeilenweise mit gosub.
Zeiger = 14 gosub Schieben
Zeiger = 16 gosub Schieben
-- Unterprogramm -----‚
#Schieben ' z.B. Zeiger
= 14
input# wert12 ' Zeiger
ist jetzt +2 erhöht (=16)
Zeiger = Zeiger – 4 : print# wert12 ' Zeiger = 12 für Speicherung
Return
Werte des
Schieberegisters word ausgeben, dabei
wird nur die Startadresse des Zeigers angegeben
Zeiger = 10 : input#
wert12 'Altwert vom Speicherplatz 10 holen
print "Anzeige ";wert12; '
Text mit Zahlenwert anzeigen
input# wert12 '
Wert vom Speicherplatz 12 holen
print " ";wert12; '
nächsten Zahlenwert anzeigen
input# wert12 '
Wert vom Speicherplatz 14 holen
print " ";wert12; ' nächsten Zahlenwert anzeigen
....... usw.
(16)
Schieberegister
byte Alte Werte jeweils schieben
um 1 Byte nach links
'Beispiel Byte 47 bis 65 (Speicherbereich)
for Zeiger = 47 to 63 Step 2 '(Plus 2) 49, 51, 53,...63
input# wert12 ' Beispiel
47 (Zeiger wird 49) 'Alte Temperatur
Zeiger = Zeiger –3
' Zeiger wird 46 (letzter wird 62)
print# wert12 'speichern auf älter (Zeiger wird 48) (letzter wird 64)
Zeiger = Zeiger –1
' Zeiger restauriert auf 47
next ' wird dort 49
' letzte bytes mit print waren 64, 65
Zeiger = 65 : input# wert12 'Alten Wert (byte) holen
' wert1 ist alter Wert ,
wert2 wird Neuwert
wert2 = Temperatur ' neuen
Wert setzen
Zeiger = 64 :
print# wert12 'speichern Temperatur (alt, neu)
auf bytes 64, 65
(17)
Schieberegister
byte Alte Werte jeweils schieben
um 1 Byte nach rechts
'Beispiel Byte 70 bis 78 (Speicherbereich)
for Zeiger = 76 to 70 Step –2 '(Minus
2) 74, 72, 70
input# wert12 ' Beispiel
76 (Zeiger wird 78)
Zeiger = Zeiger –1
' Zeiger wird 77 (speichert auf 77 und
78)
print# wert12 'speichern auf älter (danach Zeiger = 79, Byte 79 und 80
bleiben frei)
Zeiger = Zeiger –3
' Zeiger restauriert auf 76
next '(zeiger wird dort 74) 72,70
' wert1 ist Altwert vom letzten Schieben
wert2 = wert1 ' Letztes
Byte (Altwert) kopieren
' Neuwert
Betriebsstundenzähler
wert1 = Zaehlerwert '=
Betriebsstundenzähler
Zeiger = 70 : print# wert12 'speichern
Zähler (byte neu, alt)'
(18)
Schieberegister byte
anzeigen
Anzege zu (15)
print " Ein
"
for Zeiger = 46 to 64
Step 2
'print " Z ";Zeiger; ' eventuell aktivieren für Kontrolle Zeiger
input# wert12 ' Wert
holen
print " ";wert1;" ";wert2; ' Wert
ausgeben
zeiger = zeiger –2 'Zeiger restaurieren wegen input# (+2)
next
Anzeige zu (16)
print " Zähler";
for Zeiger = 70 to 76 Step 2
'print " Z=";Zeiger; ' eventuell aktivieren für
Kontrolle Zeiger
input# wert12
print " ";wert1;" ";wert2;
zeiger = zeiger –2 'Zeiger
restaurieren wegen input# (+2)
next
' letzte Ausgabe ist Byte 76 und 77
Zeiger = 78 ' letztes Byte vom Schieberegister
input# wert12 ' byte 78, 79
print " ";wert1;" " ' nur byte 78 ist Wert
vom Schieberegister
--------------------------------------------------------------------------------------------------------------
'------ Ende EEPROM-Variable -----------------------------------------
------------------------------------- ENDE Softwarebausteine Teil 3 ------------ nach_oben
zurück zu Softwarebausteine_Teil_1 Teil_2 weiter zu Teil_4 Startseite
