http://sites.schaltungen.at/arduino-uno-r3/arduino-20mhz

http://www.linksammlung.info/

http://www.schaltungen.at/

                                                                                             Wels, am 2023-01-08

BITTE nützen Sie doch rechts OBEN das Suchfeld  [                                                              ] [ Diese Site durchsuchen]

DIN A3 oder DIN A4 quer ausdrucken
DIN A4  ausdrucken   siehe     http://sites.schaltungen.at/drucker/sites-prenninger
********************************************************I*
~015_b_PrennIng-a_arduino.uno.r3-arduino-20MHz (xx Seiten)_1a.pd

Das 20MHz Arduino UNO- und Bootloader-Tutorial.

Diese Seite enthält das vollständige Skript, das ich für die Erstellung dieses Videos verwendet habe.

VIDEO

http://www.brokking.net/Video_73.html

Hallo und willkommen zu einem weiteren meiner Videos.

In diesem Video erkläre ich, wie man einen 20MHz Arduino UNO baut.

Ich werde auch erklären, wie ein 20MHz Bootloader erstellt wird und wie dieser Bootloader auf den 20MHz Arduino UNO hochgeladen wird.

Und für diejenigen, die es verpasst haben, der ATmega328P ist seit Anfang 2016 nicht mehr derselbe.

Ich werde dies später in diesem Video erklären.

Ja, der Mikrocontroller auf dem Arduino Uno, der ATMega328P, kann sicher mit 20MHz laufen, wie Sie hier im Datenblatt sehen können.

Nur um etwas mehr Rechenleistung für Ihre Projekte zu bekommen.

Für dieses Tutorial benötigen Sie einen Arduino Uno oder Klon, einen Arduino Uno als ISP-Programmierer, einen 20MHz Quarz und zwei 22 piko Farad Keramikkondensatoren.

Sie können keinen 20MHz Quarz verwenden, den Sie in die Hände bekommen können.

Stellen Sie sicher, dass der Quarz eine Lastkapazität von 18pF hat, damit er mit den 22pF-Kondensatoren zuverlässig läuft.

Die Lastkapazität kann dem Datenblatt des Quarzes entnommen werden.

Detaillierte Informationen und Berechnungen zur Lastkapazität finden Sie im Anwendungshinweis AVR042.

Ich werde einen Link zu diesem Dokument in die Beschreibung setzen.

Als erstes müssen der 16MHz Resonator und der 1,0 Megaohm-Widerstand auf der Platine entfernt werden.

Danach stehen Baumpads zur Verfügung.

Das mittlere Pad ist mit Masse verbunden.

Die äußeren Pads sind die Verbindung für den Kristall.

Schließen Sie den Kristall und die Kondensatoren an, wie ich es hier getan habe.

Eine schematische Darstellung findet sich im Datenblatt des ATmega328P.

Als nächstes müssen Sie einen 20MHz Bootloader erstellen.

Und hier wird es interessant.

Die neueste Version der Arduino IDE zum Zeitpunkt der Erstellung dieses Videos enthält nicht die Tools, die wir benötigen.

Um die richtigen Tools zu erhalten, muss die Arduino IDE Version 1.0.6 heruntergeladen werden.

Verwenden Sie der Einfachheit halber einfach die "Windows-ZIP-Datei für die Installation ohne Administratorrechte".

Entpacken Sie den heruntergeladenen Ordner und suchen Sie dieses Makefile.

Öffnen Sie es mit Notepad oder in meinem Fall Notepad++.

Kopieren Sie die ATmega328 Zeilen und nehmen Sie die Änderungen vor, die ich hier zeige (20MHz hinzufügen).

Ändern Sie die Baudrate auf 76,8 Kilo Baud und die AVR-Frequenz auf 20MHz.

Ändern Sie abschließend die Namen der Hex- und Lst-Dateien und speichern Sie das Makefile.

Wenn Sie Probleme beim Speichern der Datei haben, vergewissern Sie sich, dass die Datei nicht schreibgeschützt ist.

Öffnen Sie das Befehlszeilenfenster und navigieren Sie zum optiboot-Verzeichnis, in dem sich omake befindet.

Geben Sie nun omake atmega328_20MHz ein

