Den Frequenzzähler mit LCD Display auf der Platine aufgebaut.

Ich habe den Frequenzzähler auf einer 4 x 6 cm großen Platine aufgebaut. Mit einer Sockelleiste wird das 1602 LCD Display drauf gesteckt. Die Stromversorgung wird an den Klemmen mit 5V herausgeführt. Hier kommt auch das Frequenz-Signal rein.

Basierend auf diesen vorherigen Artikeln wird nun alles zusammengeführt.
– Frequenzzähler Teil 1 & Teil 2
– LCD Display Teil 1 & Teil 2
Arduino Uno als ISP
Ein Frequenzzähler für niedrige Frequenzen …

Frequenzzähler auf der Platine

Die Materialiste.

1 x Lochrasterplatine ca. 4 x 6 cm
1 x 26-poliger IC Sockel
1 x 16 polige Sockelleiste die Aufnahme des LCD Displays
1 x LCD Display 1602 mit 4-Bit Ansteuerung
1 x 16-polige Stiftleiste für das LCD Display
1 x 16MHz Quarz
2 x 15pF Kondensatoren SMD
1 x 100 Ohm Widerstand
1 x 1k Ohm Widerstand
1 x 5k Ohm Drehwiderstand
1 x 10uF Tantal Kondensator
1 x 4-polige Schraubklemme
1 Rolle Fädeldraht lötbar (ich verwende 0,28mm Material lackiert)

Alles zusammen für ca. 10-15 Euro Materialwert.

Frequenzzähler auf der Platine

Nun zur Aufbaubeschreibung.

1. Als erstes werden in die Ecklöcher der Lochraster Platine 3mm Schrauben eingesetzt mit Muttern. Sie schauen unter raus und sind die Standfüße. Damit liegt die Platine nicht wackelig auf dem Tisch und es kann kein Kurzschluß durch herumliegende Metallteile (Drähte) entstehen.

2. Das LCD Display bekommt eine 16-polige Stiftleiste

3. Die 16-polige Sockelleiste wird an den Rand der Platine gesetzt, sodaß das LCD Display später direkt über der Platine liegt.

4. Der 28-polige Sockel für den ATMEGA328P-PU wird aufgelötet.

5. Der 16MHz Quarz wird an die IC-Pins 9 und 10 gelötet. Zwei Kondensatoren mit 15pF werden von den Pins an Masse gelegt.

xtal-arduino

6. Zur Stabilisierung der Spannungsversorgung wird ein 10nF Tantal ELKO an die Pins 7 (+) und 8 (-) gelötet.

7. Der Kontrast-Regelwiderstand wird aus einem 1kOhm Widerstand und einem 4,7kOhm Trimm-Widerstand aufgebaut. Eine kleine senkrechte Bauform ist später leichter von der Seite einzustellen, ich hatte aber nur einen liegenden Widerstand in der Kiste.

8. Es kann noch ein 6-poliger Programmier-Stecker aufgelötet werden. Ich habe mich später aber entschieden den ATMEGA328 auf dem Steckbrett zu programmieren. Daher ist er vorhanden, wird hier aber nicht verwendet.

9. Die 4-polige Schraubklemme wird an den Rand gesetzt.
Die Belegung von links nach recht:
– 1 frei, hier kann eine 9 oder 12v Stromversorgung angeschlossen werden. Dazu ist aber noch ein 5V Regler auf dem Board notwendig. Platz ist noch vorhanden.
– 2 Versorgungsspannung + 5V
– 3 Masse Versorgungsspannung und Signal
– 4 Signaleingang zum Vorverstärker

10. Daneben sitzt der Eingangsverstärker Transistor. Die Widerstände und der Eingangskondensator sind unter der Platine in SMD Bauform verlötet. Aufbau wie hier, nur habe ich einen 2,2uF Kondensator im Eingang verwendet. Der Ausgang geht auf PIN 11.

11. Der Kathoden Anschluß der LCD Beleuchtung (LCD -) bekommt noch einen 100 Ohm Widerstand gegen Masse.

12. Nun werden alle Anschlüsse nacheinander mit Fädeldraht verbunden und verlötet. Hierfür habe ich gut 1m verbraucht. Erst die Display Verbindungen und dann die Stromversorgung

Hier die Display Verbindungen.

Von der LCD Sockelleiste geht es direkt zum entsprechenden 328 IC Pin. Die Arduino Uno Bezeichnungen sind hier auch noch erwähnt weil das für die Entwicklung auf den Steckbrett wichtig war.

LCD > Arduino > 328 IC 28DIL Gehäuse
————-
VSS > GND > P8
VDD > +5V > P7
V0  > 5k Poti + 1kOhm Widerstand > GND
RS  > Pin 12 > P18
R/W > Pin 13 > P19
E   > Pin 11 > P17
D4  > Pin 7 > P13
D5  > Pin 8 > P14
D6  > Pin 9 > P15
D7  > Pin 10 > P16
A   > +5V
K   > 100 Ohm Widerstand > GND

