Code stürtzt laufend ab.....

Joshua314 · Beitrag von **Joshua314** » 04.03.2019 20:06

Dieser Code stützt bei mir immer ab.... Mit Ungültiger Speicherzugriff
Wer kann mir helfen ???

Gruß Thomas

Datei GlockenDef.txt

Code: Alles auswählen

[Glocke_1]
Schlagzeit=3000
Laufzeit=1500
Gesamtzeit=3500
Bit=2
[Glocke_2]
Schlagzeit=3000
Laufzeit=1500
Gesamtzeit=3000
Bit=3

Eigentlicher Code

Code: Alles auswählen

EnableExplicit


#TagS = 24*60*60
#MaxGlocken =   8

#Schlagzeit = "Schlagzeit"
#Laufzeit   = "Laufezeit"
#Gesamtzeit = "Gesamtzeit"

Enumeration
#And
#Or
EndEnumeration


Enumeration RunMode
  #dry
  #hot
EndEnumeration


Structure Fehler
  Date.l
  Fehler.s
EndStructure

Global NewList Fehler.Fehler()

Structure GlockenDef
  Nr.i
  Schlagzeit.i                        ; Zeit bis zum Schlag 
  Laufzeit.i                          ; Zeit des Motors
  Gesamtzeit.i                        ; Gesamtlaufzeit bis ein Zyklus zu ende ist
  Bit.i                               ; Bit welches Geschaltet werden muss
EndStructure

Global NewList GlockenDef.GlockenDef()

Structure Glocken
  Jahr.i
  Monat.i
  Tag.i
  Stunde.i
  Minute.i
  DoIt.s
EndStructure

Global NewList Glocken.Glocken()

Structure IO
  Output.i
  Zeit.i
  Typ.i
EndStructure

Global  NewList IO.IO()
Global  NewList IO_T.IO()
Global  NewList IO_Buffer.IO()

Global Dim IO_Typ.s(2)
IO_Typ.s(0) ="R_"
IO_Typ.s(1) ="S_"

Procedure AddFehler(S.s,Nr.i,Date.l)
  AddElement(Fehler())
  Fehler()\Date= Date
  If Nr
    Fehler()\Fehler = "Zeile:"+Right("0000"+Str(Nr),4)+" "+S
  Else 
    Fehler()\Fehler = S
  EndIf   
EndProcedure

  

Procedure min(a.i,b.i)
  If a <= b 
    ProcedureReturn a
  Else 
    ProcedureReturn b
  EndIf 
EndProcedure

Procedure max(a.i,b.i)
  If a >= b 
    ProcedureReturn a
  Else 
    ProcedureReturn b
  EndIf 
EndProcedure



Procedure InserIO(ms.i,*Glockendef)
   
  PushListPosition(GlockenDef())
  ChangeCurrentElement(GlockenDef(),*GlockenDef)
 
  AddElement(IO())
  IO()\Zeit = ms-Glockendef()\Schlagzeit
  IO()\Output = (1<<GlockenDef()\Bit)
  IO()\Typ = #Or
  AddElement(IO())
  IO()\Zeit = (ms-Glockendef()\Schlagzeit)+ GlockenDef()\Laufzeit
  IO()\Output = 1<<GlockenDef()\Bit
  IO()\Typ=#And 
  PopListPosition(Glockendef())
  
  ProcedureReturn 1
EndProcedure