Nach erfolgreichem Make werden Sie mit zwei neuen Dateien im optiboot-Verzeichnis belohnt.

Das einzige, was noch zu tun ist, ist die Datei boards.txt zu ändern, die hier zu finden ist.

Kopieren Sie die Arduino Uno-Board-Info und ändern Sie uno in uno_20MHz.

Ändern Sie den Namen und die Upload-Geschwindigkeit, wie ich es hier zeige.

Und jetzt wird es richtig interessant.

Wir müssen die richtigen Fuse-Bits setzen.

Dies liegt daran, dass der 16MHz Resonator durch einen 20MHz Quarz ersetzt wird.

Standardmäßig ist der ATmega328P des Arduino auf einen Low-Power-Quarzoszillator eingestellt.

Wie Sie dem Datenblatt entnehmen können, liegt der empfohlene Frequenzbereich bei bis zu 16MHz.

Damit der 20MHz Quarz zuverlässig arbeitet, muss er auf den Full Swing-Quarzoszillator umgestellt werden.

Dadurch wird der Frequenzbereich auf bis zu 20 MHz erweitert.

Denken Sie daran, dass ich sagte, dass der ATmega328P seit Anfang 2016 nicht mehr derselbe ist?

Dies liegt daran, dass Atmel den Full-Swing-Oszillator entfernt hat, wie Sie im Datenblatt lesen können.

Stellen Sie also sicher, dass Sie einen ATmega328P von 2015 oder früher haben.

Sie können das Datum anhand der Lasergravur auf der Verpackung überprüfen.

Dieser ATmega328P wurde 2014 in Woche 49 hergestellt.

Und dieser in 2013 in Woche 44 und dieses letzte Exemplar stammt aus 2015 in Woche 17.

Ok, zurück zum Full-Swing-Oszillator.

Im Datenblatt des ATmega328P finden wir detaillierte Informationen zu den Einstellungen.

Bei wirklichem Interesse kann man sich das gerne anschauen.

 Im Moment werde ich diesen Fuse-Bit-Rechner verwenden.

Ich werde einen Link zu dieser Seite in die Beschreibung setzen.

Um besser zu verstehen, was vor sich geht, werde ich zuerst die ursprünglichen 16MHz Arduino-Uno-Fuse-Bits setzen.

Niedrige Sicherung wird in hexadezimaler Form auf FF gesetzt.

Die hohe Sicherung wird in hexadezimaler Form auf DE gesetzt

Und schließlich werden die erweiterten Fuse-Bits in hexadezimaler Form auf 05 gesetzt.

Das Lustige an Sicherungsbits ist die Notation.

Unbenutzt oder nicht ausgewählt steht für eine 1.

Wenn eine Funktion ausgewählt ist, steht sie für eine 0.

Wie Sie sehen können, sind alle Low-Bit-Fuses ungeprüft.

Die Sicherung ist jedoch in hexadezimaler Form auf FF programmiert.

Das heißt alle Einsen in binärer Form.

Hier können wir den Full-Swing-Oszillator mit der längsten Anlaufzeit auswählen, um zuverlässige Ergebnisse zu erhalten.

Wie Sie sehen können, ist die Uhrauswahl 3-Sicherung jetzt eingestellt.

Dadurch wird das Low-Fuse-Bit auf F7 in hexadezimaler Form anstelle von FF geändert.

Der Rest der Fuse-Bits kann unberührt gelassen werden.

 In der Boards-Datei können wir nun die richtigen Fuse-Bits setzen.

Um den richtigen Bootloader zu verwenden, muss der Name des Bootloaders geändert werden.

Es muss derselbe Name wie die neue Bootloader-Datei sein, die zuvor erstellt wurde.

Und schließlich müssen Sie die richtige Taktfrequenz einstellen und die Board-Datei speichern.

So weit, ist es gut. Es ist Zeit, den Bootloader auf den ATmega328P hochzuladen.

Dazu benötigen wir den Arduino als ISP-Programmierer.

Der Vorgang zum Erstellen eines ISP-Programmierers wird auf dieser Seite ausführlich erläutert.

Ich werde diese Seite in der Beschreibung verlinken.

https://www.arduino.cc/en/Tutorial/ArduinoISP

