Bascom BASCOM ; Erste Schritte zum Ausprobieren

[TommyB]

Soweit richtig, hat aber Nachteile.
Du setzt immer das ganze Register, musst also z.B. bei DDRx beachten ob nicht vorher schon was gesetzt war, oder eben nicht.
Richtig wäre:
1) Register laden
2) Bits setzen / löschen, je nach Bedarf. And löscht, Or setzt.
3) Register zurück schreiben
Oder einfach Bascom's Config Port / Pin nutzen.
Oder man weiß genau was man tut, was bei komplexeren Programmen aber nahezu unmöglich ist, zumindest wenn man nach ein paar Monaten noch was anpassen muss und sich erst wieder stundenlang reindenken muss.

Und warum die Aufgabe, das hast du dir grade selbst beantwortet. Das ist ein Fehler den du schon öfters gemacht hast, du liest nicht richtig.

... Ja, ne, ich meine was wäre die maximale Zeitspanne die du erreichen könntest...

Jetzt frag dich mal ob das so ganz ohne Vorteiler auch das maximalste ist

Preload ist Glücksache wenn der wirklich 100% exakt ist.
Warum?
Du hast nur eine CPU. Einen "Task" der arbeiten kann. Und der durchläuft entweder deine Main Loop, oder kümmert sich grade um den aufgetretenen Interrupt.

Preload bekommst du ja einen Interrupt wenn der Timer überläuft, dann musst du ihm den Wert geben, und zwar schnellstmöglich! Weil der Timer zählt gnadenlos weiter. Vielleicht bist du zu langsam und der Timer hat mittlerweile schon bis 100 gezählt, dann bist du halt 100 Takte daneben.
Das ganze wird umso schlimmer je höher der Reload Wert und desto niedriger der Prescaler ist, weil du so immer weniger Zeit hast. Dazu kommt dass du ja in der CPU Rechenregister hast, die müssen bei jedem Interrupt gesichert und nachher wiederhergestellt werden. Sonst könnte er nach dem Interrupt nicht so da weiter machen wo er vorher aufgehört hat. Da gehen schon einige Taktzyklen verloren. Du merkst davon nichts, Bascom kümmert sich darum, die Takte sind trotzdem verbraten.
Und wenn du jetzt noch andere Interrupts ebenfalls verwendest (normalerweise kann immer nur einer laufen) und du in einer ISR noch etwas zeitintensives machst (wait, lcd, langsames uart, ...) dann wird es erst richtig lustig. Daher, wenn irgendwie möglich, die Hardware alles machen lassen.
CTC hast du das Problem nicht, da setzt du das Maximum fest, welches deswegen so hoch wie möglich sein kann (umso genauer kannst du ihn einstellen).

 

[Heini-14]

Mit dem Preloader hast Du schon Recht. Ich habe zum testen eine for Schleife benutzt, wobei nichts weiter drin war, als die Zeit abzuzählen und dann die LED anzuschalten. Diese ging natürlich mit einem externen Quarz auf die Sekunde genau. Ebend, weil der µC nichts andres zu tun hatte.

Soweit richtig, hat aber Nachteile.

Meinst Du die Zeit 83,89ms.
Und dann kommt es schon wieder

• 1) Register laden
• 2) Bits setzen / löschen, je nach Bedarf. And löscht, Or setzt.
• 3) Register zurück schreiben

Immer wieder diese Schreibweise, genau wie in den Datenblättern, weshalb ich nichts davon verstehe. Und deshalb habe ich mich ein bisschen damit befasst und bin dabei auf verschiedene Seiten geraten, die immer wieder mit Registern und Bit's Erklärungen stattfinden.

Eigentlich suchte ich etwas, wie man Taster druck länge (nur ein Taster) auswerten und für bestimmte Anwendungen nutzen kann. Wie Taster 500ms drücken -> LED an PORTx an. Taster 1000ms drücken -> LED an PORTy an usw.

 

[TommyB]