Procedure.i GlockendefLesen(File.s)      ; Liest die Definition der einzelnen Glocken  Physik
  Protected.i i,F,Result
  
  F = OpenPreferences(File)
  If F
    ClearList(GlockenDef())
    For I = 1 To #MaxGlocken
      If PreferenceGroup("Glocke_"+Str(i))
        AddElement(GlockenDef())
        Result = 1                                                     ; wir nehmen an, dass alles ok ist 
        With GlockenDef()
          \Nr = i 
          \Schlagzeit =  ReadPreferenceInteger("Schlagzeit",0)       
          \Laufzeit   =  ReadPreferenceInteger("Laufzeit",0)       
          \Gesamtzeit =  ReadPreferenceInteger("Gesamtzeit",0)       
          \Bit        =  ReadPreferenceInteger("Bit",0)       
          
          If \Schlagzeit <=0 
            Result = 0 
            AddFehler("GlockenDefFehler: Glocke"+Str(i)+" Schlagzeit <=0",0,Date())
          EndIf 
          
          If \Laufzeit <=0 
            Result = 0 
            AddFehler("GlockenDefFehler: Glocke"+Str(i)+" Laufzeit <=0",0,Date())
          EndIf 
          
          If \Gesamtzeit <=0 
            Result = 0 
            AddFehler("GlockenDefFehler: Glocke"+Str(i)+" Schlagzeit <=0",0,Date())
          EndIf 

          
          If \Schlagzeit < \Laufzeit
            Result = 0 
            AddFehler("GlockenDefFehler: Glocke"+Str(i)+" Schlagzeit < Laufzeit",0,Date())
          EndIf 
          
          If \Gesamtzeit < \Schlagzeit
            Result = 0 
            AddFehler("GlockenDefFehler: Glocke"+Str(i)+" Gesamtzeit < Schlagzeit",0,Date())
          EndIf 
                 
          If Not Result 
            DeleteElement(GlockenDef())
          EndIf   
        EndWith
      EndIf   
    Next I
    If ListSize(GlockenDef())
      SortStructuredList(GlockenDef(),#PB_Sort_Descending,OffsetOf(GlockenDef\Schlagzeit),#PB_Integer)
    EndIf 
    ProcedureReturn ListSize(GlockenDef())
  Else 
    ProcedureReturn -1
  EndIf 
EndProcedure
Procedure.l OsterDate (Jahr.i)
;   { Ostern faellt auf den n. Maerz.  Beisp.: OSTERN=33 bedeutet 2.April    }
;   { Quelle: http://cssa.stanford.edu/~marcos/carter.html, modifiziert nach }
;   { der Gregorianischen Schaltjahresrechnung. Gueltig fuer 1894 bis 2203   }
    Protected.i a,b,c,Dat 
  
    a = (204 - 11 * (jahr % 19) ) % 30 + 21
    b = a - (a / 49)
    c = jahr + (jahr / 4) - (jahr / 100) + (jahr / 400) + b + 37
    Dat = b - (c % 7) + 7
    ProcedureReturn Date(Jahr,3+(Round((Dat-1)/31, #PB_Round_Down)),1+((Dat-1)%31),0,0,0)
EndProcedure
Procedure.i OsterMonat(Datum.d)
  ProcedureReturn Month(OsterDate(Year(Datum)))
EndProcedure
Procedure.i OsterTag(Datum.d)
 ProcedureReturn Day(OsterDate(Year(Datum)))
EndProcedure
Procedure ErrorDisplay(Flag.i)
  Protected.s Error
  
  If ListSize(Fehler())
    ForEach Fehler()
      Error = Error + FormatDate("%dd.%mm.%yyyy %hh:%ii:%ss ",Fehler()\Date)+ Fehler()\Fehler+Chr(10)
    Next Fehler()
    ;MessageRequester("Fehler",Error)
    If Flag 
      ClearList(Fehler())
    EndIf 
  EndIf 
EndProcedure


Procedure.s Replace(InStr.s,Datum.l)                                    ; Tauscht Macros aus   incl Ostern   für das passende Jahr 
  Protected Ostern.l 
  Protected OutStr.s
  
  Ostern = OsterDate(Year(Datum))
  
;   InStr = ReplaceString(InStr,"OSTERSONNTAGMONAT",Str(Month(Ostern)))
;   InStr = ReplaceString(InStr,"OSTERSONNTAGTAG",Str(Day(Ostern)))
;   InStr = ReplaceString(InStr,"OSTERMONTAGMONAT",Str(Month(Ostern+(#TagS))))
;   InStr = ReplaceString(InStr,"OSTERMONTAGTAG",Str(Day(Ostern+(#TagS))))
;   InStr = ReplaceString(InStr,"OSTERSAMSTAGMONAT",Str(Month(Ostern-(#TagS))))
;   InStr = ReplaceString(InStr,"OSTERSAMSTAGTAG",Str(Day(Ostern-(#TagS))))
;   InStr = ReplaceString(InStr,"KARFREITAGMONAT",Str(Month(Ostern-(2*#TagS))))
;   InStr = ReplaceString(InStr,"KARFREITAGTAG",Str(Day(Ostern-(2*#TagS))))
; 
; 
;   InStr = ReplaceString(InStr,"PFINGSTSONNTAGMONAT",Str(Month(Ostern+(49*#TagS))))
;   InStr = ReplaceString(InStr,"PFINGSTSONNTAGTAG",Str(Day(Ostern+(49*#TagS))))
;   InStr = ReplaceString(InStr,"PFINGSTMONTAGMONAT",Str(Month(Ostern+(50*#TagS))))
;   InStr = ReplaceString(InStr,"PFINGSTMONTAGTAG",Str(Day(Ostern+(50*#TagS))))
;   
;   InStr = ReplaceString(InStr,"ROSENMONTAGMONAT",Str(Month(Ostern-(48*#TagS))))
;   InStr = ReplaceString(InStr,"ROSENMONTAGTAG",Str(Day(Ostern-(48*#TagS))))
;   
;   InStr = ReplaceString(InStr,"ASCHERMITTWOCHMONAT",Str(Month(Ostern-(46*#TagS))))
;   InStr = ReplaceString(InStr,"ASCHERMITTWOCHTAG",Str(Day(Ostern-(46*#TagS))))
; 
;   
;   
;   InStr = ReplaceString(InStr,"HIMMELFAHRTMONAT",Str(Month(Ostern+(39*#TagS))))
;   InStr = ReplaceString(InStr,"HIMMELFAHRTTAG",Str(Day(Ostern+(39*#TagS))))
;   
;   InStr = ReplaceString(InStr,"FRONLEICHNAMMONAT",Str(Month(Ostern+(60*#TagS))))
;   InStr = ReplaceString(InStr,"FRONLEICHNAMTAG",Str(Day(Ostern+(60*#TagS))))
  
  
  
  If FindString(InStr,"JAHR") > 0 
    InStr = ReplaceString(InStr,"JAHR",Str(Year(Datum)))
  EndIf 
  
  If FindString(InStr,"MONAT") > 0 
    InStr = ReplaceString(InStr,"MONAT",Str(Month(Datum)))
  EndIf 
  
  If FindString(InStr,"TAG") > 0 
    InStr = ReplaceString(InStr,"TAG",Str(Day(Datum)))
  EndIf 
  
  If FindString(InStr,"STUNDE") > 0 
    OutStr =  ReplaceString(InStr,"STUNDE",Str(Hour(Datum)))
    InStr = OutStr
  EndIf 
  
  If FindString(InStr,"MINUTE") > 0 
    InStr = ReplaceString(InStr,"MINUTE",Str(Minute(Datum)))
  EndIf
  
  If FindString(InStr,"JAHR") > 0 
    InStr = ReplaceString(InStr,"*","-1")
  EndIf 
  
  ProcedureReturn InStr
EndProcedure
Procedure.i ParseInt(Zeile.s,*Value)                                 ; holt einen Int aus Zeile 
  Protected.s STR = ""
  Protected.i Val,Pos=1,Flag = 0
  
  If Left(Zeile,1) = "-" 
    Flag = 1
  EndIf     
  
  While ((Mid(Zeile,Pos,1) >= "0") And (Mid(Zeile,Pos,1) <="9")) 
    STR + Mid(Zeile,Pos,1)   
    Pos+1
  Wend
  
  If STR <> ""
    Val = Val(STR)
    If Flag
      Val = Val *-1
    EndIf   
    PokeI(*Value,Val)
  EndIf   
  ProcedureReturn Len(STR)+Flag
EndProcedure
Procedure CheckNow(*Glocke.Glocken,Zeit.l)                           ; Checkt ob *Glocke mit jetzt übereinpasst  mit der Angegebene Zeit übereinpasst 
  Protected.i Now=1
  
  If (*Glocke\Jahr   >  0) And (*Glocke\Jahr   <> Year(Zeit))   : Now = 0 : EndIf 
  If (*Glocke\Monat  >  0) And (*Glocke\Monat  <> Month(Zeit))  : Now = 0 : EndIf 
  If (*Glocke\Tag    >  0) And (*Glocke\Tag    <> Day(Zeit))    : Now = 0 : EndIf   
  If (*Glocke\Stunde > -1) And (*Glocke\Stunde <> Hour(Zeit))   : Now = 0 : EndIf 
  If (*Glocke\Minute > -1) And (*Glocke\Minute <> Minute(Zeit)) : Now = 0 : EndIf 
  ProcedureReturn Now
EndProcedure
Procedure.i Parse(Zeile.s,Parse.s,*Value)                            ; parsed InStr Zeile -die Variable Parse - und schreibt den wert InStr *Value
  Protected.i Pos
 
  Pos = FindString(Zeile,Parse)
  
  If Pos > 0
    Pos + Len(Parse)
    If Mid(Zeile,Pos,1) = "*"
      PokeI(*Value,-1) 
      ProcedureReturn 1
    Else 
      ProcedureReturn ParseInt(Mid(Zeile,Pos),*Value)
    EndIf 
  EndIf 
  ProcedureReturn 0
EndProcedure
Procedure GlockenMath(*S ,Nr.i)                                    ; sucht nach < und >  und kann dazwischen EINE Rechenoperation durchführen 
  Protected.s InStr 
  Protected.i StartPos,Pos,P,a,b,OP,Cnt,OK= 1
  
  InStr = PeekS(*S)
  
  While FindString(InStr,"<")
    StartPos = FindString(InStr,"<") 
    Pos = Startpos + 1
    a=0
    b=0
    Cnt = 0
    P = ParseInt(Mid(InStr,Pos),@a)
    If P 
      Cnt+1
    Else 
      AddFehler("GlockenMath: Linkes Argument fehlt",Nr,Date())
      OK = 0 
    EndIf   
    
    Pos + P 
    OP = 0
    
    If FindString(Mid(InStr,Pos,1),"+")
      OP= 1
    ElseIf FindString(Mid(InStr,Pos,1),"-")
      OP= 2
    ElseIf FindString(Mid(InStr,Pos,1),"*")
      OP= 3
    ElseIf FindString(Mid(InStr,Pos,1),"/")
      OP= 4      
    ElseIf FindString(Mid(InStr,Pos,1),"%")
      OP= 5
    EndIf   
    
    If OP 
      Pos +1 
      Cnt +1
    Else 
      AddFehler("GlockenMath: Operator fehlt",Nr,Date())
      OK = 0
    EndIf 
    
    P = ParseInt(Mid(InStr,Pos),@b)
    If P 
      Cnt +1
    Else   
      AddFehler("GlockenMath: Rechtes Argument fehlt",Nr,Date())
      OK = 0 
    EndIf   
    
    Pos + P 
    
    If Mid(InStr,Pos,1) = ">"
      Pos + 1
      If Cnt = 3
        Select OP
          Case 1: a = a + b
          Case 2: a = a - b
          Case 3: a = a * b
          Case 4: a = a / b
          Case 5: a = a % b
        EndSelect
      EndIf 
      InStr = ReplaceString(InStr,Mid(InStr,StartPos,Pos-StartPos),Str(a))
    Else 
      AddFehler("GlockenMath: rechte > fehlt",Nr,Date())
      ok = 0 
    EndIf   
  Wend   
  
  If ok                  ; wenn alles ok ist schreiben ändern wir den String 
    PokeS(*S,InStr)
  EndIf 
  
  
  ProcedureReturn OK 
EndProcedure
Procedure ParseCron(Links.s,*G.Glocken,Nr.i)                         ; Links ist der Teil der geparst werden soll, Position InStr der liste 
  Protected.i Result = 1,OldPos
  
  If Not Parse(Links,"JA",*G+OffsetOf(Glocken\Jahr))
    AddFehler("ParseLine:  Zeitpunkt Jahr fehlt",Nr,Date())
    Result =0
  EndIf   
  
  If Not Parse(Links,"MO",*G+OffsetOf(Glocken\Monat))
    AddFehler("ParseLine: Zeitpunkt Monat fehlt",Nr,Date())
    Result =0
  EndIf   
  
  If Not Parse(Links,"TA",*G+OffsetOf(Glocken\Tag))
    AddFehler("ParseLine: Zeitpunkt Tag fehlt",Nr,Date())
    Result =0
  EndIf   
  
  If Not Parse(Links,"ST",*G+OffsetOf(Glocken\Stunde))
    AddFehler("ParseLine: Zeitpunkt Stunde fehlt",Nr,Date())
    Result =0
  EndIf   
  
  If Not Parse(Links,"MI",*G+OffsetOf(Glocken\Minute))
    AddFehler("ParseLine: Zeitpunkt Minute fehlt",Nr,Date())
    Result =0
  EndIf   
  
  ProcedureReturn Result 
EndProcedure
Procedure SucheGlocke(Nr.i)                                          ; Sucht die Glockennummer und gibt den Zeiger auf den Glockendef zurück
  ForEach GlockenDef()
    If GlockenDef()\Nr = Nr
      ProcedureReturn @GlockenDef()
    EndIf 
  Next GlockenDef()
  ProcedureReturn -1
EndProcedure
Procedure.s GlockenMachenMitZeitString()                             ; gibt einen String zurück, der den IO
  Protected.s Result=""
  ForEach IO_T()
    Result = Result +"P:"+Str(IO_T()\Output)+"Z:"+Str(IO_T()\Zeit)+";"
  Next IO_T()
  ProcedureReturn Result  
EndProcedure




Procedure GlockenMachenMitZeit()
  Protected.i Oldtime=0,Port=0,Last=-1
  
  If ListSize(IO())
    ClearList(IO_T())
    ForEach IO()
      PushListPosition(IO())      
      If Last <> IO()\Zeit                                 ;Nur wenn wir eine Neue Zeit haben --- Sonst fassen wir nur zusammen 
        AddElement(IO_T())
      EndIf   
      Last = IO()\Zeit                                     ;und dann den Merker neu setzen 
      If IO()\Typ = #Or 
         IO_T()\Output = Port |IO()\Output
      ElseIf IO()\Typ = #And
         IO_T()\Output = Port & ~IO()\Output
      EndIf 
      Port = IO_T()\Output
      If NextElement(IO())
        IO_T()\Zeit  = IO()\Zeit - OldTime
        Oldtime + IO_T()\Zeit
      Else 
        IO_T()\Zeit =0 
      EndIf   
      PopListPosition(IO())
    Next IO()  
  EndIf 
EndProcedure


Procedure.s GlockenMachenString()
  Protected.s Result=""
  ForEach IO()
    Result = Result +IO_Typ(IO()\Typ)+"P:"+Str(IO()\Output)+"Z:"+Str(IO()\Zeit)+";"
  Next IO()
  ProcedureReturn Result  
EndProcedure




Procedure.i GlockenMachen(*S,nr,Mode.i)
  Protected.i Pos=1,StartZeit=0,G,Gesamtwarten,W,P,MaxLaufzeit=0,KlammerFlag,Result=1,Insert=0
  Protected *GlockenAdresse
  Protected InStr.s
  
  InStr = PeekS(*S)
  
  ClearList(IO())                                                                              ; erst mal leer machen 
  
  While Pos < Len(InStr)
    Select Mid(InStr,Pos,1)
      Case "("
        Pos +1 
        Gesamtwarten = 0                                                                       ; Warten InStr der Klammer zurücksetzen  
        MaxLaufzeit = 0 
        If Klammerflag
          AddFehler("Glocken KlammerFehler: ) vor (",NR,Date())  
          Result = 0 
          Break
        EndIf 
        Klammerflag = 1 
      Case ")"
        Pos +1 
        StartZeit + MaxLaufzeit                                                                ; jetzt die Maximallauzeit der letzten Gesamtklammer als neuer Start
        Klammerflag = 0
      Case "G"
        Pos + 1
        P = ParseInt(Mid(InStr,Pos),@G)
        If Not P 
          AddFehler("GlockenStartOffset: Glocken Nr fehlt",NR,Date())
          Result = 0 
          Break
        EndIf 
        Pos + p 
        *GlockenAdresse = SucheGlocke(G) 
        If *GlockenAdresse = -1
          AddFehler("GlockenStartOffset: Glocke "+Str(G)+" nicht definiert",Nr,Date())
           Result = 0 
          Break
        Else 
          If Mode = #hot
            InserIO(StartZeit+Gesamtwarten,*GlockenAdresse)
            Insert = 1
          EndIf   
          PushListPosition(GlockenDef())
          ChangeCurrentElement(GlockenDef(),*GlockenAdresse)
          MaxLaufzeit = Max(GlockenDef()\Gesamtzeit+Gesamtwarten,MaxLaufzeit)        ; Glocke einfügen und neue Startzeit ermitteln 
          PopListPosition(GlockenDef())
        EndIf 
      Case "W"
        Pos + 1
        P = ParseInt(Mid(InStr,Pos),@W)
        If Not P 
          AddFehler("GlockenStartOffset: W (Warte) Parameter fehlt",Nr,Date())
          Result = 0 
          Break
        EndIf 
        Pos + P 
        Gesamtwarten + W                
      Default 
        AddFehler("GlockenStartOffset: Parameter nicht erkannt",Nr,Date())
        Result = 0 
        Break
    EndSelect        
  Wend   
  
  If Result = 0 
    If Insert = 1 
      DeleteElement(IO())
    EndIf 
    ProcedureReturn 0
  EndIf 
  
  If ListSize(IO())
    SortStructuredList(IO(),#PB_Sort_Ascending,OffsetOf(IO\Zeit),#PB_Integer)                                 ; suche das Früheste Zeitereignis
    FirstElement(IO())                                                                                        ; Gehe auf das erste Ereignis
    w = (IO()\Zeit)*-1                                                                                        ; Addiere die Maximale negtive Zeit dazu , dann wird alles ab Null
    ForEach IO()                                                                                              ; Hol die Maximale Zeit und mach die Positiv    
      IO()\Zeit + W                                                                                           ; Addiere die Maximale Zeit dazu , dann wird alles ab Null
    Next IO()
  EndIf  
    ;  hier stehen alle Ereigniss zu Ihremm Zeitpunkt InStr der Liste .....
  ProcedureReturn 1
  
EndProcedure

Procedure.i GlockenDuplizierer(*S,Nr.i)
  Protected.i i,Links=1,Rechts,Loops,P,ok=1
  Protected.s Dup,InStr,OutStr
  
  
  InStr = PeekS(*S)  
 
  While FindString(InStr,"{")
    Links = FindString(InStr,"{")
    Rechts = FindString(InStr,"}",links)
    If Rechts = 0 
      AddFehler("GlockenDuplizierer: } fehlt",Nr,Date())
      OK =0
      Break
    EndIf 
    
    P = ParseInt(Mid(InStr,Links+1),@Loops)
    If P
      Dup = ""
      For I = 1 To Loops
        Dup + Mid(InStr,links+1+P,Rechts-Links-2)
      Next I  
      OutStr = ReplaceString(InStr,Mid(InStr,Links,Rechts-Links+1),Dup)
      InStr = OutStr
    Else 
      AddFehler("GlockenDuplizirer:  Multiplikator fehlt",Nr,Date())
      OK = 0 
      Break
    EndIf 
  Wend 
  
  If OK                          ; wenn alles OK ist schreiben wir um 
    PokeS(*S,InStr)  
  EndIf 
  
  
  ProcedureReturn ok
  
EndProcedure

Procedure CheckDoit(Zeile.s,nr.l,Datum.d)
  Protected Result = 1
  
  If CountString(Zeile,"(") = 0 
    AddFehler("ParseLine: Kein Befehl gefunden",Nr,Date())
    Result =0
  EndIf 
  
  If CountString(Zeile,"(") <> CountString(Zeile,")")
    AddFehler("ParseLine:  ( )  Anzahl Ungleich",Nr,Date())
    Result =0
  EndIf 
  
  If CountString(Zeile,"{") <> CountString(Zeile,"}") 
    AddFehler("ParseLine: { } Anzahl Ungleich ",Nr,Date())
    Result =0
  EndIf 
    
  If CountString(Zeile,"<") <> CountString(Zeile,">") 
    AddFehler("ParseLine: < > Anzahl Ungleich",Nr,Date())
    Result =0
  EndIf 
  
  ProcedureReturn Result
EndProcedure

Procedure SplitPos(S.s)
  Protected Pos
  Pos = FindString(S,"(")
  If FindString(S,"{") > 0 
    Pos = min(Pos,FindString(S,"{"))
  EndIf 
  If FindString(S,"<") > 0
    Pos = min(Pos,FindString(S,"<"))
  EndIf   
EndProcedure

Procedure ParseZeile(Zeile.s,Datum.d,Nr.i,Mode.i)
  Protected.i Result=1,Pos
  Protected.s Links,Rechts
  Protected DummyGlocke.Glocken
  Protected *Doit
  
  With DummyGlocke                                               ; Gleich mal anlegen auf immer 
    \Jahr=-1:\Monat=-1:\Tag=-1:\Stunde=-1:\Minute=-1
  EndWith
  
  Result = CheckDoit(Zeile,Nr,Datum)                             ; mal grob cheken ob alle Klammern da sind 
   
  If Result                                                      ; Wenn ja 
     Zeile = Replace(Zeile,Date())                               ; und ersetzen alle Platzhalter incl Ostern und bewegliche feiertage 
     Result  = GlockenMath(@Zeile,NR)                            ; und rechnen auch noch gleich alles durch 
  EndIf 
  
  If Result                                                      ; wenn nach dem Mathe noch alles ok ist 
    If SplitPos(Zeile) > 1                                       ; haben wir einen CRON teil drinnen oder nicht 
      Result = ParseCron(Left(Zeile,Pos),@DummyGlocke,Nr)        ; Schauen wir die Zeit nach 
    EndIf 
  EndIf 
  
  If Result 
    Rechts = Mid(Zeile,SplitPos(Zeile))
    Result = GlockenDuplizierer(@Rechts,Nr)                      ; Jetzt noch duplizieren und gut 
  EndIf 
  
  If Result 
    Result =GlockenMachen(@Rechts,Nr,Mode)                        ; Checkt oder macht die Glocken jetzt InStr IO 
  EndIf 
  
  If (Mode = #hot) And Result
    GlockenMachenMitZeit()
  EndIf 
    
  ProcedureReturn Result
EndProcedure

Procedure GlockenLesen(Datei.s,Datum.l,Mode.i)
  Protected.i File  ,Nr,Result
  Protected.s Zeile
  
   File = ReadFile(#PB_Any,Datei,#PB_Ascii)  
   If Not File 
     ProcedureReturn -1
   EndIf
   
   Nr=0
   
   While Not Eof(File)
     Zeile = Trim(UCase(ReadString(File,#PB_Ascii)))
     Debug Zeile
     If Left(Zeile,1) = ";"                                ; Kommentar entfernen 
       Zeile = ""
     EndIf  
     Nr+1
     If Zeile <> ""
       Zeile = RemoveString(Zeile," ")  
       If Not ParseZeile(Zeile,Datum,Nr,Mode) 
         Result = -1
       EndIf   
     EndIf 
   Wend 
   CloseFile(File)
   
   If Result = - 1 
     ProcedureReturn -2
   Else   
     ProcedureReturn ListSize(Glocken()) 
   EndIf  
EndProcedure


Global L.s,Eingabe.s


Debug GlockenDefLesen("Glockendef.txt")
ErrorDisplay(1) 
 


Eingabe = "{<102-100>(G1G2)}{3(G2W200G1)}"
Debug GlockenMath(@Eingabe,1)
Debug Eingabe

Debug GlockenDuplizierer(@Eingabe,1)
Debug Eingabe
ErrorDisplay(1) 

Debug GlockenMachen(@Eingabe,1,#Dry)
Debug GlockenMachenString()
Debug GlockenMachenMitZeit()
Debug GlockenMachenMitZeitString()








;Debug Glockenlesen("Crontab.txt",Date(),1)

ErrorDisplay(1)


While (1=1)
 Delay(10)
Wend

STARGÅTE · Beitrag von **STARGÅTE** » 04.03.2019 20:50

Zeile 601:

Code: Alles auswählen

  If OK                          ; wenn alles OK ist schreiben wir um 
    PokeS(*S,InStr)  
  EndIf

Das *S ist ja ein Pointer und kommt von ja von einem String.
Du darf jetzt aber nicht einfach an diesen Ort deinen "eigenen" String schreiben.
Denn dein neuer String ist ja länger:

Code: Alles auswählen

Vorher :{2(G1G2)}{3(G2W200G1)}
Nachher :(G1G2)(G1G2)(G2W200G1)(G2W200G1)(G2W200G1)

Was du machen kannst (um ein String in deiner Procedure zu bearbeiten), ist folgendes:

Code: Alles auswählen

Procedure ChangeMyString(*S.String) ; Parameter als *S.String definieren
	*S\s = "Neuer langer String" ; Änderung über das Feld
EndProcedure

Define MyString.String ; Beachte hier, das es nicht .s ist, sondern .String, also eine Struktur mit einem String


MyString\s = "Hallo" ; String über das Strukturfeld bearbeiten
Debug MyString\s

ChangeMyString(@MyString) ; An Prozedur senden

Debug MyString\s ; String ist sauer geändert worden

Joshua314 · Beitrag von **Joshua314** » 05.03.2019 12:25

Danke Stargate,

das wars... Die Auswertung läuft .....
Ich mach gerade noch ein paar Änderungen, dann geht mit der Hardwareweiter.

Ziel vom Ganzen.
http://www.reimlingen.de

Rathaus der Gemeinde oben in der Mitte .. Diese Uhr...

Danke noch mal
Thomas

Beitrag von **Kiffi** » 05.03.2019 12:31

Joshua314 hat geschrieben:Ziel vom Ganzen.
http://www.reimlingen.de

Rathaus der Gemeinde oben in der Mitte .. Diese Uhr...

Schönes Projekt!

Joshua314 · Beitrag von **Joshua314** » 06.03.2019 23:11

Dann Dazu noch ein paar Bilder.

Bild

Simulator für die Uhr
Bild

Treiber auf dem Tisch
Bild

Schaltschrank wo alle rein muss
Bild

Programm wo der der PARSER dank eurer Hilfe läuft

Der Motor läuft.
Die Zeiger fahren
Referenzfahrt geht
Zielfahrt Uhrzeit geht

Jetzt sind eben die Glocken Drann

PureBoard

Code stürtzt laufend ab.....

Code stürtzt laufend ab.....

Re: Code stürtzt laufend ab.....

Re: Code stürtzt laufend ab.....

Re: Code stürtzt laufend ab.....

Re: Code stürtzt laufend ab.....