Bascom BASCOM ; Erste Schritte zum Ausprobieren

Ich könnte ein paar Großaufnahmen machen, wenn es Dir etwas nützt.
Vcc und AVcc sind direkt miteinander verbunden (d.h. der digitale Teil des Controllers stört seinen eigenen Analogteil - idealerweise sollte man AVcc über einen L-C-Tiefpaß (oder zumindest einen R-C-Tiefpaß) ("Windkessel") mit Vcc verbinden.
Also unter Umständen leidet die Genauigkeit des Analogteils.. aber sonst kein Problem.

Schlimmer ist, daß Aref auch direkt auf Vcc verbunden ist (vor allem, weil das auch überhaupt keinen Sinn macht - AVcc kann auch intern auf den ADC gekoppelt werden, wenn nötig. Alternativ eben eine der internen Referenzen, oder eben wenn irgend'ne exotische Referenz benötigt wird, diese extern).

Wenn aber eine interne Referenz verwendet werden soll, liegt diese auch an Aref an (um da mittels Kerko gepuffert zu werden) - da liegen hier aber von außen Vcc drauf - die schwache interne Referenz versucht also Vcc auf 2,56V oder 1,1V oder was auch immer runterzuzwingen.

Diesen Quark hab ich das erste mal bei irgend'nem Pollin-Experimentierboard gesehen - ob die das selbst verzapft haben, oder auch irgendwo abgekupfert, weiß ich nicht - jedenfalls machen viele den Mist nach...

Der Quarz scheint fest mit den beiden XTAL-Pins verbunden und auch verlötet zu sein - bei vielen Anwendungen wird das möglicherweise nicht stören, aber die beiden Beine könnten auch einen asynchronen Takt für Timer2(?) bereitstellen - mittels präzisem 32kHz-Uhrenquarz oder sowas. Für 8MHz reicht auch der interne R-C-Oszillator - Mega48/88/168 können aber auch schneller...
 
Also Pwm1a habe ich jetzt eingegliedert. Die Grüne Led blinkt weiterhin. Wie gesagt, mit der Pwm1b komme ich nicht klar.


CodeBox BascomAVR
$regfile = "m8def.dat"                  'Controllerdefinitionsdatei einbinden
$crystal = 8000000                      'Systemtakt angeben (Baudrate)
$hwstack = 40                           'Stacks
$swstack = 16
$framesize = 32
$baud = 19200                           'Baudrate UART

Dim Zeichen As Byte                     'UART-Empfang
Dim Z As Byte                           'Timerüberlaufzähler
Dim Poti As Word                        'ADC-Messung
Dim Fla As Byte
Dim Pause As Byte
Dim Pausex2 As Byte
Dim Tov1cnt As Byte


Rot Alias Portd.7                       'Namen für LED-Beine
Gruen Alias Portc.3
Config Rot = Output                     'Ausgänge
Config Gruen = Output
Rot = 1                                 'LEDs erstmal an
Gruen = 1

'Phasenkorrekter 8-Bit-PWM, PWM-Frequenz=245Hz
Config Timer1 = Pwm , Prescale = 64 , Compare A Pwm = Clear Down , Compare B Pwm = Clear Down

Pwm1b = 100
'ADC aktivieren (single conversion, Prescaler Auto, AVcc (INTERN!!!)
Config Adc = Single , Prescaler = Auto , Reference = Avcc

Do                                      'Hauptschleife Begin
   'erstes Teilprogramm - UART Empfang und auswerten
   If Ischarwaiting() = 1 Then          'Wenn Zeichen Empfangen
      Zeichen = Inkey()                 'dann Zeichen aus Puffer lesen
      If Zeichen = "1" Then             'Wenn Zeichen = "1"
         Rot = 1                        '...
         Print "Led An"
      Elseif Zeichen = "0" Then         'Wenn Zeichen = "0"
         Rot = 0                        '...
         Print "Led Aus"
      Elseif Zeichen = "t" Then         'Wenn Zeichen = "t"
         Toggle Rot                     '...
         Print "Toggle Led"
      Elseif Zeichen = "?" Then         'Wenn Zeichen = "?"
         If Rot = 0 Then                'Dann wenn Led aus ist...
            Print "Led ist aus"
         Elseif Rot = 1 Then            'sonst wenn Led an ist...
            Print "Led ist an"
         End If
      Elseif Zeichen = 0 Then           'bei 0x00 PWM deaktivieren
         Config Timer1 = Pwm , Prescale = 64 , Compare A Pwm = Disconnect , Compare B Pwm = Disconnect
      Elseif Zeichen = 255 Then         'bei 0xFF PWM aktivieren
         Config Timer1 = Pwm , Prescale = 64 , Compare A Pwm = Clear Down , Compare B Pwm = Clear Down
      Else
         Pwm1b = Zeichen                'sonst PWM1B zuweisen
      End If
   End If

   'zweites Teilprogramm - LED durch timer blinken lassen
   If Tifr.tov1 = 1 Then                'wenn Timer übergelaufen ist
      Set Tifr.tov1                     'Überlaufflag zurücksetzen
      Incr Tov1cnt                      'überlaufzähler inkrementieren
      If Pause = Tov1cnt Then     'entspricht dem 2ten "waitms pause"
         Fla = Rnd(200)
         Fla = Fla + 55
         Pwm1a = Fla
      End If

      Incr Z
      If Z = 245 Then                   'Überläufe zählen (245)
         Z = 0                          'Zähler zurücksetzen
         Toggle Gruen                   'LED toggeln
      End If
   End If
Loop
 
Zuletzt bearbeitet:
erstens darf in Zeile 55 PWM1B nicht mehr manipuliert werden (auskommentieren)
zweitens hast Du nur den Halben Flackercode aus #21 übernommen...
 
zweitens hast Du nur den Halben Flackercode aus #21 übernommen...
Da habe ich #297 nicht richtig gelesen. Jetzt habe ich alles so, wie es sein soll (denk ich mal). Hab auch gleich mal ne RGB Led angschlossen.
Das Flackerlicht, die Rote Led, beides auch mit der Steuerung über's Terminal (Rot mit 0,1,t und ?) (Pwm mit 0 und 255).


CodeBox BascomAVR
$regfile = "m8def.dat"                  'Controllerdefinitionsdatei einbinden
$crystal = 8000000                      'Systemtakt angeben (Baudrate)
$hwstack = 40                           'Stacks
$swstack = 16
$framesize = 32
$baud = 19200                           'Baudrate UART

Dim Zeichen As Byte                     'UART-Empfang
Dim Z As Byte
Dim Fla As Byte
Dim Pause As Byte
Dim Pausex2 As Byte
Dim Tov1cnt As Byte


Rot Alias Portd.7                       'Namen für LED-Beine
Gruen Alias Portc.3
Config Rot = Output                     'Ausgänge
Config Gruen = Output
Rot = 1                                 'LEDs erstmal an
Gruen = 1

'Phasenkorrekter 8-Bit-PWM, PWM-Frequenz=245Hz
Config Timer1 = Pwm , Prescale = 64 , Compare A Pwm = Clear Down , Compare B Pwm = Clear Down

Pwm1b = 100
'ADC aktivieren (single conversion, Prescaler Auto, AVcc (INTERN!!!)
Config Adc = Single , Prescaler = Auto , Reference = Avcc

Do                                      'Hauptschleife Begin
   'erstes Teilprogramm - UART Empfang und auswerten
   If Ischarwaiting() = 1 Then          'Wenn Zeichen Empfangen
      Zeichen = Inkey()                 'dann Zeichen aus Puffer lesen
      If Zeichen = "1" Then             'Wenn Zeichen = "1"
         Rot = 1                        '...
         Print "Led An"
      Elseif Zeichen = "0" Then         'Wenn Zeichen = "0"
         Rot = 0                        '...
         Print "Led Aus"
      Elseif Zeichen = "t" Then         'Wenn Zeichen = "t"
         Toggle Rot                     '...
         Print "Toggle Led"
      Elseif Zeichen = "?" Then         'Wenn Zeichen = "?"
         If Rot = 0 Then                'Dann wenn Led aus ist...
            Print "Led ist aus"
         Elseif Rot = 1 Then            'sonst wenn Led an ist...
            Print "Led ist an"
         End If
      Elseif Zeichen = 0 Then           'bei 0x00 PWM deaktivieren
         Config Timer1 = Pwm , Prescale = 64 , Compare A Pwm = Disconnect , Compare B Pwm = Disconnect
      Elseif Zeichen = 255 Then         'bei 0xFF PWM aktivieren
         Config Timer1 = Pwm , Prescale = 64 , Compare A Pwm = Clear Down , Compare B Pwm = Clear Down
      'Else
         'Pwm1b = Zeichen                'sonst PWM1B zuweisen
      End If
   End If

   'zweites Teilprogramm - LED durch timer blinken lassen
   If Tifr.tov1 = 1 Then                'wenn Timer übergelaufen ist
      Set Tifr.tov1                     'Überlaufflag zurücksetzen
      Incr Tov1cnt                      'überlaufzähler inkrementieren
      If Pause = Tov1cnt Then           'entspricht dem 2ten "waitms pause"
         Fla = Rnd(200)
         Fla = Fla + 55
         Pwm1a = Fla
      End If
      If Pausex2 = Tov1cnt Then         'entspricht dem ersten "waitms pause"
         Pwm1b = 255 - Fla
         Pause = Rnd(10)
         Pause = Pause * 6
         Pausex2 = Pause
         Shift Pausex2 , Left           'pausex2=pause*2
         Tov1cnt = 0
      End If

      Incr Z
      If Z = 245 Then                   'Überläufe zählen (245)
         Z = 0                          'Zähler zurücksetzen
         Toggle Gruen                   'LED toggeln
      End If
   End If
Loop

Jetzt müsste die Zeit- oder halt die Helligkeitssteuerung kommen.
 
Zuletzt bearbeitet:
Jetzt müsste die Zeit[…]steuerung kommen.
Die Idee wäre, jedes "andere" Zeichen (also in Zeile 54) jetzt als Aufforderung zu interpretieren, die Kerze für genau soviele Sekunden anzuzünden, und danach wieder auszupusten.
Wie Du anzündest und auspustest weißt Du, Sekunden generiert das zweite Teilprogramm (die grüne LED wird nur jede Sekunde getoggelt, also der toggle-Befehl nur einmal pro Sekunde ausgeführt).

Was noch fehlt ist also lediglich ein Software-Countdown. (Byte Variable)

Konkreter:
Wann soll die Kerze angezündet werden? Wenn dieses andere Zeichen empfangen wurde - dann muß außerdem der Countdown-Zähler mit dem Wert (also dem Zeichen) geladen werden.
Wann dekrementiert der Countdown? Jede Sekunde einmal.
Wie auch die grüne LED toggelt
Wann soll die Kerze ausgeblasen werden? Immer dann, wenn der Zähler beim dekrementieren null wird (also nach dem dekrementieren gleich null ist)
 
Was noch fehlt ist also lediglich ein Software-Countdown. (Byte Variable)
Einen Countdown kenne ich nur auf diese Weise

CodeBox BascomAVR
If Flag = 1 Then
      For I = 1 To 10
         Rot_6 = Ein
         Waitms 100
         Rot_6 = Aus
         Wait 10
      Next I
      Flag = 0
   End If

Das ist halt wieder eine Variante mit Wait Befehlen, die wir nicht verwenden wollen.
Wenn ich die Zeit der Toggle LED vergrößern will, müsste ich die Z Variable als Word deklarieren. Aber auch dann komme ich nicht auf größere Zeitabstände.
wenn ich Zeile 76 bis 80 in die Zeile 54 kopiere, die ich mit einer anderen LED anschließe, passiert überhaupt nichts.
Ich stehe wieder mal auf dem Schlauch.
 
Du hast doch eine Routine, also einen Teil deines Programms, was 1x die Sekunde ausgeführt wird. Jetzt brauchst du eigentlich nur noch einen Zähler und musst zählen.
Also in diesem Teilprogramm Zähler = Zähler + 1. Und dann prüfen ob (sagen wir) Zähler >= 50 ist (der gewählte Zeitpunkt zum Abschalten. Wenn ja dann abschalten, sonst nichts machen.)
Beim Starten sicher stellen dass Zähler = 0 ist.

Das was du geschrieben hattest ist wieder blocking, hält also den Controller davon ab andere Dinge zu tun, nicht nur wegen der Waits, auch weil der ganze Prozess geschleift wird. Aber das hast du ja schon richtig erkannt :)
 
Du trennst das anzünden und das ausblasen.
Angezündet wird, wenn das Zeichen empfangen wurde (das sonst keine andere Funktion hat, also im else-Block des UART-Teilprogrammes).
Der Wert dieses Zeichens soll außerdem festlegen, wieviele Sekunden bis zum ausblasen vergehen sollen. Ich würde von diesem Wert aus herunterzählen lassen.
Du brauchst also eine weitere Zählvariable, die hier (im else-Block nach dem Kerzenanzünden) den Wert von Zeichen zugewiesen bekommt.

Das ausblasen erfolgt im "Grüne-Led-blinkt"-Teilprogramm, genauer erst da, wo auch die LED getoggelt wird. Dieser Code wird ja exakt einmal pro Sekunde ausgeführt.
Dort soll aber nicht einmal pro Sekunde ausgepustet werden - Du willst ja erstmal x Sekunden warten.
Also dekrementierst Du dort (einmal pro Sekunde) Deine neue Zählvariable und schaust danach, ob sie gleich null ist. Ist das der Fall, läßt Du die Kerze auspusten (sonst tust Du nichts).

Daß die Kerze so alle 256 Sekunden ausgepustet wird ist klar - folgt im nächsten Schritt
 
Angezündet wird, wenn das Zeichen empfangen wurde (das sonst keine andere Funktion hat, also im else-Block des UART-Teilprogrammes).
Also Angezündet wird sie mit
Elseif Zeichen = 255 Then 'bei 0xFF PWM aktivieren Config Timer1 = Pwm , Prescale = 64 , Compare A Pwm = Clear Down , Compare B Pwm = Clear Down
Ich weiß nicht, wie ich eine Zählervariable einbringen kann.
 
Ist doch nichts anderes als du es in #304 Zeile 8..13 gemacht hast.
Du brauchst nur eine weitere Variable als Zähler.
Da definierst du den Speicherplatz (und den Namen dafür - Vorsicht mit Umlauten, kA ob Bascom das kann, ist aber eh ein No-Go.).

Jetzt scheiden sich die Geister, du könntest entweder hoch, oder runter zählen, im Endeffekt kommt es aber auf das Selbe hinaus.
Beim Start schaltest du an und setzt den Zähler auf den Startwert (0 für hoch zählen, Endwert für runter zählen). In dem Teil "pro Sekunde" erhöhst bzw. verringerst du um 1 und prüfst dann auf den Grenzwert (Endwert beim hoch zählen, 0 beim runter zählen). Wenn getroffen, dann aus.
 
Das mit der Variable hab ich schon verstanden, aber im UART Block wird alles mit If Zeichen abgefragt und funktioniert nur in Verbindung mit dem Terminal.
Das anschalten der Kerze soll ich doch im ersten Teilprogramm ausführen, oder liege ich jetzt falsch?
 
Das anschalten der Kerze soll ich doch im ersten Teilprogramm ausführen,
Ja, der Schnipsel in #309 schaltet die Kerze dauerhaft ein, wenn 'ne '255' empfangen wurde.
Im auskommentierten Else-Teil hatten wir vorher KanalB zugewiesen, da soll jetzt auch angezündet werden, zusätzlich soll dort der Countdown (die neue Zählvariable) geladen werden. Eben mit dem wert des empfangenen Zeichens.

Das dekrementieren und überprüfen ob dabei null erreicht wurde, geschieht im zweiten Teilprogramm - in dem Teil, der jede Sekunde einmal dran ist. Wie das toggeln der grünen LED.
 
Also mit Zeichen anzünden geht. Nun muss ich nur noch eine Zeitverzögerung berechnen.
Frage: Wenn ich jetzt die Zählervariable runter zählen lasse (z.B. 50), mit welcher Zeit (Sekunden) kann ich damit rechnen oder welchen Rechnung muss ich ausführen?
 
Zuletzt bearbeitet:
Nehmen wir an, Du hast 'ne 217 empfangen - das erste Teilprogramm stellt also fest, das was im Empfangspuffer liegt (Ischarwaiting()), liest die 217 raus, und verleicht sie nacheinander mit seinen ganzen Kommandos. Da keins zutreffend ist, wird der else ("sonst")-Bereich ausgeführt.
Dort zündest Du also die Kerze an, und belädst Deinen Countdown (die Zählvariable) mit dem wert des empfangenen Zeichens.
Zwei Zeile Bascom-Code.
Erster Teil fertig.

Zweiter Teil:
Du hast einen Code-Bereich, der jede Sekunde genau einmal ausgeführt wird, nämlich der, wo die grüne LED getoggelt wird. Dort dekrementierst Du einmal den Countdown (nach 217 Sekunden wurde der Code also 217mal ausgeführt; der Countdown ist dann also bei null angekommen). Danach prüfst Du (also) ob der Countdown gleich null ist, ist das der Fall, bläst Du die Kerze aus.
Vier Zeilen Bascom-Code.
Fertig.
 
Dort zündest Du also die Kerze an
mit Config Timer1 = Pwm , Prescale = 64 , Compare A Pwm = Clear Down , Compare B Pwm = Clear Down
Wenn ich ASCII Zeichen 217 bzw. 0xD9 eingebe, passiert nichts mehr.
Im Kopf habe ich Dim Zaehler As Byte und Zaehler = 50
weiter komme ich halt nicht, da ich keine Vorstellung habe wie diese Schreibweise ausgeführt wird. Im Internet sehe ich nur Beispiele mit Interrupts oder irgendwelche vergleichbare Anwendungen mit Wartezeiten, die wir hier ja vollkommen ausschließen wollen.
 
Nur zu Interrupts:

Im Moment nutzt du Polling. Du hast eine Anwendungsschleife die konstant durchläuft. Darin sind Teilprogramme die nur dann ausgeführt werden wenn eine Bedienung erfüllt ist (IsCharWaiting, Tifr.tov1 = 1, ...). Wenn nichts davon erfüllt ist startet die Schleife von vorne und fragt wieder den Zustand ab (=Polling, also abfragen / ziehen des Zustandes). Sorgt aber auch für 100% CPU Last und somit hohen Stromverbrauch*.

Bei Interrupts ist es fast das Selbe, nur dass du nicht abfragst sondern Routinen hast die automatisch aufgerufen werden, von der Hardware. Deine Hauptschleife, da gibt es 2 Möglichkeiten.
Möglichkeit 1:
Du behandelst alles in der Interrupt Routine selbst, also alles was dann ausgeführt werden soll.
Das hat aber Nachteile sollte hier viel (zeitintensiver) Code laufen, wie z.B. Schreiben auf ein LCD. Es kann nur ein Interrupt gleichzeitig arbeiten (nicht ganz richtig, reicht aber erst mal). Beispiel, dein ADC hat einen neuen Wert fertig, Interrupt läuft, schreibt auf ein LCD. Aber währenddessen treten 20 Timer Events auf. Blöd, weil die verpasst du währenddessen.
Möglichkeit 2:
Du setzt in der Interrupt Routine nur ein Flag, welches in der Hauptschleife abgefragt wird. Dort, also losgelöst vom Interrupt, wird dann der Code ausgeführt. So würde der ADC Code in der Hauptroutine (unterbrechbar) ausgeführt werden und den Timer nicht beeinflussen.

Wie auch immer, wenn man mit Interrupts arbeitet nutzt man auch den Sleep Befehl. Damit wird die CPU schlafen gelegt wenn die Hauptschleife fertig ist. Geweckt wird er wieder durch Interrupts. Es wird also nach Sleep weiter gearbeitet.

Allerdings bleibt der Code selbst größtenteils gleich, er ist nur anders angeordnet.

*hoher Stromverbrauch ist bei AVR's natürlich relativ zu sehen, aber bei batteriegetriebenen Anwendungen ist das durchaus relevant.
 
Du erinnerst Dich an das Echo-Programm irgendwann am Anfang?
Im Kopf habe ich Dim Zaehler As Byte
Ja, wobei der Name jetzt nicht viel über die Funktion der Variable aussagt. Ich hätte sie Countdown genannt...
Nein, nicht im Kopf sondern nach Empfang des Zeichens, was kein anderes Kommando ist, also im Else-Teil von Teilprogramm-1.
Und Du willst da keine fixen 50 zuweisen, sondern eben das was empfangen wurde, also Zeichen...


CodeBox BascomAVR
Countdown = Zeichen  'Startwert fue Contdown laden
 
:offtopic:
Möglichkeit 2:
Du setzt in der Interrupt Routine nur ein Flag, welches in der Hauptschleife abgefragt wird
Wobei das (auch wenns oft angewendet wird) nicht immer unbedingt Sinn macht. Statt in der ISR ein weiters Flag zu setzen, und dieses im Hauptprogramm zu pollen, kann man auch gleich (wie hier) im Hauptprogramm das Interrup-Flag pollen.
Sinniger ist dann, zB beim UART gleich auf relevante Zeichen zu filtern, und das via Flag zu melden.
Du weißt sicher, was ich meine...
 
:offtopic:
Jepp, weiß ich. Würd aber am Anfang zu weit gehen, schätze ich :)
Allerdings mache ich es tatsächlich selbst so. Ein IRQ Byte wo die ISR die Bits setzt und die Main Loop diese abfragt und auswertet. Das IRQ Byte ist etwas was ich selbst definiert habe, das bleibt immer gleich. Ich müsste nur die ISR's anpassen, sollte sich hardwareseitig was ändern (z.B. von Timer 0 auf Timer 2). Klar, geht auch anders, viele Wege führen nach Rom.
 
