Bascom BASCOM ; Erste Schritte zum Ausprobieren

Hast du doch quasi alles schon.
Wenn Timer2 Compare Match eintritt (Hardware Interrupt), dann
Wenn Cnt einen gewissen Wert überschreitet, dann
Rufe Tick_1s auf und setze Cnt auf 0

Und was ist Hz? Impulse pro Sekunde.
Dein Timer zählt schon die Impulse. Jetzt muss er nur noch passend zurück gesetzt werden.
In der Tick_1s nach der Ausgabe einfach Timer1 = 0
 
Also Taster drücken (auch mehrmals pro Sekunde), danach geht wieder zurück auf Null.
Ich hatte bei Ontimer1: das Timer1 = 0 rein geschrieben, war natürlich falsch.
 
So soll es sein, also der Frequenzzähler läuft :)
Gibt jetzt nur 3 Probleme zum finalen Produkt:
  1. Die internen 8MHz sind nicht grade genau. Lösung: Externer (Uhren)Quarz. Hatten wir schon. Das interne RC Glied ist eher ein Schätzeisen.
  2. Obwohl der Chip mit 8MHz Takt um die 3MHz erfassen könnte, sind wir jetzt auf 65535Hz limitiert (Maximalwert von Timer1).
  3. Bei sehr niedrigen Frequenzen (wie 1Hz) ist die Auflösung zu gering, da nur in 1Hz Schritten gemessen wird.
Da Problem 1 externe Hardware voraussetzen würde kümmern wir uns mal um 2.
Schon eine Idee wie man die Auflösung, also den Maximalwertes des Timers erhöhen könnte?
Den Timer1 Overflow ISR habe ich bewusst drin gelassen, wenn auch leer, also inaktiv.
 
Ich hatte in #544 schon einmal nach der Hardware gefragt. Den Uhrenquarz müsste ich bestellen, die anderen habe ich da. Aber warum den Waximalwert erhöhen, wenn die Rede von einem Uhren Quarz war, der nur ein paar Kiloherz hat.
 
Der sollte auch nicht als Systemtakt dienen sondern als genauer Takt für Timer2, der die Sekundenimpulse auslöst ;)
Für das bissl interne Rechnerei reicht der interne RC Oszillator aus (~8MHz).
Oder du taktest den Timer2 synchron (wie jetzt, also abhängig von der CPU Clock). Geht auch. Dann könnte man, wenn man möchte, bis zu 20MHz hoch gehen (bei 5Vcc), macht ungefähr 8MHz maximale Eingangsfrequenz.

Uhrenquarz nimmt man wegen der Eigenheit dass er den "krummen" Wert 32,768kHz hat. Krumm ist der aber nicht, aus digitaler Sicht. Rechne die Zahl mal /256 und /128, du kommst genau auf 1. 256 ist der Überlauf von 8 Bit Timern, und Timer2 kannst du einen Prescaler von 128 einstellen. Keine Rechnerei mehr, keine Zählerei in Software...
Du nutzt also dann 2 Takte. Den (nur) für Timer 2 und die interne für den Rest.
 
Da wir zwei Timer benutzen könnte man beim höchstwert des ersten Timers ein Überlauf zum zweiten Timer auslösen, der dann weiter zähl usw. Das wäre nur so meine erste Idee.
 
Prinzipiell ja, aber wir benutzen die 2 Timer ja schon. Timer2 anfummeln wär böse, verändert unsere schöne Zeitbasis. Timer1 zählt ja die Flanken, ist also auch tabu. Ok, wir hätten jetzt noch den 8bittigen Timer0 übrig. Könnte man rein theoretisch nutzen. Einen Nutzen hast du davon allerdings nicht, die lassen sich nicht direkt vernetzen.

Jetzt ist es ja so, dass der Timer1 nur hoch zählt, bis er irgendwann überlaufen würde. Das passiert wenn man beim vollem UInt16 - aka Word - noch 1 hinzufügt. Wert ist wieder 0. Daher das Limit auf 65535Hz.
Aber: Der Timer hat ja einen Interrupt wenn er überläuft.
Und: Du kannst Variablen deklarieren.
Also kannst du auch die Anzahl der Überläufe zählen.
Erstell also einen weiteren Software Zähler, also eine Variable. Byte reicht eigentlich aus, damit landen wir bei >16MHz Auflösung, deutlich über 3 also, mach trotzdem mal als Word.
Die muss jetzt bei Überlauf des Timers erhöht werden, und natürlich mit genullt werden wenn du es beim Timer auch machst.
Für die Ausgabe beide Werte (Zähler und Timerwert) multiplizieren*.