Du hast ja in Bascom aber Befehle dafür, du musst dich da nicht so drum kümmern.
Was du aber wissen solltest, ist, wie du heraus findest welche Hardware der Chip hat (z. B. 3 Timer), welche Funktionen die bieten, und welche Prescaler auswählbar sind. Wie die genau gesetzt werden müssen ist hier ja egal, wird dir abgenommen. Das ist ja der Vorteil an Hochsprachen.

Und klar, die Hauptsprachen für die Käfer sind entweder Assembler oder C. Bascom und Luna sind eher Randerscheinungen, Bascom vor allem auch weil das nicht grade kostenlos ist.

Das mit de Dauer wie lange ein Taster gedrückt ist ist ja ein rein logisches Problem. Und hier heißt es dass viele Wege zum Ziel führen.
Das Grundprinzip hatten wir aber schon.
Du willst ja wissen wie lange der Taster gedrückt wurde. Also brauchst du logischerweise eine Zeitbasis. Die muss ja jetzt nicht ultra präzise sein, ob es nun 100ms oder 110ms sind fällt kaum auf. 500 und 1000ms... Müsste der Taster also für die Dauer von 5 oder 10 Timerüberläufen gedrückt bleiben.
Timer, Variablen und dessen Zuweisung, Incr, Select Case, all das hatten wir alles schon. Du musst eigentlich nur noch erkennen wann und wie lange der Taster gedrückt wurde. Einen dedizierten Befehl gibt es hierfür nicht, da ist nur logisches Denken gefragt.

 

[Heini-14]

Ok, Du hast meine Überlegungen bestätigt, indem ich eine Zeitbasis brauche.
Also eine Zeitbasis und eine Verzweigung mit

• Do-Loop
• While-Wend
• If-Then-Else
• GOTO oder
• GOSUB/RETURN

mach ich mir morgen Gedanken. Jetzt muss ich erst einmal meinen Arm wieder zur Ruhe legen.

 

[LotadaC]

@I2cdelay:

In Beitrag #749 schrieb ich schon, daß der PCF8574 nur 100 kHz kann und nicht 1 MHz, wie mit der obigen Zeile eingestellt wird.

Und da sind wir wieder beim Dokumentationsproblem:
1. in der Standard-Bibliothek sind für I²C Routinen angelegt, die das ganze in Software umsetzen (link)
2. es gibt eine (mMn kostenpflichtige oder nur in der Vollversion nutzbare) einbindbare Bibliothek, die Hardware-I²C unterstützt, und die Funktionen der Standard-Bibliothek ersetzt (wird vor der Standard-Lib durchsucht)
3. I2cdelay greift laut Online-Hilfe nur bei Software-Routinen.
4. Für Soft-I²C existiert eine verbesserte (Start/Stop-Conditions oder so) Bibliothek.
5. Neben den Routinen I2cwbyte und I2crbyte gibts noch I2csend und I2creceive, welche automatisch die Adresse (als 8-Bit Adresse mit LSB=0) erwarten

Nun gings ja eigentlich nicht um I²C selbst, sondern um ein LCD.

6. Bascom's Standard-Lib stellt Routinen zur Ansteuerung parallel angebundener Displays bereit.
7. außerdem zwei kompaktere Bibliotheken (statt flexibler Beinwahl fixe Zuweisungen), die mit einer oder zwei Enable-Leitungen arbeiten.

Das verwendete (parallele) Display ist aber an einen I²C-Portexpander angeschlossen - für den Controller handelt es sich also um ein seriell über I²C angebundenes Display.

8. Dafür gibts die lcd-i2c.lib Bibliothek von Kent Andersson (leider grad keine Quelle, aber Cassio hat sich hier ja mal umfangreich damit beschäftigt).
Hier findet man dazu:

Kent Andersson geht bei seiner Library von folgender Verbindung zwischen PCF-Baustein und Display aus:

P0 -> D4
P1 -> D5
P2 -> D6
P3 -> D7
P4 -> RS
P5 -> RW (not used, set to 0 to ground for write)
P6 -> E2 (on 1 or 2 line display nc)
P7 -> E1(=E)