Das mit dem Countdown hab ich jetzt gelöst. Läuft wie ein Uhrwerk, wenn die Grüne LED ganz genau im Sekundentakt blinkt.
Das anschalten im UART-Teilprogramm habe ich so wie in #314 und #317 beschrieben ist geändert. Leider tut sich da auch nichts.

CodeBox BascomAVR
$regfile = "m8def.dat"                  'Controllerdefinitionsdatei einbinden
$crystal = 8000000                      'Systemtakt angeben (Baudrate)
$hwstack = 40                           'Stacks
$swstack = 16
$framesize = 32
$baud = 19200                           'Baudrate UART

Dim Zeichen As Byte                     'UART-Empfang
Dim Z As Byte
Dim Fla As Byte
Dim Pause As Byte
Dim Pausex2 As Byte
Dim Tov1cnt As Byte
Dim Countdown As Byte


Rot Alias Portd.7                       'Namen für LED-Beine
Gruen Alias Portc.3
Config Rot = Output                     'Ausgänge
Config Gruen = Output
Rot = 1                                 'LEDs erstmal an
Gruen = 1

'Phasenkorrekter 8-Bit-PWM, PWM-Frequenz=245Hz
Config Timer1 = Pwm , Prescale = 64 , Compare A Pwm = Clear Down , Compare B Pwm = Clear Down