Dies ist mein Arduino als ISP-Programmierer.

Es ist genau das gleiche wie auf der Arduino-Website beschrieben.

Der einzige Unterschied ist das Gehäuse und der ISP-Anschluss.

Und ich habe einen anderen Arduino als ISP-Programmierer verwendet, um diesen Arduino als ISP-Programmierer zu programmieren.

Auf diese Weise kann ich das Programm in diesem Programmer nicht versehentlich überschreiben.

Starten oder starten Sie also die Arduino IDE Version 1.0.6 neu und verbinden Sie den ISP-Programmierer mit dem Computer.

Klicken Sie auf Tools, Board und wählen Sie den 20-MHz-Arduino aus.

Wählen Sie den richtigen COM-Port des ISP-Programmierers und wählen Sie den Programmierer Arduino als ISP aus.

Klicken Sie auf Bootloader brennen.

Und das ist es.

Der 20MHz Arduino mit Bootloader ist nun fertig und es ist Zeit, das erste Programm hochzuladen.

Gehen Sie zu Beispiele > Basic und wählen Sie das Blinkprogramm aus.

Schließen Sie den 20-MHz-Arduino an Ihren Computer an.

Wählen Sie den 20 MHz Arduino Uno, wählen Sie den richtigen COM-Port und laden Sie die Blink-Skizze hoch.

Die LED auf dem Arduino Uno sollte jetzt anfangen zu blinken.

Dies ist nur ein Beispiel, da das Timing der Verzögerungsfunktion nicht richtig funktioniert.

Damit dies mit der Arduino IDE Version 1.6.11 funktioniert, müssen Sie den 20MHz Bootloader in das optiboot-Verzeichnis kopieren und die Datei board.txt dahin ändern.

An dieser Stelle fragen Sie sich vielleicht, warum die Arduino Uno-Boards mit 16MHz statt mit 20MHz laufen.

Einer der Gründe ist, dass die meisten Timing-Funktionen nur bei 8 oder 16 MHz korrekt funktionieren.

Was funktioniert also und was nicht? Grundsätzlich funktioniert alles im Datenblatt.

Zum Beispiel funktionieren I2C, SPI, Pulsweitenmodulation, serielle Kommunikation, EEPROM-Lesen / Schreiben, analoges Lesen, Interrupts usw. einwandfrei.

Solange die 20MHz Taktfrequenz berücksichtigt wird.

Was nicht richtig funktioniert, sind Codeteile, die auf den 16MHz Takt angewiesen sind.

Zum Beispiel die Arduino-Funktionen delay, millis und micros. delayMicroseconds funktioniert jedoch gut.

 Da es so viele Bibliotheken und Codebeispiele gibt, rate ich, es einfach auszuprobieren und zu prüfen, ob der Code auf 20MHz läuft.

Und läuft es wirklich schneller?

Lassen Sie uns mit diesem Programm einen einfachen Geschwindigkeitstest durchführen.

Wie Sie sehen können, führt es 500 Float-Berechnungen durch.

Vor den Berechnungen wird der Ausgang 13 hoch gesetzt.

Nach den Berechnungen wird der Ausgang niedrig gesetzt.

Wie bereits in einem anderen Video erklärt, beträgt die Zeit zum Setzen des Ausgangs 125 Nanosekunden.

Mit dem 16MHz Arduino beträgt die Gesamtzeit zum Beenden der 500 Float-Berechnungen 4,687 Millisekunden.

Der 20MHz Arduino führt die 500 Float-Berechnungen in nur 3,75 Millisekunden durch.

Dies ist in der Tat eine Geschwindigkeitssteigerung von 25 %.

Und damit endet dieses Video.

Vielen Dank fürs Zusehen und hinterlassen Sie Ihre Gedanken in den Kommentaren unten.

Quelle:

********************************************************I*

18.08.2022

Arduiono UNO 20Mhz

Üblicherweise wird hat der UNO einen 16MHz Resonator zur Takterzeugung eingebaut. Diesen ersetze ich hier durch einen 20MHz Quarz. Dazu sollte man nur UNOs mit ein Atmega328P in DIL Ausführung verwenden. Die SMD Version ist dazu eher ungeeignet. Die Info darüber ist hier im Internet verfügbar. Danke an den Verfasser für seinen Beitrag dafür. Ich verwende nur moderne aktuelle Atmega328P CPUs, welche mit 20MHz funktionieren.