Frequenzzähler auf der Platine

Die Software

// Arduino 328 Frequenzzähler auf Platine 
// von 1 Hz bis ca. 5 MHz
// > 900 Hz Eingangsspannung muss an Pin 5 mit ca. 5V Pegel ankommen.
// < 1000 Hz Eingangsspannung muss an Pin 5 mit ca. 5V Pegel ankommen.
// V 1.2: 1602 Display hinzugefügt
// V 2.0: niedrige Frequenzen hinzugefügt
// V 2.41: hohe Frequenzen umgeschieben und lcdOut() hinzugefügt
// V 2.42: FreqCounter Library wieder genommen
// V 2.43: auf Nano 328 angepasst
// V 2.44: auf Platine 328 + NPN Emitter Schutzschaltung
//
// Stromaufnahme incl. Display Beleuchtung 28mA
// Messbereich bis ca. 5 MHz, je nach Symmetrie des Signals (max. 8 MHz) 
// Messsignal Amplitude min. 100mV SS
// Eingangsschaltung: 2uF + BE-Strecke ( NPN 0,7V )
//
// Matthias Busse 16.11.2014 Version 2.44

// http://interface.khm.de/index.php/lab/experiments/arduino-frequency-counter-library/
#include < FreqCounter.h>

#include 
LiquidCrystal lcd(12, 13, 11, 7, 8, 9, 10);
/* LCD Display Anschlüsse:
LCD > Arduino > 328 IC 28DIL Gehäuse
-------------
VSS > GND > P8
VDD > +5V > P7
V0  > 5k Poti + 1kOhm Widerstand > GND
RS  > Pin 12 > P18
R/W > Pin 13 > P19
E   > Pin 11 > P17
D4  > Pin 7 > P13
D5  > Pin 8 > P14
D6  > Pin 9 > P15
D7  > Pin 10 > P16
A   > +5V
K   > 100 Ohm Widerstand > GND 

Frequenz Messeingang 
> 2uF > BC547B NPN Emitterschaltung > P11, beim 328 28DIL Gehäuse 

Messbereich bis ca. 5 MHz 
Eingangsamplitude min. 100mV SS */

unsigned long rfreq, mfreq;
int mihz=0, hz=0, khz=0, mehz=0; // mHz, Hz, kHz und MHz je 3 Ziffern
char sfreq[15];                  // sfreq=Stringfrequenz
static int schnell=0;            // > 1kHz = 1
static int slgrenze=2000;        // schnell / langsam Grenze
double sum=0, mfrequency, rfrequency;
int count=0;

// langsam
int k=0,pin=5;
unsigned long T;     // Periodendauer in us
double fsum=0.0;     // Summieren
double f=0;          // Frequenz in MHz 
unsigned long time;  // Startzeit

void setup() {
  pinMode(pin, INPUT);
//  Serial.begin(38400);               // Serielle Ausgabe
  lcd.begin(20,4);
  lcd.clear();
  lcd.setCursor(0,0);
  lcd.print("Frequenz Zaehler");
  lcd.setCursor(0,1);         // Display ausgeben
  lcd.print(" MBS  Ver. 2.44 ");
  // 2 Sekunden wegzählen, da die ersten beiden Messungen eh murks sind.
  FreqCounter::f_comp=120;   // Cal Wert
  FreqCounter::start(1000);  // 1 s Gate Time
  while (FreqCounter::f_ready == 0) 
  mfreq=FreqCounter::f_freq;
  FreqCounter::f_comp=120;   // Cal Wert
  FreqCounter::start(1000);  // 1 s Gate Time
  while (FreqCounter::f_ready == 0) 
  mfreq=FreqCounter::f_freq;
  schnell=0;
  if(mfreq > slgrenze) schnell=1;
}

void loop() {
  if(schnell==1) {
    FreqCounter::f_comp=120;   // Cal Wert
    FreqCounter::start(1000);  // 1 s Gate Time
    while (FreqCounter::f_ready == 0) 
    mfreq=FreqCounter::f_freq;
    lcdOut((double)mfreq);
    if(mfreq < (slgrenze*0.97)) {                   // auf langsam umschalten
      schnell=0;
    }
  } // if (schnell==1)
  else { // langsam
    time=micros();
    do {
      T = pulseIn(pin, HIGH) + pulseIn(pin, LOW);
      if (T==0) {
//        Serial.println("Timeout.");
      }
      else {
        f=1/(double)T;        // f=1/T   
        k++;    
      }  
      fsum+=f*1e6;
    } while( micros() < (time+1e6)); // 1 Sekunde mitteln
    mfrequency = fsum/k*0.9925;
    lcdOut(mfrequency);
    fsum=0.0;
    k=0;
    if(mfrequency > (slgrenze*1.03)) {
      schnell=1; 
    }
  } // else langsam */
} // loop