Pwm1b = 100
'ADC aktivieren (single conversion, Prescaler Auto, AVcc (INTERN!!!)
Config Adc = Single , Prescaler = Auto , Reference = Avcc

Do                                      'Hauptschleife Begin
    'erstes Teilprogramm - UART Empfang und auswerten
   If Ischarwaiting() = 1 Then          'Wenn Zeichen Empfangen
      Zeichen = Inkey()                 'dann Zeichen aus Puffer lesen
      If Zeichen = "1" Then             'Wenn Zeichen = "1"
         Rot = 1                        '...
         Print "Led An"
      Elseif Zeichen = "0" Then         'Wenn Zeichen = "0"
         Rot = 0                        '...
         Print "Led Aus"
      Elseif Zeichen = "t" Then         'Wenn Zeichen = "t"
         Toggle Rot                     '...
         Print "Toggle Led"
      Elseif Zeichen = "?" Then         'Wenn Zeichen = "?"
         If Rot = 0 Then                'Dann wenn Led aus ist...
            Print "Led ist aus"
         Elseif Rot = 1 Then            'sonst wenn Led an ist...
            Print "Led ist an"
         End If

      Elseif Zeichen = 0 Then           'bei 0x00 PWM deaktivieren
         Config Timer1 = Pwm , Prescale = 64 , Compare A Pwm = Disconnect , Compare B Pwm = Disconnect
      Elseif Zeichen = 255 Then         'bei 0xFF PWM aktivieren
         Config Timer1 = Pwm , Prescale = 64 , Compare A Pwm = Clear Down , Compare B Pwm = Clear Down

      Elseif Zeichen = 217 Then         '0xD9
         Countdown = 217                'belädst Deinen Countdown (die Zählvariable) mit dem wert des empfangenen Zeichens
      End If
   End If

   'zweites Teilprogramm - LED durch timer blinken lassen
   If Tifr.tov1 = 1 Then                'wenn Timer übergelaufen ist
      Set Tifr.tov1                     'Überlaufflag zurücksetzen
      Incr Tov1cnt                      'überlaufzähler inkrementieren
      If Pause = Tov1cnt Then           'entspricht dem 2ten "waitms pause"
         Fla = Rnd(200)
         Fla = Fla + 55
         Pwm1a = Fla
      End If
      If Pausex2 = Tov1cnt Then         'entspricht dem ersten "waitms pause"
         Pwm1b = 255 - Fla
         Pause = Rnd(10)
         Pause = Pause * 6
         Pausex2 = Pause
         Shift Pausex2 , Left           'pausex2=pause*2
         Tov1cnt = 0
      End If

      Incr Z
      If Z = 245 Then                   'Überläufe zählen (245)
         Z = 0                          'Zähler zurücksetzen
         Toggle Gruen                   'LED toggeln

         Incr Countdown
         If Countdown = 60 Then
            Config Timer1 = Pwm , Prescale = 64 , Compare A Pwm = Disconnect , Compare B Pwm = Disconnect
         End If
      End If
   End If
Loop
 

Über uns

  • Makerconnect ist ein Forum, welches wir ausschließlich für einen Gedankenaustausch und als Diskussionsplattform für Interessierte bereitstellen, welche sich privat, durch das Studium oder beruflich mit Mikrocontroller- und Kleinstrechnersystemen beschäftigen wollen oder müssen ;-)
  • Dirk
  • Du bist noch kein Mitglied in unserer freundlichen Community? Werde Teil von uns und registriere dich in unserem Forum.
  •  Registriere dich

User Menu

 Kaffeezeit

  • Wir arbeiten hart daran sicherzustellen, dass unser Forum permanent online und schnell erreichbar ist, unsere Forensoftware auf dem aktuellsten Stand ist und der Server regelmäßig gewartet wird. Auch die Themen Datensicherheit und Datenschutz sind uns wichtig und hier sind wir auch ständig aktiv. Alles in allem, sorgen wir uns darum, dass alles Drumherum stimmt :-)

    Dir gefällt das Forum und unsere Arbeit und du möchtest uns unterstützen? Unterstütze uns durch deine Premium-Mitgliedschaft!
    Wir freuen uns auch über eine Spende für unsere Kaffeekasse :-)
    Vielen Dank! :ciao:


     Spende uns! (Paypal)