zuerst die Antworten auf deine Fragen:
1. Das "Abfüllen" in eine lokale Variable ist nicht unbedingt die Lösung wenn der programmierte Ausdruck
bei der Zuweisung einer Variablen schon zu komplex ist. Allerdings will ich dieses Problem nicht zu hoch
hängen.
Folgendes Beispiel funktioniert jedenfalls:
for i=0 ... h_daten.ANZAHL_ROLLOS_PRO_GRUPPE-1
{
rolloIndex = h_daten.RolloGruppe[n].mitglied[i];
if ( rolloIndex < h_daten.ANZ_ROLLO_SCHALTER )
{
if (not h_daten.Rollo_Lz[rolloIndex].tasterbetaetigung and
not h_daten.Rollo_Lz[rolloIndex].zeitAufAktiv
and not h_daten.Rollo_Lz[rolloIndex].zeitZuAktiv)
{
RolloSchliessenEnde (rolloIndex);
}
}
else break;
}
Du erkennst allerdings 2 geschachtelte IF-Anweisungen. Dies ist gemacht worden um den Ausdruck "schlank"
zu halten.
Ein weiteres funktionierendes Beispiel:
if h_prozd.AusgPortBit[h_daten.Rollo[rolloIndex].a_adr].bit[h_daten.Rollo[rolloIndex].a_bit+1] == h_prozd.AUSG_EIN
//Oeffungsbewegung
{
if ( h_daten.PFlag.Regen
or h_prozd.TempInnenUnterschritten // Temperatur Innen unterschritten
or h_daten.Rollo_Lz[rolloIndex].aktuelleStellung2 > h_daten.Rollo[rolloIndex].zeitSchliessvorgang
// Oeffnungsweite erreicht
or h_prozd.TempAussenUnterschritten) // Aussentemperatur zu niedrig
{
// Rollo aus
h_daten.Rollo_Lz[rolloIndex].diagnose = 200;
RolloSchliessenEnde (rolloIndex);
continue;
}
}
Also, du siehst, dem System ist schon ein wenig zuzumuten.
Hier noch 2 Beispiele für Datentypen:
type rollo_schalter
{
byte text[LEN_FKTINFO_FELD]; // Beschreibungstext
byte modus; // fuer allgemeine Steuerungsfunktion, z.B. "Alles Aus"
// 0=manuell, 1=zeitsteuerung, 2=sonnensteuerung
byte a_adr; // Port-Ausgabeadresse des Rolladen
byte a_bit; // Bit-Start-Ausgabeadresse des Rolladen (2 Ausgabebits)
byte e_adr; // Port-Eingabeadresse fuer Betaetigung des Rolladen
byte e_bit; // Bit-Eingabeadresse fuer Betaetigung des Rolladen
byte z_modus; // Zusatzfunktion 0:AUS, 1:Sonnensensor 1, 2:Sonnensensor2, 3:Temperaturgesteuert
byte z_adr; // Zusatzfunktion Port-Eingabeadresse ( sperren der Rolladenbetaetigung per Zeit (z.B. Tuerkontakt)
byte z_bit; // Zusatzfunktion Bit-Eingabeadresse zum Sperren der Rolladenbetaetigung per Zeit (z.B. Tuerkontakt)
byte z_wert1; // Position in x/10tel geschlossenem Rolladen bei Beschattung
// Temperaturwert bei dem (Fenster) geöffnet wird
byte z_wert2; // Inhalt hat unterschiedliche Bedeutung, je nach Zusatzfunktion
// Lichtsensor-Nr. (0..2) bei Beschattungsfunktion
// Temperaturfuehler-Nr bei temperaturgesteuertem Fenster
int zeitAuf; // frueheste Oeffnungszeit des Rolladen
int zeitAufWoEnd; // frueheste Oeffnungszeit des Rolladen am Wochenende
int sonneVerzAuf; // Verzoegert oeffnen (t/min) nach Sonnenaufgang
int zeitZu; // SchlieÃ?zeit des Rolladen
int sonneVerzZu; // Verzoegert schliessen (t/min) nach Sonnenuntergang
byte zeitSchliessvorgang;// Tatsaechliche Zeit für Schlie�vorgang Rolladen
byte zeitBetaetigung; // Zeit in Minuten: Betaetigungszeit bis zum automatischen Abschalten des Relais
byte eis; // 1: oeffnet nicht bei Eisbildung (Regen+Temperatur)
byte dummy;
}
const ANZ_ROLLO_SCHALTER = 24;
const ROLLO_SCHALTER_DATSIZE = 38;
const ROLLO_SCHALTER_MEMSIZE = ROLLO_SCHALTER_DATSIZE*ANZ_ROLLO_SCHALTER;
type rollo_schalter_laufzeit
{
byte zustand; // 0=Aus, 1=Oeffnen, 2=Aus, 3=Schliessen
byte flankeVorbereitet; // fuer Auswertung der steigenden Flanke am Eingang
int tasterbetaetigung; // Tasterbetaetigung fuer Rollo ist aktiv
int tasterManuellZu; // Tasterbetaetigtes SchlieÃ?en verhindert zeitgesteuertes Oeffnen
// am selben Tag
long oeffnungszeit; // berechnete Zeit zum Oeffnen in Sekunden
long schliesszeit; // berechnete Zeit zum SchlieÃ?en in Sekunden
long endezeit; // Laufzeit Ende in Sekunden;
long aktuelleStellung; // Schliesszeit vom geoeffneten Zustand (Beschattungsstellung)
long aktuelleStellung2; // Schliesszeit vom geoeffneten Zustand (Beschattungsstellung)
long beginnBetaetigung; // Beginn-Zeit fuer Rollobetaetigung
int z_zustand; // aktueller Zustand bei Zusatzfunktionen
int beschattungZeit; // Berechnete Rollostellung bei Beschattung in Sekunden
int zeitAufAktiv; // Rollo faehrt zeitgesteuert AUF wenn =1
int zeitZuAktiv; // Rollo faehrt zeitgesteuert ZU wenn =1
int zFunktionAktiv; // wenn Beschattung aktiv
int zFunktionMoeglich; // bei Tagesbeginn wird Beschattung ermoeglicht
int diagnose;
}
rollo_schalter_laufzeit Rollo_Lz [ANZ_ROLLO_SCHALTER]; //
rollo_schalter Rollo [ANZ_ROLLO_SCHALTER]; //
Bei dem Datentyp rollo_schalter siehst du übrigens auch die Variable "dummy" zur Einhaltung der Wortgrenzen.
Meiner Erfahrung nach resultieren meistens die Probleme aus der Tatsache, dass z.B. Arraygrenzen überschrieben
werden.
Ich habe viele Jahre in ANSI-C programmiert. Dort hatte man z.B. die Möglichkeit mit Pointern (Zeiger zum lesen
und schreiben in beliebige RAM-Speicherbereiche) zu arbeiten. Das öffnete Tür und Tor für Fehler die wahnsinnig
schwer zu finden waren. Allerdings waren die Möglichkeiten toll und die Programme sehr effizient.
Ich denke dir bleibt nichts anderes übrig, als dein Programm in mühsamer Kleinarbeit zu testen.
Am besten du deaktivierst soviel Code wie möglich, fügst immer wieder Kontrollanzeigen ein und erweiterst
den Code wenn die Tests erfolgreich waren.
Viel Erfolg wünscht
Michael
> Hallo Migi
>
> Danke für den Tipp! Werde meinen Code mal dahingehend durchsehen und allenfalls anpassen.
>
> Noch zwei Detailfragen zum Thema:
>
> Funktionieren die IFs und allenfalls auch die FORs richtig, wenn ich den zu prüfenden Wert
> zuerst in eine lokale Variable abfülle? Kannst Du ev. ein kleine Beispiel posten, welches
> zeigt wie Du diese Probleme in den Griff gekriegt hast?
>
> Kann es nach Deiner Erfahrung sein, dass die Ã?bergabe komplexer Datentypen an Funktionen
> zu Problemen führt.Der folgende Codeausschnitt zeigt ein Beispiel dafür, d.h. �bergabe eine Datentyps
> aus einem Array an eine andere Funktion (Fett):
>
>
> function processdisplayinput(data.displaystruct display) {
> byte d[64];
> byte commandchar;
> byte l;
> byte Type, Val1, Val2;
>
> edip.receiveframe(display.address, display.status.inputbuffer);
>
> l=edip.getRxData(display.status.inputbuffer,d);
> if l>0 and l<255 {
> display.status.sleeptimer=system.timer()+display.timeout;
> }
> while l>0 and l<255 {
> if d[2]>0 and d[2]<255 {
> Type=d[0];
> Val1=d[2];
> Val2=d[3];
> command(display,Type,Val1,Val2);
> };
> l=edip.getRxData(display.status.inputbuffer,d);
> };
> };
>
> <b>function controldisplay(data.displaystruct display)</b> {
> processdisplayinput(display);
>
> if display.status.newpara.mode==display.status.para.mode {
> refresh(display);
> } else {
> exit(display);
> enter(display);
> };
> };
>
> thread displaythread {
> int t;
> for t=0 ... data.DisplayCount-1 {
> <b>controldisplay(data.display[t]);</b>
> };
> sysstat.Update(data.Threaddisp);
> };
>
>
> Danke und Gruss
>
> Tom
Meine Seite: http://cc2-Haussteuerung.de
Antwort schreiben
Antworten:
Re: Probleme mit komplexen Datentypen (von lizard - 18.01.2007 10:31)