*) Das geht anders noch um Längen eleganter, aber so geht es auch und ist leichter zu verstehen.
 
die lassen sich nicht direkt vernetzen.
Heini, halt Dir mal kurz die Ohren... äh … Augen zu...
Der erste Timer könnte 'ne PWM erzeugen, der PWM-Ausgang auf den Takteingang des zweiten Timers geschaltet werden, welcher dann als Counter läuft.
Wäre zwar nicht ganz direkt, da 'ne externe Brücke nötig wär, aber...
(sowas ähnliches hatten wir Doch mal bei irgend'nem Frequenzteiler-Projekt hier irgendwo - war das nicht auch von Dir?)
 
Jepp, war mein Projekt, was zu geschätzt 90% du umgesetzt hast ;)
Tuts auch ganz gut, wenn man von Kontaktproblemen auf dem alten Breadboard mal absieht. Muss da noch mal n PCB zu zeichnen und ordern.
Auf die Idee wäre ich nie gekommen.
Aber, das geht für Anfänger etwas zu weit ;)
 
Du solltest doch weg gucken ^^
So weit sind wir noch lange nicht. Das war nur unter uns 2 ;)

Und noch leichter geht kaum. Außer fertigen Quelltext zu servieren. Aber du musst es ja verstehen, von Copy&Paste lernt niemand.
Abgesehen vom multiplizieren hast du alles schon gemacht und es steht alles bereits im Code drin.
 
Kein Ding, wirst du schon hin bekommen.

Und frag immer wenn du etwas nicht verstehst.
Hier lacht dich niemand aus! Aber wenn du was nicht verstanden hast und es verheimlichst, dann beißt es dich später.
 
Hatten wir schon mal vor ein paar Seiten. UInt16 ist die gängige Bezeichnung, Bascom verwendet noch die Alte, also hier Word.
Es definiert die Bitbreite und den Inhalt der Variable.

1 hinzufügen.
Wert = Wert + 1

Oder (falls Bascom es unterstützt):
Wert += 1

Oder:
Incr Wert

Alles macht genau das Selbe.
 
UInt16 ist eine gängige Bezeichnung in Assembler oder allgemein und bedeutet einfach Word.
Wert = Wert + 1
und Incr Wert ist ein und das selbe. Ok, wieder etwas, was ich noch nicht wusste. Damit kann ich, denke mal, umgehen.
 
UInt16, fast. Nicht für Assembler, aber für neuere Dialekte, wie VisualBasic.Net (womit ich arbeite), C#, C++, ...
Bascom nutzt noch die alten Namen.

Warum ich das so schreibe ist einfach: Es verhindert Missverständnisse.
Beispielsweise gab es früher, zu MS-DOS und Windows <95 Zeiten VisualBasic. Dort wurden auch Variablen mit einem Bezeichner, wie Integer, deklariert. Das war aber eine 16 Bit Sprache, also ist Integer auch 16 Bit breit. Danach kam ja irgendwann das .Net Framework. Jetzt war Integer aber auf einmal 32 Bit breit. Kannst du jetzt mit Word usw. fortsetzen. Daher gebe ich es lieber explizit an, statt Namen zu nennen. Grade bei älterem Code (der immer noch im Netz krusiert) führt das extrem schnell zu Fehlern und Verwirrungen.

Aber ja, UInt16 ist ein Word.
Int16 ist ein Integer
und jetzt müsste ich nachschaun ^^
Aber ich hatte ja mal eine Tabelle verlinkt.

Edit: Nur in Bascom!
 
Timer0 soll die Überläufe (Overflow) von Timer1 zählen. Also bei 65535 erfolgt ein Overflow, den soll Timer0 erfassen.
Das heißt dann Incr Overflow von Timer1. Aber wie wird das in Bascom geschrieben?
 
Du brauchst dafür keinen weiteren Hardware Timer. Deklariere einfach eine weitere Zählervariable.
Hatte ich ja schon gespoilert.
 

Ü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)