Notwendige Arbeiten:
• BOOTLOADER - Mit Arduino IDE V. 1.0.6 den Bootloader für neue Hardware erstellen
• BOARDS - In die aktuelle Ardunio IDE die boards.txt anpassen
• HEXFILE - Blink.ino mit Arduino UNO 20Mhz als HexFile mit Bootloader erstellen
• ATMEGA328P - Das erstellte Hexfile in einen Atmege328P flashen
• HARDWARE - Arduino UNO Hardware umbauen
• TEST - mit Software

HARDWARE
Der UNO wird nicht verändert, es wird nur die CPU auf zwei DIL Sockel übereinander gesteckt, welche den neuen Quarz beinhalten.
Die Grundsoftware (bootloader) des Atmega328p muss aber unbedingt, neu für 20MHz erstellt werden. Dazu später in diesem Beitrag.

Es wird ein HC49 Quarz mit 20MHz und 2 Stk 22pF Kondensatoren an Pin 9 und 10 gelötet. Zwischensockel mit Modifikation

Fertige 20Mhz UNOs gibt es nicht zu kaufen, aber die Sache ist für Projekte mit eigener Platine und einem Atmega328P interessant, da man dann die maximale Takt Frequenz der CPU mit Arduino Software verwenden kann. Weiters muss die Arduino IDE diese neue Hardware dann unterstützen, damit dafür Software erstellt werden kann. Hierzu sind einige Anpassungen erforderlich.


BOOTLOADER
Für die Erstellung des Bootloaders brauchen wir einmalig die ältere Arduino IDE Version 1.06
Der neueren IDE Versionen fehlen hier einige Files um den make durchzuführen.
Die ältere IDE Version 1.0.6 kann man hier runterladen
www.arduino.cc/en/software/OldSoftwareReleases
Sollte man auf einem zweiten Rechner machen, da die Arduino Software mit der bereits installierten neueren Version kollidiert.
in

C:\Program Files (x86)\Arduino\hardware\arduino\bootloaders\optiboot

das File makefile edidieren,

Die atmega328 Sektion in eine neue Sektion atmega328_20MHz kopieren und diese Einträge AVR_FREQ, DBAUD_RATE und Namen dann so abändern.

AVR_FREQ = 20000000L

DBAUD_RATE=76800

atmega328_20.hex

atmega328_20.lst

Die Datei makefile speichern. In einem Shell Aufruf  omake atmega328_20Mhz   ausführen.

Es werden zwei Files erzeugt.
atmega328_20.hex

und
atmega328_20.lst

Diese Files für später sichern, dann kann man sich zukünftig den Rückschritt zur 1.06 Version sparen.

Zum Rechner mit aktuellen Arduino Version (hier V. 1.8.15) wechseln und die Files
atmega328_20.hex und atmega328_20.lst
nach

C:\Program Files (x86)\Arduino\hardware\arduino\avr\bootloaders\optiboot

zu kopieren.
(hier haben sich die Pfade, im Unterschied zur alten IDE, etwas verändert)

BOARDS
Ich habe die Version 1.8.15 der Arduino IDE verwendet.
In der aktueller Arduino IDE das File boards.txt anpassen

C:\Program Files (x86)\Arduino\hardware\arduino\avr

Die originale boards.txt als .bak zur Sicherheit sichern.

Die boards.txt mit Administrator Rechten editieren.
und diese Zeilen einfügen.

--------------------------------------------

uno_20MHz.name=Arduino Uno 20Mhz

uno_20MHz.upload.tool=avrdude

uno_20MHz.upload.protocol=arduino

uno_20MHz.upload.maximum_data_size=2048

uno_20MHz.upload.maximum_size=32256

uno_20MHz.upload.speed=76800

uno_20MHz.bootloader.low_fuses=0xFF

uno_20MHz.bootloader.high_fuses=0xDE

uno_20MHz.bootloader.extended_fuses=0x05