9. wurde in einem der letzten Code-Schnipsel irgend'ne "Yrobot-Bibliothek" eingebunden - das "Yrobot-Display" ist laut obiger Quelle wie folgt verdrahtet:

Die Zusatzplatine von YwRobot benutzt aber folgende Zuordnung:

P0 -> RS
P1 -> RW
P2 -> E
P3 -> BT (Backlight)
P4 -> D4
P5 -> D5
P6 -> D6
P7 -> D7

Fazit:

Wurde denn überhaupt mal abgeklärt, wie das Display mit dem PCF verdrahtet ist? (Bevor wild irgendwelche Bibliotheken drauf losgelasen werden)
AFAIR hat Cassio in seinem Thread 'ne modifizierte Version der Kent Andersson Bibliothek (selbstgeschrieben??), die variable Zuweisung der Beine erlaubt.

 

[Heini-14]

Wurde denn überhaupt mal abgeklärt, wie das Display mit dem PCF verdrahtet ist?

Soweit ich das auf der I2C Platine erkennen kann, ist es so wie auf der YwRobot verbunden.
Ich habe sämtliche Bibliotheken, Datenblätter und Beschreibungen duchgekaut. Zumindestens habe ich es versucht, soweit ich diese verstehen kann. Doch leider verstehe ich von Protokollen, Bus und Bibliotheken rein gar nichts. Deshalb habe ich aufgegeben. Selbst die Anleitung von Cassio (ohne Bibliotheken) haben keinen Erfolg gebracht. Es ist nur Schade, dass ich damals als alles mit Arduino funktionierte, mir ein vier Zeilen I2C Display mir zulegte.
Wie gesagt, "Schuster bleib bei deinen Leisten", altes Sprichwort.
Danke für Deine Mühe, aber ich kann nicht mehr.

 

[TommyB]

Das liegt daran weil du grade mal Laufen konntest, aber gleich los gesprintet bist. Nu bist du gestolpert, war klar. Aufstehen und weiter machen, nur halt nicht so schnell.
Die paralelen Displays tun's ja erst mal auch. Und um etwas zu lernen ist eine "BlackBox", wo man nicht weiß was drin ist, das denkbar schlechteste.
N BreadBoard, n paar Kabel, paar Widerstände, nen I2C Port Expander oder besser 2, paar Taster und LEDs zum rum basteln. Alles nicht so teuer, vielleicht um die 10€ incl. Versand. Wesentlich sinnvoller als im Dunkeln rum zu stochern.

 

[Heini-14]

N BreadBoard, n paar Kabel, paar Widerstände usw.

Davon hab ich mehr als genug. Ich meine damit, mehr als man zum programmieren braucht. Na ja, ne kleine Werkstatt. Nur diesen Kabelsalat mag ich nicht. Deshalb wollte ich auch das I2C Display benutzen. Hab ja auch nen normales Display auf Platine mit nen Mega8 verlötet + Taster an PB0 und einen Poti für die Hintergrundbeleuchtung.
Wie gesagt, möchte ich jetzt erst einmal den Taster (einen Taster) für zwei bis drei LED's (an/aus) benutzen.

 

[TommyB]

Denn nutz das als Start. Da weißt du wenigstens was du hast. 2x PCF8574, damit kann man zum lernen schon viele schöne Sachen mit machen.
Wegen dem Taster, ich warte auf die ersten Ansätze.
Und verlass dich mal auf dich selbst, nicht auf irgendwas aus dem Netz. Selber Essen macht fett, selber denken schlau

 

[Heini-14]

2x PCF8574, damit kann man zum lernen schon viele schöne Sachen mit machen.

Was meinst Du damit?

 

[TommyB]

Das sind I2C Port Expander. Klemmst du am I2C Bus an und hast 8 weitere I/O Leitungen (pro Chip).

Führt man es auf die Spitze, es gibt den Chip in 2 Editionen. Eigentlich der gleiche Chip, intern nur eine andere Adresse (du kannst A0..A2 selber festlegen, A3 wird durch die Chipversion intern festgelegt). Davon könnte man also bis zu 16 gleichzeitig betreiben (2x - also Normale- und A Version, davon je max. 8 Stück). Und die sind extrem simpel, die geben das aus was du sendest, respektive anders herum.

