http://sites.schaltungen.at/sie-fahren-km-h/rechtecksignal-ausgeben
http://www.linksammlung.info/
http://www.schaltungen.at/
Wels, am 2015-12-24
BITTE nützen Sie doch rechts OBEN das Suchfeld
[ ] [ Diese Site durchsuchen]
DIN A3 oder DIN A4 quer ausdrucken
*******************************************************************************I**
DIN A4 ausdrucken (Heftrand 15mm / 5mm) siehe
http://sites.schaltungen.at/drucker/sites-prenninger
********************************************************I*
~015_b_PrennIng-a_sie.fahren.km-h-rechtecksignal.ausgeben (xx Seiten)_1a.pdf
Arduino Entwicklungsumgebung IDE ist v1.6.12
Siehe Startseite
303_Arduino-x_Bestimmung der Zählimpulsrate von Geiger-Müller-Sensoren (für Radioaktivität) mit dem ARDUINO_1a.pdf
ARDUINO Rechteckgenerator
// Frequenz-/Rechteckgenerator
#define INLENGTH 5 //maximale Größe der Zahl
#define INTERMINATOR 'H' //'H' von 'Hz'
char inString[INLENGTH+2];
int inCount;
#define MinFreq 33
#define MaxFreq 65535
#define Ausgangspin 13 // pin-13 ist die eingebaute LED, muss kein PWM-Pin sein, besserer ein anderer
unsigned int Frequenz = 100; // 33Hz max. 65,535kHz)
void setup(){
Serial.begin(9600);
Serial.println("Bitte angeben wieviel Hz ausgegeben werden sollen (mit 'Hz')!");
tone(Ausgangspin, Frequenz);
}
void loop(){
Eingabe(); //Eingabe-Funktion, die Eingabe-String entgegennimmt
//Zeichenkette -> Zahl
//Alternative: http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1176289764
Frequenz=atol(inString);
//Bereich prüfen
Frequenz=constrain(Frequenz, MinFreq, MaxFreq);
Serial.print("Es wird gesetzt: ");
Serial.print(Frequenz,DEC);
Serial.println("Hz!");
tone(Ausgangspin, Frequenz);
}
void Eingabe(){
inCount=0; //Ziffern-Zähler rücksetzen
do
{
while (Serial.available()==0);
inString[inCount] = Serial.read();
if(inString[inCount]==INTERMINATOR) break;
if((inString[inCount]<'0')||(inString[inCount]>'9')){
//continue; //geht nicht
inCount--; //-> Workaround
}
}
while(++inCount < (INLENGTH+1));
Serial.flush();
}
http://www.elektronik-labor.de/Arduino/Rechteck.html
AD-Wandler:
–
Den ADS1115 16-Bit AD Wandler am Arduino mit Autorange betreiben
–
MCP4725 12Bit DA Wandler vom Arduino ansteuern
–
Die Auflösung des ADC vom Arduino Uno erhöhen auf 16 Bit mit Oversampling
–
Den 16-Bit AD-Wandler MCP 3426 mit dem Arduino verwenden.
Arduino:
– Arduino serial buffer size ändern
– Vergleich der Stromaufnahme von Arduino Schaltungen, vom Uno bis zum IC im …
– Den Arduino in den Schlaf Modus setzen und wieder aufwecken.
– Ein Batteriemonitor für Strom und Spannung mit dem INA226 und dem Arduino Uno
RTC / Uhrzeit:
– Den Arduino Quarztakt auf 3ppm genau bestimmen mit der DS3231 RTC
– Von der RTC DS3231 die Temperatur auslesen mit dem Arduino
– Rechteck 1Hz (+-2ppm) ausgeben mit dem RTC DS3231 und dem Arduino
– Die Uhrzeit des RTC DS3231 Modul vom Arduino einstellen
– Die Uhrzeit des RTC DS3231 Modul vom Arduino auslesen
– Die Real Time Clock, RTC DS1307 am Arduino Uno betreiben
Interrupts:
– Mit dem Arduino Timer Interrupt eine LED Blinkfolge ausgeben
– Mit dem Timer Interrupt des Arduino die LED blinken lassen
– Eine Taste per Interrupt einlesen und entprellen
– Den Arduino in den Schlaf Modus setzen und wieder aufwecken.
Temperatur:
– Luftdruck und Temperatur als NMEA 0183 Datensatz ausgeben.
– Barometer Display mit 1h / 3h Differenz und Temperatur Ausgabe. Mit dem 5110 Display …
– Luftdruck und Temperatur als NMEA 0183 Datensatz ausgeben.
– Temperatursensor DS18B20 mit dem Arduino Uno Teil 2.
– Temperatursensor DS18B20 mit dem Arduino Uno und LCD Display.
– Der Luftdruck und Temperatur Sensor BMP085 am Arduino Uno.
Servos:
– Servo Pulslänge vom RC Empfänger mit dem Arduino ermitteln
– Servosteuerung mit einem Poti und dem Arduino
– Servo Ansteuerung direkt vom Arduino
Processing Grafik am PC:
– In Processing den COM Port auswählen und Werte vom Arduino einlesen.
– Eine LED mit Processing schalten und den Status zurück bekommen vom Arduino
– Arduino LED mit Processing 3 per Mausklick schalten aus Windows
– Eine Grafik mit Processing ausgeben
– Grafische PC Ausgabe der Arduino Daten mit Processing
FFT – Fast Fourier Transformation:
– Arduino FFT auf dem 5110 Display ausgeben
– Eine Grafik auf dem 5110 LCD Display ausgeben
– Eine einfache FFT – Fast Fourier Transformation – mit dem Arduino Uno
– Teil 2: Kapazitäten von 10nF bis 2000uF einfach messen mit dem Arduino
– Teil 1: Kapazitäten von 1uF – 2000uF einfach messen mit dem Arduino
– Simpler kapazitiver Schalter auf einem beliebigen Arduino Pin
– Mit der 4×4 Folientastatur Zahlen eingeben am Arduino
– 3 Tasten einlesen im Arduino
– Arduino FFT auf dem 5110 Display ausgeben
Display LCD 2×16:
– Arduino Uno mit LCD shield in einem 3D gedruckten Gehäuse
– LCD Display mit PWM Dimmer Funktion
– Temperatursensor DS18B20 mit dem Arduino Uno und LCD Display
Display LCD 4×20:
– Ein LCD Display 4×20 am Arduino betreiben.
Bluetooth:
– Das Bluetooth Modul HC-05 mit AT Kommandos vom Arduino programmieren.
– Das Bluetooth Modul HC-05 am Arduino in Betrieb nehmen.
Der Frequenzgenerator:
– Den ADF4351 Frequenzgenerator 35MHz bis 4,4GHz vom Arduino Uno ansteuern
– Rechteck 1Hz (+-2ppm) ausgeben mit dem RTC DS3231 und dem Arduino
1) Ein simpler Rechteckgenerator mit dem Arduino
– Der Frequenzgenerator und Frequenzzähler
– Den LTC-1799 mit LT-Spice simulieren Teil 2.
– Den LTC-1799 Rechteckgenerator mit LT-Spice simulieren. Schritt für Schritt Erklärung. Teil 1.
9) Ein DDS Sinus Frequenzgenerator einstellbar von 1Hz bis 40MHz mit dem AD9850 und dem …
– Unterschiedliche Signalformen mit dem R2R DA-Wandler ausgeben. Dreieck, Impuls …
– Ein Sinus Signal mit dem R2R DA-Wandler am Arduino Uno ausgeben.
2) Ein Rechtecksignal mit hoher Frequenz direkt aus dem Arduino Uno ausgeben.
3) Ein Rechteck Signal mit einstellbarer Frequenz ausgeben.
– Ein Rechteck Signal ausgeben mit dem R-2R DA-Wandler.
– Ein R-2R 4-Bit Digital-Analog Ausgang wird aufgebaut mit dem Arduino Uno.
4) Rechteck Generator einstellbar von 1kHz – 30MHz.
Der Frequenzzähler:
– Den Frequenzzähler mit LCD auf der Platine aufgebaut.
– Der Frequenzgenerator und Frequenzzähler
– Den Arduino Quarz Takt genauer bestimmen mit einer RTC oder mit GPS.
– Eingangsverstärker für den Arduino Frequenzzähler 10 Hz bis 10 MHz.
5) Ein Frequenzzähler für niedrige Frequenzen mit dem Arduino Uno und der Periodendauer …
6) Frequenzzähler mit LCD Display am Arduino Uno.
7) Frequenzzähler mit dem Arduino Uno Teil 1.
8) Frequenzzähler mit dem Arduino Uno Teil 2.
Die ICs und Sensoren:
– Den ADS1115 16-Bit AD Wandler am Arduino mit Autorange betreiben
– Den ADF4351 Frequenzgenerator 35MHz bis 4,4GHz vom Arduino Uno ansteuern
– Einstellbares Dämpfungsglied PE4302 bis 4GHz mit dem Arduino
– Das NMEA Shield für den Arduino Mega 2560 ist fertig
– Ein Batteriemonitor für Strom und Spannung mit dem INA226 und dem Arduino Uno
– Die Uhrzeit des RTC DS3231 Modul vom Arduino auslesen
– ESP8266 AccessPoint – Die blaue LED per HTML Seite vom iPhone umschalten.
– Den ESP8266 mit der Arduino IDE in Betrieb nehmen
– MCP4725 12Bit DA Wandler vom Arduino ansteuern
– Die Auflösung des ADC vom Arduino Uno erhöhen auf 16 Bit mit Oversampling
– USB FT232R Fake Chip ersetzt durch original FTDI Chip
– Das digitale Poti DS1666 am Arduino betreiben + Teil 2
– Kompassensor HMC5883L am Arduino Uno.
– Die Real Time Clock, RTC DS1307 am Arduino Uno betreiben
– Temperatursensor DS18B20 mit dem Arduino Uno Teil 2.
– Temperatursensor DS18B20 mit dem Arduino Uno und LCD Display.
– Der Luftdruck und Temperatur Sensor BMP085 am Arduino Uno.
– 5A Strom Sensor ACS 712 mit dem Arduino auslesen.
– Den 16-Bit AD-Wandler MCP 3426 mit dem Arduino verwenden.
– Die Versorgungsspannung VCC mit dem Arduino Mega 2560 messen.
Die Berechnungen:
– Den Mittelwert fortlaufend bilden mit einer Funktion
– Der Hamming Code für den Arduino
– Den Wellenwiderstand transformieren 50 Ohm > 150 Ohm mit einer Lambda/4 Leitung
– Die Dämpfung auf Koaxkabeln bei verschiedenen Frequenzen berechnen.
– Distanz und Peilung zwischen 2 Positionen berechnen
– Den LTC-1799 mit LT-Spice simulieren Teil 2.
– Den LTC-1799 Rechteckgenerator mit LT-Spice simulieren. Schritt für Schritt Erklärung. Teil 1.
– Den Kupfer Draht Widerstand berechnen.
– Das T Dämpfungsglied berechnen.
– Das PI Dämpfungsglied berechnen.
– Formeln und Berechnungen in WordPress einfügen.
– S11 und SWR umrechnen.
– Leistung in dBm und dBW umrechnen.
– Leistungen und Spannungen in dB umrechnen.
– Ansoft Designer SV – Hochfrequenz Simulator Software.
Quelle Matthias Busse:
http://shelvin.de/themen/
a
********************************************************I*
Frequenzgenerator (Blink-Schaltungen)
Rechteck-Generator
1) Ein simpler Rechteckgenerator mit dem Arduino
Es lassen sich Frequenzen von 31Hz bis 65,535kHz erzeugen.
Mit der Arduino tone() Anweisung lassen sich Töne / Rechteckfrequenzen auf einem beliebigen digitalen Pin ausgeben.
Damit ist es sehr einfach einen Rechteckgenerator zu realisieren.
// Simpler Rechteckgenerator an pin-10// Matthias Busse Version 1.0unsigned int frequenz=10000; // Frequenz 10kHzvoid setup() { tone(10,frequenz); // Frequenzausgang pin-10}void loop() {}
Quelle Matthias Busse:
http://shelvin.de/ein-simpler-rechteckgenerator-mit-dem-arduino/
********************************************************I*
2) Ein Rechtecksignal mit hoher Frequenz bis 2MHz direkt aus dem Arduino Uno ausgeben
Mit der schon vorher besprochenen ARDUINO Funktion
tone(10,frequenz); lassen sich hohe Rechteck Frequenzen bis 65kHz erreichen.
int k=10, n=10;
while(k==10) { PORTB=B00111100; // 15 asm("nop\n nop\n"); PORTB=B00000000; // 0}
Zwei Assembler Takte (nop Befehle) werden zur Symmetrie hinzugefügt, da die while(1) Schleife auch zwei Takte benötigt.
Das sind 6 Takte. 16.000 kHz / 6 Takte = 2666,7 kHz.
Wenn zusätzlich 2 x 1 nop Anweisungen eingefügt wird, ergeben sich 8 Prozessor Takte oder eine Frequenz von 16 MHz / 8 Takte = 2 MHz.
int k=10, n=10;
while(k==10) { PORTB=B00111100; // 15 asm("nop\n nop\n"); asm("nop\n"); // + 1 nop PORTB=B00000000; // 0 asm("nop\n"); // + 1 nop}
Hier die Tabelle für weitere nop Befehle und die sich dazu ergebenden Frequenzen.
Durch ein wenig rumspielen bekommt man schnell zu der gewünschten Frequenz und sieht was machbar ist.
Das sind beim Arduino Uno die höchsten realisierbaren Frequenzen.
Nur mit einem schnelleren Prozessortakt bekommt man noch höhere Frequenzen.
Nun liegt nahe die nops in eine for Schleife zu legen. Und das funktioniert auch für 0 – 6 Schleifendurchläufe. Hier scheint der Übersetzer 0 – 6 asm-nop Anweisungen auszuführen, genau wie oben beschrieben. Bei 7 Schleifen Durchläufen ändert sich das aber gänzlich und es wird eine Frequenz wie bei 50 einzelnen nops ausgegeben, also 150,94 kHz. Bei 8 nops in der Schleife sind es 133,33 kHz und bei 9 dann 119,40 kHz. Das wird dann so fortgesetzt.
Das Testprogramm hierfür sieht daher so aus.
int k=10, n=10, i;while(k==10) { PORTB=B00111100; // 15 asm("nop\n nop\n"); for(i=0;i< n; i++) asm("nop\n"); PORTB=B00000000; // 0 for(i=0;i< n; i++) asm("nop\n"); }Bei höheren Frequenzen
50kHz bis 2 MHz bleiben dann noch die „nops“ aus dem Beitrag 2 siehe OBEN.
Bisher regele ich die Geschwindigkeitsstufen mit einem Arduino Mega per Interrupt und nop-Anweisungen in for-Schleifen:
void loop(){
PORTA = B01000100;
for(i=0;i< n+80; i++)
asm("nop\n");
PORTA = B10000100;
for(i=0;i< n+80; i++)
asm("nop\n");
PORTA = B10001000;
for(i=0;i< n+80; i++)
asm("nop\n");
PORTA = B01001000;
for(i=0;i< n+80; i++)
asm("nop\n");
}
Quelle Matthias Busse:
http://shelvin.de/ein-rechtecksignal-mit-hoher-frequenz-mit-dem-arduino-ausgeben/
********************************************************I*
3) Ein Rechteck Signal mit einstellbarer Frequenz ausgeben 31Hz bis 625 Hz
Nachdem ich nun die Obergrenze des Rechtecksignals getestet habe, will ich mir jetzt mal die unteren Frequenzen ansehen.
Da bieten sich die delay(ms) und delayMicroseconds(us) Funktionen an.
Ein Prozessortakt dauert bei 16 MHz Takt 62,5 Nano Sekunden.
Meine while schleife mit den nops und Portausgaben benötigt 6 Takte. delayMicroseconds() lässt sich in 1 Mikrosekunden Stufen einstellen bis hin zu 16383, was hier einer Frequenz von ca. 31 Hz entspricht.
delay (10) // Pause 10 milli Sekunden
delayMicroseconds (100) // Pause 100 micro Sekunden
Eine genauere Betrachtung von delayMicroseconds() wird mit diesem Programm vorgenommen.
int k=10, n=10, i;
for(int i=0;i< 100;i++) { t1=micros(); delayMicroseconds(i); //von 31Hz bis 625 Hz ist delayMicroseconds verwendbar t2=micros(); Serial.print(i); Serial.print(";"); Serial.println(t2-t1); delay(10);}Von 31Hz bis 625 Hz ist delayMicroseconds verwendbar.
Die Eingabewerte i für delayMicrosecond(i) sind blau eingetragen und die Zeitdifferenzmessung mit micros() ist rot eingetragen. Wenn eine micros() Anweisung 3 Mikrosekunden braucht, ergibt sich die gelbe Linie (Eingabe + 3).
Die Funktion delayMicroseconds() arbeitet nicht linear und wir sehen hier 6 bis zu 8 Mikrosekunden Abweichung der roten Kurve gegenüber der gelben Ideallinie.
Um den Frequenzfehler kleiner 1% zu halten, sollte die Funktion nicht unter 800 Mikro Sekunden eingesetzt werden. Das entspricht einer Frequenz von 625 Hz.
Ergebnis: Damit ist delayMicroseconds() für Frequenzen von 31Hz bis 625 Hz einsetzbar.
Eine eigene for schleife
long d,l,i;d=round(i/0.0625);for(l=0;l
Diese for Schleife dauert (i*11,08)+3 Mikro Sekunden und ist von 14 bis 800 Mikrosekunden einsetzbar. Das entspricht einer Frequenz von 35,7 kHz bis runter zu 625 Hz mit einem Fehler kleiner als 1%. Die einstellbare minimale Schrittweite der Frequenzen liegt bei ca. 2 x 11 = 22 Mikrosekunden.
Ergebnis: Damit ist for(,,,) für Frequenzen von 625Hz bis 35 kHz einsetzbar
Eine eigene do while Schleife
long d,l,i;d=round(i/0.0625); do {d--;} while(d>0);
Gibt dasselbe Ergebnis wie die oben untersuchte eigene for Schleife.
Mit dem Timer Interrupt
Also teste ich den Timer Interrupt, der immer ausgelöst wird wenn der Timer überläuft.
Die Library TimerOne wird installiert und in das Programm eingebunden.
Diese Bibliothek ist eine Sammlung von Routinen zum Konfigurieren des 16-Bit-Hardware-Timers namens Timer1 auf dem ATmega168 / 328. Auf dem Chip sind 3 Hardware-Timer verfügbar, die auf verschiedene Arten konfiguriert werden können, um unterschiedliche Funktionen zu erreichen. Die Entwicklung dieser Bibliothek begann mit der Notwendigkeit nach einer Möglichkeit, die PWM-Periode oder -Frequenz schnell und einfach einzustellen, ist jedoch auf eine Zeitüberlauf-Interrupt-Handhabung und andere Merkmale angewachsen.
http://arduino.cc/playground/Code/Timer1
http://playground.arduino.cc/Code/Timer1
Hier ist die Beschreibung.
Beispiel Sketch
#include <TimerOne.h> // Library TimerOne.h // In diesem Beispiel wird der Timer-Interrupt verwendet, um eine LED zu blinken
// und demonstriert auch, wie man eine Variable teilt
// der Interrupt und das Hauptprogramm.const int led = LED_BUILTIN; // the pin with a LEDvoid setup(void){ pinMode(led, OUTPUT); Timer1.initialize(150000); Timer1.attachInterrupt(blinkLED); // blinkLED to run every 0.15 seconds Serial.begin(9600);} // Der Interrupt wird die LED blinken lassen und halten
// Track, wie oft es geblinzelt hat.
int ledState = LOW;volatile unsigned long blinkCount = 0; // use volatile for shared variablesvoid blinkLED(void){ if (ledState == LOW) { ledState = HIGH; blinkCount = blinkCount + 1; // increase when LED turns on } else { ledState = LOW; } digitalWrite(led, ledState);}// Das Hauptprogramm sendet die Blinkanzahl zum Arduino Serial Monitor
void loop(void){ unsigned long blinkCopy; // holds a copy of the blinkCount // um eine Variable zu lesen, die der Interrupt-Code schreibt, wir
// muss Interrupts vorübergehend deaktivieren, um sicher zu gehen
// nicht ändern, während wir lesen. Um die Zeit zu minimieren
// mit Unterbrechungen aus, nur schnell eine Kopie machen, und dann
// Benutze die Kopie, während der Interrupt weiter funktioniert.
noInterrupts(); blinkCopy = blinkCount; interrupts(); Serial.print("blinkCount = "); Serial.println(blinkCopy); delay(100);}
https://www.pjrc.com/teensy/td_libs_TimerOne.html
Der Timer Interrupt hat zusätzlich den großen Vorteil, dass er unabhängig vom Hauptprogramm arbeitet. Man muss sich darum dann nicht mehr kümmern, ausser in zeitkritischen Routinen.
Bei jedem Timer Interrupt wird diese Funktion aufgerufen. Die DA-Wandler Eingänge werden umschaltet. In status steckt der letzte Wert.
void timerOutput() {// Timer Ausgabe if(status==1) { PORTB=B00111100; status=0; } else { PORTB=B00000000; status=1; }}Von 1Hz bis 1kHz (oder sogar 10kHz) je nach Anforderung, ist die Timer Interrupt Routine gut zu verwenden.
Dann kommt dieses Programm zum Einsatz.
#include long mikrosekunden=500;volatile byte status = 0;void setup() { Serial.begin(38400); pinMode(10,OUTPUT); pinMode(11,OUTPUT); pinMode(12,OUTPUT); pinMode(13,OUTPUT); Timer1.initialize(mikrosekunden); Timer1.attachInterrupt(timerOutput);}void loop() {int f; while(1) { for(f=1000;f< 30000;f*=2) { mikrosekunden = round(500000/f); timerNeu(); delay(3000); } }}void timerNeu() { Timer1.detachInterrupt(); Timer1.initialize(mikrosekunden); Timer1.attachInterrupt(timerOutput);}
Im setup wird der Timerinterrupt eingestellt. Danach kann er vom Programm geändert werden indem die Variable mikrosekunden gesetzt wird und timerNeu() aufgerufen wird. Das macht die for Schleife und verdoppelt die Frequenz f dabei jedes mal.
Das ganze funktioniert für die Frequenzen von 1 Hz bis 10000 Hz. Auch noch etwas höher bis max. 83.000 Hz, hier aber nur in grossen Schrittweiten.
Da immer 500.000/f geteilt wird und das ganze auf integer gerundet wird, entstehen oben Lücken in den Frequenzen, die nicht ausgegeben werden können.
500.000 / 10.000 Hz = 50 uSek
nächster Wert 500.000 / 9.804 Hz = 51 uSek
nächster Wert 500.000 / 9.615 Hz = 52 uSek
…
Das sind 6 mögliche Frequenzen von 9 – 10 kHz, oder anders herum ausgedrückt Frequenzlücken von ca 200 Hz.
500.000 / 1.000 Hz = 500 uSek
nächster Wert 500.000 / 998 Hz = 501 uSek
Frequenzlücken von 2 Hz
500.000 / 100 Hz = 5000 uSek
nächster Wert 500.000 / 99,98 Hz = 5001 uSek
Frequenzlücken von 0,02 Hz
Ergebnis: Damit ist der Timer Interrupt für Frequenzen von unter 1Hz bis 1 kHz einsetzbar.
Zusammenfassung
Von 31Hz bis 625 Hz ist delayMicroseconds verwendbar.
Von unter 1 Hz bis 1 kHz oder sogar 10kHz, je nach Anforderung, ist die Timer Interrupt Routine gut zu verwenden.
Von 1 kHz bis 35 kHz sind die for und die while Schleife einsetzbar.
Bei höheren Frequenzen bis 2 MHz bleiben dann noch die „nops“ aus dem letzten Beitrag.
Da heisst es dann ordentlich copy-and-paste oder auch eine Schleife einfügen.
http://shelvin.de/ein-rechteck-sgnal-mit-einstellbarer-frequenz-ausgeben/
********************************************************I*
4) Rechteck Generator einstellbar von 1kHz bis 33MHz mit LINEAR technology IC LTC1799
Der Rechteck Generator mit dem precision oscillator LTC1799
Ein einstellbarer Rechteckgenerator lässt sich einfach mit dem LTC 1799 Chip bauen. Der Chip im SOT23 Gehäuse wird hier auf einer Adapterplatine verwendet.
Mit einem 200 kOhm Poti und einer Brücke kann die Frequenz eingestellt werden von ca 1 kHz bis zu 30 MHz, wenn 5V Versorgunsspannung verwendet werden. Bei 3V Spannungsversorgung liegt die obere Frequenz bei ca. 20 MHz.
Mit einer Brücke von Pin 4 zu VCC, offen oder zu GND lassen sich 3 Faktoren N einstellen. Die Faktoren N ergeben sich wie folgt:
Pin 4 an GND: N=1
Pin 4 offen: N=10
Pin 4 an VCC: N=100
Der Widerstand Rset sollte ein Poti mit 200 kOhm sein um die Frequenz verändern zu können. Bei einer gewünschten Festfrequenz kann auch ein fester Widerstand verwendet werden. Rset sollte mindestens 3,32kOhm sein. Hier wird später ein Festwiderstand in Reihe zum Poti vorgesehen.
Die Hardware
Bauteile: LTC1799 IC (ähnliches IC LTC6900 IC), 200 kOhm Poti, 3.9 kOhm Widerstand, 10nF Kondensator.
Preis ca. 3-5 Euro.
LTC1799 Rechteckgenerator
Auf dem Bild sind zu sehen: Links das Breadboard mit dem LTC1799 und dem 200 KOhm Poti darunter. Rechts die 5V Spannungsversorgung. Und noch rechts am Rand der Tastkopf vom Oszilloskop mit der Masseklemme (beide Kabel gelb).
Poti , ESR, Umschalter, 5Volt Stabilisierung
Die Kabelverbindungen auf dem Bild:
+5V an pin-1 (rot)
GND an pin-2 (schwarz)
1M Poti lin zwischen pin-1 und pin-3 und noch ein 3,3k Widerstand in Reihe
Ausgang pin-5 (gelb)
Brücke für N (orange, hier offen)
Die Frequenz Berechnung
f (Hz) = 10.000.000 Hz * 10.000 Ohm / N / Rset
Ein Beispiel
Die gewählten Werte sind
1. N=100 (pin-4 an Vcc) N=10 (pin-4 n.c. = open) N=1 (pin-4 an GND)
2. Rset=1kOhm (Poti)
f = 10.000.000 Hz * 10.000 Ohm /
100 / 1.000 Ohm = 1 MHz
f = 10.000.000 Hz * 10.000 Ohm /
10 / 1.000 Ohm = 10 MHz
f = 10.000.000 Hz * 10.000 Ohm /
100 / 100.000 Ohm = 10 kHz
Die Widerstands Berechnung
Rset = 10.000.000 Hz * 10.000 Ohm / N / f
Ein Beispiel
Die gewählten Werte sind
1. N=10 (pin-4 offen = n.c. )
2. f=100 kHz
Rset = 10.000.000 Hz * 10.000 Ohm / 10 / 100.000 Hz = 100 kOhm
Falls das LTC1799 nicht verfügbar sein sollte ist das LTC6900 ggf. eine Alternative.
Teil 1 : SOT23 Chip zu DIL Adapter selbst herstellen.
http://shelvin.de/pdf/ltc1799cs5.pdf
http://shelvin.de/sot23-chip-zu-dil-adapter-selbst-herstellen/
Quelle Matthias Busse:
http://shelvin.de/rechteck-generator-einstellbar-von-1khz-30mhz/
********************************************************I*
5) Ein Frequenzzähler für niedrige Frequenzen mit dem Arduino Uno und der Periodendauer Messung
Der Messbereich beträgt also 1mHz (milliHertz) bis 10 kHz (killoHerz)
Über die Messung der Pulslängen HIGH und LOW kann aus einem Rechtecksignal, oder einem ähnlichen Signal, die Frequenz bestimmt werden.
Der Arduino bietet hierzu die Funktion pulseIn(pin, signal) an. Die funktioniert an jedem Digital Pin und misst, wenn man die HIGH und die LOW Zeit addiert die Periodendauer T in Mikrosekunden.
Die Grenzwertbetrachtung
Bei einer Periodendauer von 100 Mikrosekunden entspricht +- 1 Mikrosekunde Fehler 1%, sodass bis ca. 10 kHz gemessen werden kann mit einem Fehler <1%.
Die Periodendauer T wird als unsigned long angegeben und kann somit bis maximal 4.294.967.295 zählen. Das entspricht 230 Mikroherz und somit ist der Millihertz Bereich voll erfasst und 3 Kommastllen sind bei niedrigen Frequenzen möglich.
Beispiel Sketch
void loop() { 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 f = fsum/k*0.9925; // Korrekturwert einrechnen Serial.println(f); fsum=0.0; k=0;}
Im Programm wird über 1 Sekunde (1e6 Mikrosekunden) gemittelt, deshalb sind nur Frequenzen bis runter zu ca. 3 Hz messbar.
Für niedrigerer Frequenzen muss entsprechend länger gemittelt werden, zum Beispiel 10, 100 oder 1000 Sekunden um 3 Millihertz erfassen zu können.
Fazit
Mit dieser einfachen und flexiblen Routine sind Messung von 3Hz bis 10 kHz möglich incl. einiger Nachkommastellen.
Links
Für höher Frequenzen wird die
hier beschriebene Technik verwendet.
Quelle Matthias Busse:
http://shelvin.de/ein-frequenzzaehler-fuer-niedrige-frequenzen-mit-dem-arduino-uno-und-der-pulslaengenmessung/
********************************************************I*
6) Frequenzzähler mit LCD Display am Arduino Uno.
Zum Frequenzzähler wird ein LCD Display 16x2 hinzugefügt basierend auf den beiden Projekten:
- Frequenzzähler mit dem Arduino Uno Teil 1
- Frequenzzähler mit dem Arduino Uno Teil 2
- Ein LCD Display 4x20 am Arduino betreiben Teil 1
- LCD Display mit PWM Dimmer Funktion Teil 2
Das 1602 LCD Display soll die gemessene Frequenz ausgeben.
Die Anschlüsse bei beiden Projekten überschneiden sich nicht, sodass sie alle weiter verwendet werden.
Die LCD-Display 16x2 Anschlüsse:
LCD > ARDUINO UNO
Vss > GND
Vdd > +5V
V0 > 10k Poti + 1kOhm in Reihe > GND
RS > pin-12
R/W > pin-13
E > pin-11
D4 > pin-7
D5 > pin-8
D6 > pin-9
D7 > pin-10
A > +5V
K > 10R > GND
Die Messfrequenz wird mit einem Pegel von ca. 5,0V auf ARDUINO pin-5 und GND angeschlossen.
Achtung: nicht über 5V Pegel
Der Aufbau
FOTO fehlt, Schaltbild fehlt
Das Programm
// Arduino Uno Frequenzzähler bis ca. 5 MHz// Eingangsspannung muss an Pin 5 mit ca. 5V Pegel ankommen.// V 1.2: 1602 Display hinzugefügt// // Beschreibung und Library unter:// http://interface.khm.de/index.php/lab/experiments/arduino-frequency-counter-library///// Matthias Busse 24.05.2014 Version 1.2/* LCD Display Anschlüsse:LCD > Arduino-------------VSS > GNDVDD > +5VV0 > 10k Poti + 1kOhm Widerstand > GNDRS > Pin 12R/W > Pin 13E > Pin 11D4 > Pin 7D5 > Pin 8D6 > Pin 9D7 > Pin 10A > +5VK > 10 Ohm Widerstand > GND */#include <FreqCounter.h>#include <LiquidCrystal.h>LiquidCrystal lcd(12, 13, 11, 7, 8, 9, 10);long int rfreq, mfreq; // rfreq=Rechenfrequenz, mfreq=Messfrequenzint hz=0, khz=0, mhz=0; // Hz, kHz und MHz je 3 Ziffernchar sfreq[15]; // sfreq=Stringfrequenzvoid setup() { Serial.begin(38400); // Serielle Ausgabe Serial.println("Frequenz Zaehler V 1.2"); lcd.begin(20,4); lcd.clear(); lcd.setCursor(0,0); lcd.print("Frequenz Zaehler"); delay(1000);}void loop() { FreqCounter::f_comp= 8; // Kompensation einstellen FreqCounter::start(1000); // Zähler starten für 1000ms while (FreqCounter::f_ready == 0) // warten bis der Zähler fertig ist mfreq=FreqCounter::f_freq; // Ergebnis lesen rfreq=mfreq; hz=rfreq-(int((rfreq/1000))*1000); // Hz ermitteln rfreq=(rfreq-hz)/1000; // kHz ermitteln khz=rfreq-(int((rfreq/1000))*1000); rfreq=(rfreq-khz)/1000; // MHz ermitteln mhz=rfreq-(int((rfreq/1000))*1000); if(mfreq<1000) // Hz in String schreiben sprintf(sfreq," %3d Hz",hz); if((mfreq>=1000)&&(mfreq<1000000)) // kHz.Hz in String schreiben sprintf(sfreq," %3d.%03d Hz",khz,hz); if(mfreq>999999) // MHz.kHz.Hz in String schreiben sprintf(sfreq,"%3d.%03d.%03d Hz",mhz,khz,hz); Serial.println(sfreq); // Terminal ausgeben lcd.setCursor(1,1); // Display ausgeben lcd.print(" "); lcd.setCursor(1,1); lcd.print(sfreq);}
https://github.com/PaulStoffregen/FreqCount
Für den Frequenzeingang sollte noch eine Schutzschaltung vorgesehen werden,
z.B. ein 7400 IC mit 5V Berieb, das den Pin 5 des Arduino vor Überspannungen schützt.
> Frequenzzähler für niedrige Frequenzen mit Pulslängenmessung
> Eingangsverstärker für den Frequenzzähler
> Den Frequenzzähler mit LCD auf der Platine aufgebaut.
Quelle Matthias Busse:
http://shelvin.de/frequenzzaehler-mit-display/
********************************************************I*
7) Frequenzzähler mit dem Arduino Uno Teil 1
Wenn eine 5V Wechselspannung vorliegt, z.B. aus dem Rechteckgenerator, kann der Arduino die Frequenz direkt zählen. Das funktioniert bis ca. 8 MHz bei einem symmetrischen
Rechtecksignal, ansonsten weniger. Martin Nawrath hat hierzu eine gute Library geschrieben und bereit gestellt.
Die Hardware
Beim Uno wird die 5V Rechteckspannung direkt an Pin 5 gelegt.
Bitte keine höhere Spitzenspannung verwenden, da das den Arduino beschädigen oder zerstören kann. Am besten schaltet man einen TTL Baustein 74xx davor, der ist billiger zu ersetzen als der Mikrocontroller.
Die Software
Hier der Arduino Programmcode (Sketch) mit Kommentaren:
// Arduino Uno Frequenzzähler bis ca. 5 MHz// Eingangsspannung muss an Pin 5 mit 5V Pegel ankommen.// // Beschreibung und Library unter:// http://interface.khm.de/index.php/lab/experiments/arduino-frequency-counter-library///// Matthias Busse 11.04.2014 Version 1.0#include <FreqCounter.h>long int freq;void setup() { Serial.begin(38400); // Serielle Ausgabe Serial.println("Frequenz Zaehler V 1.0");}void loop() { FreqCounter::f_comp= 8; // Kompensation einstellen FreqCounter::start(1000); // Zähler starten für 1000ms while (FreqCounter::f_ready == 0) // warten bis der Zähler fertig ist freq=FreqCounter::f_freq; // Ergebnis lesen Serial.println(freq); // und ausgeben}
– Die Beschreibung von Martin Nawrath
Arduino Frequency Counter Library
Aus unserem> Theremin-Projekt habe ich diese Frequenzzähler-Bibliothek abgeleitet. Die Bibliothek ermöglicht die Messung von Frequenzen mit hoher Auflösung und Genauigkeit.
Der Frequenzeingang ist fest mit dem digitalen Pin 5 verbunden. Dieser Pin ist der alternativen Port-Funktion T1 zugeordnet, bei der es sich um den Eingang 16 Bit Hardware Counter1 handelt. Um eine höhere Auflösung als 16 Bit zu erhalten, werden die
Zählerüberläufe ebenfalls gezählt und mit dem Zählerwert zu dem endgültigen langen Ganzzahlergebnis berechnet. Der Ausgang der Frequenzquelle muss einen digitalen Pegel haben, so dass schwache Signale beispielsweise durch einen einzelnen Transistor oder einen 74HC14-Inverter verstärkt werden müssen. Die maximale Eingangsfrequenz beträgt etwa 8 MHz, wenn das Tastverhältnis 50% beträgt.
Wenn Sie höhere Frequenzen messen möchten, müssen Sie einen Vorteiler oder eine Teilerschaltung verwenden, die von anderen im Internet veröffentlichten
Zählerprojekten verwendet werden kann. Die Gate-Zeit für die Zählperiode kann in der Funktion start () gewählt werden, wobei Werte von 10, 100 oder 1000 ms für eine Auflösung von 100, 10 und 1 Hz praktikabel sind, aber jeder Wert verwendet werden kann. Die interne Auflösung der Gatezeit beträgt 2 ms, so dass die Zeit im Inkrement 2 variiert werden kann. Wenn Sie den Anzeigefehler minimieren möchten, kann der Wert der Variable FreqCounter :: f_comp leichte Gatetime-Fehler kompensieren. Im Vergleich zu einem kommerziellen ACECO-Zähler ist es möglich, die Abweichung über den gesamten Bereich auf nahezu Null zu reduzieren. Für Torzeiten von 10,100,100 wurden die Werte 1, 10 und 100 für unsere Duemilanova-Platten als gut befunden.
Beispiel Sketch
#include <FreqCounter.h>void setup() { Serial.begin(57600); // connect to the serial port Serial.println("Frequency Counter");}long int frq;Void loop() { FreqCounter::f_comp= 8; // Set compensation to 12 FreqCounter::start(100); // Start counting with gatetime of 100ms while (FreqCounter::f_ready == 0) // wait until counter ready frq=FreqCounter::f_freq; // read result Serial.println(frq); // print result delay(20);}
Vorverstärker-Schaltpläne
Quelle Matthias Busse:
http://shelvin.de/frequenzzaehler-mit-dem-arduino-uno/
********************************************************I*
8) Frequenzzähler mit dem Arduino Uno Teil 2
Die Frequenz wird zu besseren Lesbarkeit mit Dezimalpunkten ausgegeben.
Anstelle von 123445566 Hz wird nun 123.445.566 Hz ausgegeben.
Die Software
Hier der Arduino Programmcode (Sketch) mit Kommentaren:
// Arduino Uno Frequenzzähler bis ca. 5 MHz// Eingangsspannung muss an Pin 5 mit 5V Pegel ankommen.// pin-5 muß hier der Eingangspin für die Frequenzzählung sein, das gibt die Library FreqCounter.h so vor// Beschreibung und Library unter:// http://interface.khm.de/index.php/lab/experiments/arduino-frequency-counter-library///// Matthias Busse 12.04.2014 Version 1.1#include <FreqCounter.h>long int rfreq, mfreq; // rfreq=Rechenfrequenz, mfreq=Messfrequenzint hz=0, khz=0, mhz=0; // Hz, kHz und MHz je 3 Ziffernchar sfreq[15]; // sfreq=Stringfrequenzvoid setup() { Serial.begin(38400); // Serielle Ausgabe Serial.println("Frequenz Zaehler V 1.1");}void loop() { FreqCounter::f_comp= 8; // Kompensation einstellen FreqCounter::start(1000); // Zähler starten für 1000ms while (FreqCounter::f_ready == 0) // warten bis der Zähler fertig ist mfreq=FreqCounter::f_freq; // Ergebnis lesen rfreq=mfreq; hz=rfreq-(int((rfreq/1000))*1000); // Hz ermitteln rfreq=(rfreq-hz)/1000; // kHz ermitteln khz=rfreq-(int((rfreq/1000))*1000); rfreq=(rfreq-khz)/1000; // MHz ermitteln mhz=rfreq-(int((rfreq/1000))*1000); if(mfreq<1000) // Hz in String schreiben sprintf(sfreq," %3d Hz",hz); if((mfreq>=1000)&&(mfreq<1000000)) // kHz.Hz in String schreiben sprintf(sfreq," %3d.%03d Hz",khz,hz); if(mfreq>999999) // MHz.kHz.Hz in String schreiben sprintf(sfreq,"%3d.%03d.%03d Hz",mhz,khz,hz); Serial.println(sfreq); // und ausgeben}
Hilfreiche Links
< Frequenzzähler mit dem Arduino Uno Teil 1
> Frequenzzähler mit LCD Display
Quelle Matthias Busse:
http://shelvin.de/frequenzzaehler-mit-dem-arduino-uno-teil-2/
********************************************************I*
9) Ein DDS Frequenzgenerator mit dem AD9850 und Arduino Uno
DDS = Direkte Digitale Synthese
Die Direct Digital Synthesis oder direkte digitale Synthese (kurz DDS) ist ein Verfahren in der digitalen Signalverarbeitung zur Erzeugung periodischer, bandbegrenzter Signale mit praktisch beliebig feiner Frequenzauflösung. Das Verfahren stellt heute neben der rational gebrochenen Phasenregelschleife die dominierende Methode zur Generierung von Signalen fein einstellbarer Frequenz dar und hat weite Verbreitung in der Nachrichten- und Messtechnik gefunden.
Mit der fertigen AD 9850 DDS Platine (z.B. von ebay für unter 10 Euro) und dem Arduino Uno lässt sich ziemlich einfach ein einstellbarer Sinus Frequenzgenerator aufbauen. Dieser ist dann durchstimmbar von 1 Hz bis 40 MHz in 1 Hz Schritten.
Ich habe hier die serielle Ansteuerung des AD 9850 DDS ( Direkte Digitale Synthese ) gewählt weil dann weniger Anschlüsse vom Arduino benötigt werden.
Die Verbindung der beiden Platinen.
|
Arduino Uno
|
DDS AD 9850
|
Kabelfarbe im Bild
|
Kommentar
|
|
5V
|
VCC
|
rot
|
Spannungsversorgung mit 5V
|
|
GND
|
GND
|
blau
|
Masse
|
|
Pin 8
|
DATA
|
orange
|
serielle Datenleitung
|
|
Pin 9
|
CLK
|
grün
|
Datentakt zum Übernehmen der seriellen Daten
|
|
Pin 10
|
FQ
|
weiß
|
Frequenz Update signal
|
|
Pin 11
|
RST
|
braun
|
Reset
|
Es können auch andere digitale PINs vom Arduino verwendet werden solange wir auf der digitalen Seite des Arduino Uno bleiben und das im Programm entsprechend angepasst wird.
Der Sinus Ausgang ist dann SINA und SINB (um 180° verschoben), jeweils gegen GND.
Im Bild mit den Leitungen rot und gelb angeschlossen.
Die Ansteuerung des DDS wird auf verschiedenen Seiten beschrieben. Teilweise kommen dort auch Arduino Bibliotheken zum Einsatz. Das ist aber gar nicht notwedig, da es mit ein paar Codezeilen schnell erledigt ist.
Ich habe das Programm hier einfach und kompakt gehalten.
Zusätzlich ist eine Sweep Funktion enthalten, die die Frequenz mit n Schritten in einer bestimmten Zeit verändert und dann wieder von vorn anfängt.
Für eine feste Frequenz wird diese Funktion verwendet:
void AD9850_Frequenz(double frequenz)
Für einen Frequenzsweep wird diese Funktion verwendet:
void sweep(long int fstart, long int fstop, int nstep, int tms)
Die fertige Arduino Datei zum Download.
Hier nun der Arduino Programmcode mit Kommentaren:
// DDS AD9850 Board und Arduino Uno// Serielle Ansteuerung des DDS Board// Fest-Frequenz-Ausgabe oder Frequenz-Sweep//// Matthias Busse Version 0.4 vom 30.11.2013//Arduino Uno > AD9850 Board Anschlüsse #define RST 11 // Arduino 11 > Board RST - Reset#define FQ 10 // Arduino 10 > Board FQ - Frequenz Update#define CLK 9 // Arduino 9 > Board CLK - Takt#define DATA 8 // Arduino 8 > Board DATA - Daten// Dann noch anschliessen// Arduino 5V > Board VCC// Arduino GND > Board GND#define pulseHigh(pin) {digitalWrite(pin, 1); digitalWrite(pin, 0); }void setup(){ AD9850_Init(); AD9850_Reset();// Wenn nur eine feste Frequenz ausgegeben werden soll: // AD9850_Frequenz(200000); // Frequenz in Hz einstellen}void loop(){ while(1) { sweep(100000, 400000, 20, 1000); // wenn Frequenzen durchgesweept werden sollen delay(1000); } }void sweep(long int fstart, long int fstop, int nstep, int tms) {// Die Frequenz linear durch sweepen// ca. 2 ms pro Schritt werden mindestens benötigt. //// fstart: Startfrequenz// fstop: Stopfrequenz// nstep: Anzahl der Schritte// tms: Sweepzeit in ms//// Matthias Busse Version 1.0 vom 27.11.2013 long int i, f, fdelta, tdelta; unsigned long t1; fdelta=(fstop-fstart)/(nstep-1); tdelta=tms/(nstep-1); for(i=0; i<nstep; i++) { t1=millis(); f=fstart+(i*fdelta); AD9850_Frequenz(f); while((millis()-t1) < tdelta){} }}void AD9850_Init(){// Ausgänge definieren // Matthias Busse Version 1.0 vom 27.11.2013 pinMode(RST, OUTPUT); // alles Ausgänge pinMode(FQ, OUTPUT); pinMode(CLK , OUTPUT); pinMode(DATA, OUTPUT); digitalWrite(RST, 0); // alles 0 digitalWrite(FQ, 0); digitalWrite(CLK, 0); digitalWrite(DATA, 0);}void AD9850_Reset(){// DDS zurück setzen// Matthias Busse Version 1.0 vom 27.11.2013 pulseHigh(RST); //Reset Signal pulseHigh(CLK); //Clock Signal pulseHigh(FQ); //Frequenz Update Signal}void AD9850_Frequenz(double frequenz){// Die Frequenz übertragen und DDS starten // Matthias Busse Version 1.0 vom 27.11.2013 long int y; frequenz=frequenz/1000000*4294967295/125; //für ein 125 MHz Quarz y=frequenz; AD9850_SendData(y); // w4 - Frequenzdaten LSB übertragen AD9850_SendData(y>>8); // w3 AD9850_SendData(y>>16); // w2 AD9850_SendData(y>>24); // w1 - Frequenzdaten MSB AD9850_SendData(0x00); // w0 - 0x00 keine Phase pulseHigh(FQ); // Die neue Frequenz ausgeben}void AD9850_SendData(unsigned char c) {// 8 Bit Daten senden mit CLK Impuls// Matthias Busse Version 1.0 vom 27.11.2013 int i; for(i=0; i<8; i++) { digitalWrite(DATA, (c>>i)&0x01); pulseHigh(CLK); }}
> Analog Device AD9850 Info Seite und das Datenblatt
> Seite 1 in Deutsch
http://www.nmea.de/schaltung/sch-dds9850.html
http://shelvin.de/ein-dds-frequenzgenerator-mit-dem-ad9850-und-dem-arduino-uno/
********************************************************I*
a
Sketch Nr.1: Blinkende LED
a
Auf dem Arduino ist an Pin 13 bereits eine LED eingebaut (für Testzwecke). Häufig blinkt diese Lampe schon, wenn man ein neues Arduino-Board anschließt, da das Blink-Programm zum Testen des Boards je nach Hersteller bereits vorab installiert ist. Wir werden dieses Blinken jetzt selbst programmieren.
Schaltung:
Die auf dem Board vorhandene LED ist auf dem Bild rot eingekreist.
Man muss nur das Board per USB-Kabel mit dem Computer verbinden.
void setup() // hier beginnt das Setup{ // hier beginnt ein ProgrammabschnittpinMode(13, OUTPUT); // pin-13 mit verbauter LED soll ein Ausgang sein} // hier ist ein Programmabschnitt beendetvoid loop() // hier beginnt das Hauptprogramm - wird vom Arduino immer wiederholt{ // hier beginnt der nächste ProgrammabschnittdigitalWrite(13, HIGH); // schalte die die Spannung an pin-13 ein (LED ein).delay(999); // warte 999 Millisekunden = 0,999 SekundendigitalWrite(13, LOW); // schalte die die Spannung an pin-13 aus (LED aus).
delay(1500); // wartet 1,5 Sekunden} // hier ist auch der Programmabschnitt beendet// Hier am Ende springt das Programm an den Start des Loop-Teils. // Also schalte die LED an Pin7 an - Endlosschleife
Sketch-Code besser so
// digital pin-13 has an LED connected on most ARDUINO boardsint ledPin = 13; // Variable deklarieren mit ledPin und initialisieren mit = 13;void setup() { // the setup routine runs once when you press reset pinMode(ledPin, OUTPUT); // Befehl=pinMode pin=13 Modus=Ausgang}void loop() { // the loop routine runs over and over again forever digitalWrite(ledPin, HIGH); // LED auf High-Pegel = +2V..+5V = Ub delay(1000); // Wartezeit 1000ms = 1 Sekunde digitalWrite(ledPin, LOW); // LED auf Low-Pegel = 0V..0,8V = GND delay(1000); // wait for a second}
Impulsdiagramm 1s high 1s low = 0,5 Hz
Impulsdiagramm 10ms high 10ms low = 50.0 Hz
https://www.grund-wissen.de/elektronik/elektronik-mit-arduinos.html