uno_20MHz.bootloader.file=optiboot/optiboot_atmega328_20MHz.hex

uno_20MHz.bootloader.unlock_bits=0x3F

uno_20MHz.bootloader.lock_bits=0x0F

uno_20MHz.build.mcu=atmega328p

uno_20MHz.build.f_cpu=20000000L

uno_20MHz.build.board=AVR_UNO_20MHz

uno_20MHz.build.core=arduino

uno_20MHz.build.variant=standard

---------------------------------------------

Arduino IDE neu starten
Die neue Hardware sollte nun in der Boards Liste angeboten werden.

Der neue 20MHZ UNO wird nun als Board angeboten.

HEXFILE
Inhalt ist bootloader + Applikation (blink)
In der Arduino IDE:
Hardware board "Arduino UNO 20MHz" definieren
Neues Projekt test starten und einfaches Programm blinkende LED einfügen.
compile und
dann per "export with bootloader" ein Hexfile erzeugen
Im Verzeichnis "test" der aktuellen INO Datei (Sketch) Liegen zwei Files test.ino.standard.hex und test.ino.with_bootloader.standard.hex
Die Datei mit dem Bootloader wird benötigt.

Der Bootloader ermöglicht das Flashen von Programmen aus der IDE heraus in den Speicher.

ATMEGA328P
Das erstellte Hexfile mit dem Bootloader wird mit einem Programmer in einen Atmega328P geflasht.

 Das muss nur einmal gemacht werden für eine neue CPU.

Hier werden die Fuses eingestellt und der Bootloader in die CPU geflasht.

Damit kann die CPU in einen UNO eingesetzt werden.
Die Applikation Blink.ino ist hier sekundär, da bei funktionierender Hardware nun immer über die IDE Software in den Speicher geladen wird.

Siehe auch mein Artikel über das Flashen AVR
Die Fuses werden für den UNO so eingestellt.

BODLEVEL = 2V7

RSTDISBL = [ ]

DWEN = [ ]

SPIEN = [X]

WDTON = [ ]

EESAVE = [X]

BOOTSZ = 256W_3F00

BOOTRST = [X]

CKDIV8 = [ ]

CKOUT = [ ]

SUT_CKSEL = EXTXOSC_8MHZ_XX_16KCK_14CK_65MS

EXTENDED = 0xFD (valid)

HIGH = 0xD6 (valid)

LOW = 0xFF (valid)

LB = NO_LOCK

BLB0 = NO_LOCK

BLB1 = LPM_SPM_DISABLE

Die geflashte CPU in die umgebaute Hardware einsetzen.

ATMEGA328P
Programm mit der IDE in den Speicher laden funktioniert.
Kommunikation via Serial Monitor OK
Bei Blink.ino blinkt die LED genauso schnell wie mit 16MHz CPU.
Meine Controldemo ist ohne Änderung gelaufen.

Vorsicht:

Ob alle Libraries und Funktionen die veränderte Taktrate unterstützen, kann im Vorhinein nicht gesagt werden.
Es ist eine offiziell nicht unterstütze Hardware, das soll einem bewusst sein.

Quelle:

http://www.saintummers.at/computer/arduino/uno20.html

Control Demo

Für einen Kollegen habe ich diese Steuerung entworfen, welche auf Tastendruck eine Pumpe startet.

Der Durchfluss wird per Impuls-Geber gezählt.

Die Pumpe wird per Schwimmerschalter gestoppt, wenn der gewünschte Pegel erreicht ist.

Während die Pumpe läuft wird Zeit und Durchfluss angezeigt.

Überwachung des Programmes erfolgt via Watchdog.

ControlDemo V1.01   Zeile1: Programm Version
count 1739                 Zeile2: Gezählte Impulse
sec      120                 Zeile3: abgelaufene Zeit
run                              Zeile4: Stati wie run, START und STOP