void lcdOut(double f) {
// Frequenz formatiert ausgeben
// auf dem 16x2 LCD Display 
//
// Matthias Busse Version 1.0

int nachkomma=0;
unsigned long rf;

  rf=(unsigned long)f*1000;
  if((f-(int)f) > 0.005) { // Nachkommastellen
    rf=(unsigned long)(f*1000);
    nachkomma=1;
    mihz = rf-(int(rf/1000)*1000);
    rf=(rf-mihz)/1000;  
  }
  rf=(unsigned long)f;
  hz = rf-(int(rf/1000)*1000);
  rf=(rf-hz)/1000;
  khz = rf-(int(rf/1000)*1000);
  rf=(rf-khz)/1000;
  mehz = rf-(int(rf/1000)*1000);
  if(f >= 1000000.0) {sprintf(sfreq," %3d %03d %03d Hz",mehz,khz,hz);}
  if((f > slgrenze)&& (f<1000000.0)) {sprintf(sfreq,"     %3d %03d Hz",khz,hz);}
  else if((f >= 1000.0) && (f<1000000.0)) {sprintf(sfreq," %3d %03d,%03d Hz",khz,hz,mihz);}
  if((f>=1.0) && (f < 1000.0)) {sprintf(sfreq,"     %3d,%03d Hz",hz,mihz);}
  if(f < 1.0) {sprintf(sfreq,"       0,%03d Hz",hz,mihz);}
  lcd.setCursor(1,1);         // Display ausgeben
  lcd.print("                ");
  lcd.setCursor(1,1);
  lcd.print(sfreq); 
}

Die IC Programmierung.

Nach der Programmentwicklung auf dem Steckbrett wurde der ATMEA238P-PU Chip vom Uno aus programmiert wie in diesem Artikel beschrieben und dann auf die Platine gesteckt.

Der erste Test

Alle Verbindungen werden überprüft und durchgeklingelt. Nachbar Lötpads werden auf Isolation überprüft. Dann kann es los gehen.

5V werden angeschlossen. Die Schaltung läuft und die Stromaufnahme ist ca. 28mA, alles OK.

Frequenzzähler auf der Platine

Mit einem Frequenzgenerator werden die Grenzen ermittelt.

Die Eingangsspannung sollte mindestens 100mV Spitze-Spitze betragen, dann werden Frequenzen bis zu ca. 5MHz gemessen, abhängig von der Symmetrie. Theoretisch sind sogar 8MHz (halbe Taktfrequenz ) möglich.

von Matthias Busse

Ein Nachtrag: Der Frequenz Messfehler liegt bei ca. 60ppm also in der 4. oder 5. Stelle der angezeigten Frequenz bei den verwendeten Standard Bauteilen. Für eine genauere Messung der Frequenz kann dieses Uhrzeit Modul mit eingebunden werden. Dadurch kann der Fehler der Messung kleiner 3ppm werden und liegt damit an der 5. oder 6. Stelle der Frequenz.

9 Gedanken zu „Den Frequenzzähler mit LCD Display auf der Platine aufgebaut.

  1. Pingback: Frequenzzähler mit LCD Display am Arduino Uno. | Shelvin – Elektronik ausprobiert und erläutert

  2. Pingback: Der Frequenzgenerator und Frequenzzähler | Shelvin – Elektronik ausprobiert und erläutert

  3. Pingback: Ein simpler Rechteckgenerator mit dem Arduino | Shelvin – Elektronik ausprobiert und erläutert

  4. jgr

    Hallo,

    sehr gute Darstellung. Ist es möglich ein Schaltbild zu bekommen?
    Dann könnte man besser erkennen, wie die beiden 15nF Kondensatoren und der 100 Ohm Widerstand
    eingebaut wurden.
    Vielen Dank vorab.
    Viele Grüße
    JGR

    Antworten
  5. admin Beitragsautor

    Ich habe das Bild für die Standard Quarz Beschaltung eingefügt.
    Der 100 Ohm Widerstand ist für die LCD Beleuchtung und wird von LCD- (Kathode der LED Beleuchtung) zu Masse geschaltet.

    Antworten
  6. Werner

    Schöner Artikel. Inzwischen gibt es ja arduinoartige Boards mit ESP8266 die mit 80 MHz getaktet werden. Das müßte doch wesentlich höhere Grenzfrequenzen ergeben. Schon probieert?

    Gruß aus München
    Werner

    Antworten
    1. admin Beitragsautor

      Damit sollte es dann bis 30 MHz funktionieren.
      Theoretisch liegt die maximal meßbare Frequenz bei der halben Taktfrequenz wenn das Meßsignal symetrisch ist. In der Praxis ist das aber nicht sicher erreichbar, 1/3 ist da realistisch.

      Antworten
  7. Pingback: Den Arduino Quarztakt auf 3ppm genau bestimmen mit der DS3231 RTC | Shelvin – Elektronik ausprobiert und erläutert

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.