Beispiel Modelleisenbahn. Du müsstest nur 3-4 Leitungen verlegen (Clock, Data, GND und +5V, falls du letzteres nicht besser irgendwo vor Ort bekommen kannst). und hättest bis zu 2(wegen Hardware Adresse)x8(3 Adressleitungen)x8(Bit pro Byte), also 128 Signale die du steuern und/oder auswerten könntest. Klar, vom IC zu der Ampel oder der Weiche, was auch immer, muss einzeln verlegt werden, aber halt nur bis zum PCF, nicht Querfeldein durch die ganze Anlage.

Noch extremer, es gibt auch Multiplexer, womit man einen I2C Bus auf verschiedene Segmente aufteilen könnte. Abteil Bayern, Niedersachsen, ...Das führt jetzt aber definitiv zu weit. Möglich wäre es aber.

 

[Heini-14]

Mein vorläufiger Entwurf:
Rot = kurzer Tastendruck geht aus, wenn Blau = langer Tastendruck erfolgt.
Blau allerdings geht gar nicht mehr aus.
Es darf geholfen werden. Danke!


CodeBox BascomAVR

$regfile = "m8def.dat"
$crystal = 8000000
$hwstack = 32
$swstack = 32
$framesize = 64
Dim Z As Word
Ddrb = &B0000_0000                      'alle Pin's sind Eingänge
Portb = &B1111_1111                     'alle Eingang mit Pullup (High) konfiguriert
Ddrd = &B1110_0000
Portd = &B0001_1111
'Namen für LED-Beine
Blau Alias Portd.7
Rot Alias Portd.6
Gruen Alias Portd.5
Taster Alias Pinb.0
'Phasenkorrekter 8 -bit -pwm , Pwm -frequenz = 245hz
Config Timer1 = Pwm , Prescale = 64 , Compare A Pwm = Clear Down , Compare B Pwm = Clear Down
Do                                      'Hauptschleife Begin
   If Tifr.tov1 = 1 Then                'wenn Timer übergelaufen ist
      Tifr.tov1 = 1                     'Überlaufflag zurücksetzen
      If Taster = 0 Then
         Incr Z
         If Z < 100 Then
            Rot = 1
            Blau = 0
         Else
            Rot = 0
         End If
         If Z > 100 Then
            Blau = 1
            Rot = 0
         Else
            Blau = 0
         End If
      End If
   End If
Loop                                    'Hauptschleife Ende

 

[TommyB]

Dabei hatten wir es in #573 schon fast fertig.
Und das ganz ohne Polling...

UART und Timer1 brauchen wir hier nicht, könnte raus.
Tick_1s wäre jetzt nur etwas ungünstig, könnte man aber z.B. auf Tick_200mS bringen, man müsste nur eine Zahl ändern.
Sonst... Naja, könnte man so machen (zumindest in Etwa, so geht es ja nicht), anders geht aber eleganter.
Schau dir mal Select Case an.

 

[Heini-14]

Der Tick_1s nur eine Zahl ändern -> ok, auf 200ms geändert.
Select Case habe ich von der Ampel den Teil raus genommen und so sieht er jetzt aus.


CodeBox BascomAVR

Incr Dauer
   Select Case Dauer
      Case 1 : Gruen = 0 : Gelb = 0 : Rot = 1
      Case 3 : Gruen = 0 : Gelb = 1 : Rot = 1
      Case 5 : Gruen = 1 : Gelb = 0 : Rot = 0
      Case 6 : Dauer = 0
   End Select

Aber wo und wie vermittle ich das dem Taster?

 

[TommyB]

Schau dir die Hilfe mal etwas genauer an. Jetzt musst du den Wert ja mit dem Taster genau treffen. Blöd.
Ich gehe davon aus dass Dauer in 200ms Schritten ist:


CodeBox BascomAVR

   Select Case Dauer
      Case 0 To 1 : ' Ignorieren (Taster könnte prellen - vielleicht reicht ein simples 0 (ohne To) schon aus, testen. Dann wäre es dadrunter halt 0 To ...
      Case 1 To 3 : ' Kurz gedrückt (200mS > Dauer < 600mS)
      Case 3 To 5 : ' Länger gedrückt (600mS > Dauer < 1000mS)
      Case Else : ' Sehr lange gedrückt (> 1000mS)
   End Select

Die Zeiten und Aktionen bleiben dir natürlich selbst überlassen.

Dir fehlt aber noch etwas ganz elementares.
Weg von Elektronik zum Praxisbeispiel. Du arbeitest jetzt im Securitygewerbe. Wenn schon sowas nötig ist, dann macht man tendenziell eher ungerne den Tag der offenen Tür. Also ist es wichtig dass du die Tür im Auge behälst. Wann wurde sie geöffnet, wer kam rein, wann wurde sie wieder geschlossen.
Wer jetzt rein kommt vergessen wir mal, das passt als Analogie nicht, aber die Tür als solches sehr wohl.
Wenn die Tür offen ist: gefährlich, Zeit zählen.
Wenn sie geschlossen ist: alles cool.
Ziemlich genau das fehlt noch in deinem Code (oder du hast es nicht mit kopiert).

 

[Heini-14]

Ziemlich genau das fehlt noch in deinem Code (oder du hast es nicht mit kopiert).

Da war nichts mit kopieren von der Ampel. Ich habe lediglich die Schreibweise von Case mit den Aliasen genommen.
Jetzt habe ich den Key mit reingebaut und dann passiert folgendes.
Nach dem flashen geht kurz die Blaue Led an, danach die Grüne. Diese bleibt für ca. eine Minute an und dann geht es wieder von vorn los. Kurz Blau dann Grün.
Das alles ohne einen Taster zu drücken.

CodeBox BascomAVR

$regfile = "m8def.dat"
$crystal = 8000000
$hwstack = 40
$swstack = 16
$framesize = 32
$baud = 19200
'------------------------------------------------------------------------------------
Dim Count As Byte
Dim Dauer As Byte
'------------------------------------------------------------------------------------
' Aliase
Blau Alias Portd.7
Rot Alias Portd.6
Gruen Alias Portd.5
Key Alias Pinb.0
'------------------------------------------------------------------------------------
' Initialisiere Hardware
Init:
   ' Hardware konfiguration
   Ddrb = &B1111_1110
   Portb = &B0000_0001
   'Ddrc = &B__11_1111
   'Portc = &B__00_0000
   Ddrd = &B1111_0111
   Portd = &B0000_1000
'------------------------------------------------------------------------------------
   ' Konfiguration Timer 2 (CTC, 8MHz/256/249 = 8ms)
   Config Timer2 = Ctc , Prescale = 256 , Clear_timer = 1
   Ocr2 = 249                           ' Setze Maximalwert für Timer 2 (CTC)
   On Oc2 Isr_oc2                       ' Setze ISR für Timer 2 Overflow Compare
   Enable Oc2                           ' Aktiviere Timer 2 Overflow Compare Int.
'------------------------------------------------------------------------------------
   ' Konfiguration Watchdog
   Config Watchdog = 2048               ' Setze Watchdog Timeout auf ~2sec
   Start Watchdog                       ' Aktiviere den Wachhund
   Enable Interrupts
'------------------------------------------------------------------------------------
Main:
   ' Den Wachhund zurücksetzen
   Reset Watchdog
   ' Einschlafen (bis zum nächsten Interrupt)
   Config Powermode = Idle
   Goto Main                            ' und zurück
'------------------------------------------------------------------------------------
Isr_oc2:
   ' Erhohe internen Zähler
   Incr Count
   If Count = 25 Then
      Count = 0
      Gosub Tick_200ms
   End If