// Controldemo.ino// Autor: Heinrich Stummer 06/2022//interrupt, Millis, I2C Display, Debounce, und Watchdog Demo const char vers[20] = "ControlDemo V 1.01";//Watchdog #include <avr/wdt.h>//LCD#include <LiquidCrystal_I2C.h>LiquidCrystal_I2C lcd(0x27,20,4);//LEDconst byte ledrun = 13;       // Betriebs LED blinkenconst long duration = 100;    // milisekundenbyte ledstatus = LOW;//LCD Blinkconst byte lcdblinker = 1;         // Blinkender Punkt auf dem LCD - Siehe Aufruf 'blinker(speed, zeile, postion)'// cycleconst byte cycle = 8;             //Ausgang zur Periodendauer Messungbyte cc = 0;//MOTOR     Relais für Motorconst byte rel1 = 11;//Millisunsigned long oldMillis = 0;unsigned long myMillis = 0;unsigned long zeit = 0;unsigned long stime;// Start und Stop Buttonconst int pinstart = 7;     // Start Button pin 7const int pinstop = 6;      // Stop Button pin 6            zB: Schwimmer Niveauschalter 0 oder 1 unsigned long debdelay = 3;byte startbutton = HIGH;byte startstate = startbutton;            byte oldstartstate = startbutton;   unsigned long oldstartdebtime = 1;          // debouncetime , wichtig bei prellenden Tasten - wert etwas verlängernbyte stopbutton = HIGH;byte stopstate = stopbutton;            byte oldstopstate = stopbutton;   unsigned long oldstopdebtime = 1;// Zeit aktivbyte actrun = 0;            //actrun = 1 zeit läuft, // Counterconst byte intPin = 2;                 // Eingang vom Pumenrad  PIN2 = int0 beim Arduio UNO. Ein UNO hat nur zwei Int0 und int1 Eingängevolatile unsigned long wheel = 0;      // Impulse vom Pumpenrad// ***************  Hier die STOP Tasten  Logik 'oeffner'  oder 'schließer'   einstellen. entwender   0 oder 1    ***************// Notwendig zB. bei Schwimmersteuerung.const byte configstopbutton = 0;  // 0 is button pressed            Button ist 'schließer'  oder NormalOpen, NO// const byte configstopbutton = 1; // 1 is button released         Button ist 'oeffner'   oder NormalClose, NC//+++++++++++++++++++++++++++++++++++++++++++++++++++++++void  setup ( ){  pinMode(intPin, INPUT_PULLUP);  attachInterrupt(digitalPinToInterrupt(intPin),flowcount,RISING);  detachInterrupt(digitalPinToInterrupt(intPin));    pinMode(ledrun, OUTPUT);  pinMode(pinstart,INPUT_PULLUP);  pinMode(pinstop,INPUT_PULLUP);  pinMode(rel1, OUTPUT);  pinMode(cycle, OUTPUT);    lcd.init();  lcd.backlight();  Serial.begin(9600);  Serial.println(vers);     // Anzeige Programmversion am Terminal  lcd.setCursor(0,0);  lcd.print(vers);            // Anzeige Programmversion LCD Zeile 0      lcd.setCursor(0,1);  lcd.print("count ");  lcd.setCursor(0,2);  lcd.print("sec   ");   wdt_enable(WDTO_4S);       // Watchdog timeout  ca. 4 Sekunden ...}//+++++++++++++++++++++++++++++++++++++++++++++++++++++++void  loop (){    myMillis = millis();   //die gelaufenen Milisekunden lesen. Alle 49 Tage und 17Stunden gibt es hier einen Überlauf.  cyclecheck(cycle);    //Messung für Oszi an Pin cycle.... ca. 19Hz mit Ardunio UNO 16MHz  blinker(10,0,19);    // LED Blinken 100ms * 10 ist Sekunde,   LCD Punkt blinken auf Pos.19  Zeile 1  T_start();      // startbutton       ==> Starte Timer und enable interrupt für flowcounter - Timer und Flowcounter reset  T_stop();       // stopbutton        ==> Stop Timer und disable interrupt flowcounter   buttonanzeige(); // Status der Buttons an LCD Zeile 3  jobcontrol();    // Action start oder stop  runmotor();      // Motor steuern via actrun status    zeitanzeige();   // laufende Zeit LCD  an  LCD Zeile 2  flowanzeige();   // Impulse vom Counter  an LCD Zeile 1  isrunning();     // Anzeige Status am LCD  abhängig von actrun     wdt_reset();     // Watchdog reset, ...} //+++++++++++++++++++++++++++++++++++++++++++++++++++++++void jobcontrol(){          //starte - stop Timer und flowcounter durch startbuttun und stopbutton       if (startbutton == 0) {        // Start Button        if (actrun == 0){            zeit = 0;            wheel = 0;            actrun = 1;              // Motor wird via run-motor gestartet            lcd.setCursor(6,1);            lcd.print("              ");            lcd.setCursor(6,2);            lcd.print("              ");            stime = millis();      // aktuelle Zeit merken            attachInterrupt(digitalPinToInterrupt(intPin),flowcount,FALLING);        }     }    if (stopbutton == configstopbutton) {           // Stop Button  - Öffner oder Schliesser je nach Config..              detachInterrupt(digitalPinToInterrupt(intPin));         actrun = 0;     }}void runmotor(){   if (actrun == 1) {      digitalWrite(rel1,HIGH);   } else  {      digitalWrite(rel1,LOW);    }}   void flowanzeige(){                         //Show Flow counter  lcd.setCursor(6,1);   lcd.print(wheel); }void zeitanzeige(){                         //show time   if (actrun == 1) {      lcd.setCursor(6,2);      zeit = (millis()-stime)/1000;              lcd.print(zeit);    }}void isrunning(){                           //anzeige 'run' oder nicht   if (actrun == 1) {         lcd.setCursor(0,3);         lcd.print("run");   } else {         lcd.setCursor(0,3);         lcd.print("   ");   }}void buttonanzeige(){                        // Ausgabe Button Stati an LCDif (startbutton == 0){    lcd.setCursor(9,3);    lcd.print("START");  } else {    lcd.setCursor(9,3);    lcd.print("     ");  }  if (stopbutton == configstopbutton){    lcd.setCursor(16,3);    lcd.print("STOP");  } else {    lcd.setCursor(16,3);    lcd.print("    ");  }  }void cyclecheck(byte c) {   //Periodendauer Messung mit Oszi    digitalWrite(c,cc);      cc = ~cc;  }void flowcount(){                           // Zählt impulse von Flügelrad wenn Interrupt enabled ist    wheel++;}void T_start(){                              // Start Taste  int pinread = digitalRead(pinstart);  if (pinread != oldstartstate) {    oldstartdebtime = millis();  }  if ((millis() - oldstartdebtime) > debdelay) {    if (pinread != startstate) {      startstate = pinread;      startbutton  = startstate;    }  }  oldstartstate = pinread; }void T_stop(){                                // Stop Taste  int pinread = digitalRead(pinstop);  if (pinread != oldstopstate) {    oldstopdebtime = millis();  }  if ((millis() - oldstopdebtime) > debdelay) {    if (pinread != stopstate) {      stopstate = pinread;      stopbutton = stopstate;    }  }  oldstopstate = pinread; }void blinker(int dur, int zeile, int pos){                          // LED Blinken und Punkt Blinken am LCDif (dur < 1) dur = 1;if (myMillis - oldMillis >= duration * dur) {   oldMillis = myMillis;    if (ledstatus == LOW) {       ledstatus = HIGH;       if (lcdblinker == 1) {           lcd.setCursor(pos,zeile);           lcd.print(".");       }     } else {        ledstatus = LOW;       if (lcdblinker == 1) {           lcd.setCursor(pos,zeile);           lcd.print(" ");       }    }   digitalWrite(ledrun, ledstatus); }}

Quelle:

http://www.saintummers.at/computer/arduino/controldemo.html

Durchflussmessung mit Arduino Uno

Arduino Wasseruhr

https://www.aeq-web.com/arduino-flowmeter-durchfluss-menge-messen-wasseruhr/

Arduino Flowmeter

Wie man eine Wasseruhr baut und damit den aktuellen Durchfluss messen kann

https://www.youtube.com/watch?v=ptBleiQKvWc

Arduino Flowmeter

Durchfluss-Sensor mit Arduino u. LCD-Anzeige

https://www.youtube.com/watch?v=LcmfUzS_1CU

DIN A4 ausdrucken
********************************************************I*
Impressum: Fritz Prenninger, Haidestr. 11A, A-4600 Wels, Ober-Österreich, mailto:[email protected]
ENDE