Return
'------------------------------------------------------------------------------------
Tick_200ms:
   Incr Dauer
   If Key = 1 Then
      Select Case Dauer
         Case 0 To 1 : Gruen = 0 : Blau = 0 : Rot = 0       ' Ignorieren (Taster könnte prellen - vielleicht reicht ein simples 0 (ohne To) schon aus, testen. Dann wäre es dadrunter halt 0 To ...
         Case 1 To 3 : Gruen = 0 : Blau = 1 : Rot = 0       ' Kurz gedrückt (200mS > Dauer < 600mS)
         Case 3 To 5 : Gruen = 1 : Blau = 0 : Rot = 0       ' Länger gedrückt (600mS > Dauer < 1000mS)
         Case Else :                    ' Sehr lange gedrückt (> 1000mS)
      End Select
   End If
Return

 

[TommyB]

55, 56 passt so auch nicht.

Der Taster will bestimmt auf Masse ziehen, du fragst aber ab ob er nicht gedrückt ist, also High.
Daher läuft es immer weiter, ohne dass du was machst.

Außerdem zählst du immer, nicht nur dann wenn die Tür offen ist, also irrelevant ob der Taster gedrückt ist oder nicht.
Irgendwann, wohl nach der Minute, läuft dein Zähler dementsprechend über und es geht wieder bei 0 los.

Du merkst, da ist noch ein Fehler in deiner Logik
Versuch dich in den Chip hinein zu versetzen und geh Schritt für Schritt den Ablauf in Gedanken durch.
Zur Not, es könnte hilfreich sein, wenn du UART wieder einbindest (nur zum Senden), um dir mit ein paar Print (?) Befehlen den aktuellen Status auf dem PC anzeigen zu lassen. Nur zur Fehlersuche und Verständnis, hat hiermit selbst nichts zu tun.

 

[Heini-14]

Änderung ab Zeile 42, Zeile 42 ist jetzt Zeile 6, aber es ist nicht das, was ich wollte. Denn Key drücke:

1. mal -> rot an
2. mal -> Blau an, Rot wieder aus
3. mal -> Grün an, Blau wieder aus
4. mal -> alles aus
5. mal -> passiert nichts mehr, muss erst Reset drücken, dann wieder das Gleiche von vorn an.

Ich wollte, dass nur die Led an geht, die die Millisekunden von Drückdauer erreicht hat. Irgendwo ist noch ein Fehler oder es fehlt noch etwas.


CodeBox BascomAVR

Main:
   ' Den Wachhund zurücksetzen
   Reset Watchdog
   ' Einschlafen (bis zum nächsten Interrupt)
   Debounce Key , 0 , On_key , Sub
   Config Powermode = Idle
   Goto Main                            ' und zurück
'------------------------------------------------------------------------------------
Isr_oc2:
   ' Erhohe internen Zähler
   Incr Count
   If Count = 25 Then
      Count = 0
      'Gosub Tick_200ms
   End If
Return
'------------------------------------------------------------------------------------
Tick_200ms:
   Incr Dauer
   Select Case Dauer
      Case 0 To 1 : Gruen = 0 : Blau = 0 : Rot = 1       ' Ignorieren (Taster könnte prellen - vielleicht reicht ein simples 0 (ohne To) schon aus, testen. Dann wäre es dadrunter halt 0 To ...
      Case 1 To 2 : Gruen = 0 : Blau = 1 : Rot = 0       ' Kurz gedrückt (200mS > Dauer < 600mS)
      Case 3 To 3 : Gruen = 1 : Blau = 0 : Rot = 0       ' Länger gedrückt (600mS > Dauer < 1000mS)
      Case 4 : Gruen = 0 : Blau = 0 : Rot = 0       ' Sehr lange gedrückt (> 1000mS)
   End Select
Return
'------------------------------------------------------------------------------------
On_key:
   If Key = 0 Then
      Gosub Tick_200ms
   End If
Return

 

[TommyB]

Ohje... Das ist ja nun komplett wirr. Jetzt hast du dir dazu noch deine Zeitbasis komplett zerledert...
Taster per Interrupt abzufragen ist auch etwas gewagt, und hier komplett unnötig. Edit: Ok, kein Interrupt, Debounce. Kommt aber aufs Selbe hinaus.

Dabei hatte ich es schon in #795 und #797 veranschaulicht...

Wie wärs damit:


CodeBox BascomAVR

$regfile = "m8def.dat"
$crystal = 8000000
$hwstack = 40
$swstack = 16
$framesize = 32
$baud = 19200
'------------------------------------------------------------------------------------
Dim Count As Byte
Dim Dauer As Byte
'------------------------------------------------------------------------------------
' Aliase
Blau Alias Portd.7
Rot Alias Portd.6
Gruen Alias Portd.5
Key Alias Pinb.0
'------------------------------------------------------------------------------------
' Initialisiere Hardware
Init:
   ' Hardware konfiguration
   Ddrb = &B1111_1110
   Portb = &B0000_0001
   'Ddrc = &B__11_1111
   'Portc = &B__00_0000
   Ddrd = &B1111_0111
   Portd = &B0000_1000
'------------------------------------------------------------------------------------
   ' Konfiguration Timer 2 (CTC, 8MHz/256/249 = 8ms)
   Config Timer2 = Ctc , Prescale = 256 , Clear_timer = 1
   Ocr2 = 249                           ' Setze Maximalwert für Timer 2 (CTC)
   On Oc2 Isr_oc2                       ' Setze ISR für Timer 2 Overflow Compare
   Enable Oc2                           ' Aktiviere Timer 2 Overflow Compare Int.
'------------------------------------------------------------------------------------
   ' Konfiguration Watchdog
   Config Watchdog = 2048               ' Setze Watchdog Timeout auf ~2sec
   Start Watchdog                       ' Aktiviere den Wachhund
   Enable Interrupts
'------------------------------------------------------------------------------------
Main:
   ' Den Wachhund zurücksetzen
   Reset Watchdog
   ' Einschlafen (bis zum nächsten Interrupt)
   Config Powermode = Idle
   Goto Main                            ' und zurück
'------------------------------------------------------------------------------------
Isr_oc2:
   ' Erhohe internen Zähler
   Incr Count
   If Count = 25 Then
      Count = 0
      Gosub Tick_200ms
   End If
Return
'------------------------------------------------------------------------------------
Tick_200ms:
   Print Dauer ' nur damit du mal was siehst was passiert. kA ob Bascom das so frisst, aber du hattest ja mein ich schon mal früher was gesendet.
   If Key = 0 Then ' ##### 0 statt 1! -- Wenn Tür offen
      Incr Dauer ' ##### Nur zählen während gedrückt -- Zeit nur messen wenn Tür offen
      Select Case Dauer
         Case 0 To 1 : Gruen = 0 : Blau = 0 : Rot = 1       ' Ignorieren (Taster könnte prellen - vielleicht reicht ein simples 0 (ohne To) schon aus, testen. Dann wäre es dadrunter halt 0 To ...
         Case 1 To 2 : Gruen = 0 : Blau = 1 : Rot = 0       ' Kurz gedrückt (200mS > Dauer < 600mS)
         Case 3 To 3 : Gruen = 1 : Blau = 0 : Rot = 0       ' Länger gedrückt (600mS > Dauer < 1000mS)
         Case 4 : Gruen = 0 : Blau = 0 : Rot = 0       ' Sehr lange gedrückt (> 1000mS)
      End Select
   Else
      Dauer = 0 ' ##### Taster nicht mehr gedrückt, Dauer zurück setzen -- Tür wieder dicht, alles ok
   End If
Return

 

[Heini-14]

Ok Danke.
Mit Debounce hatte ich den Taster entprellen wollen. Und per Interrupt meinte ich, wäre eine Elegante Lösung.
Jetzt gibt es aber noch ein Problem. Wenn ich nur Grün anschalten will, sollen nicht erst die anderen zwei nacheinander aufleuchten, sondern nur die Grüne beim loslassen des Tasters. Da gibt es glaube ich den Bitwait -Befehl. Der hat aber ein wait drin stehen. Ist das ein warten im Sinne der Wait-Befehle oder kann ich diesen für die Lösung nehmen?