Arduino, Frequenz mittels Encoder einstellen und ausgeben.

KaiR · 21. November 2022

Also bei mir funktioniert es:

Und die atomic.h ist dort zu finden:

Ich benutze nicht die Version aus dem App-Store! sondern die mit dem Windowsinstaller

Teckelfreund · 21. November 2022

Nein, es drängt mich nicht. Wichtig ist, dass ich auf meinem PC eine funktionsfähige Arduino IDE installiert habe. Es ist auch kein Problem, Arduino neu zu installieren. Ich bin auf das Ergebnis gespannt, wenn du den Sketch heute Abend mit deiner Arduino Umgebung getestet hast.

KaiR · 21. November 2022

Wie gesagt, ich werde es heute Abend mal mit meiner Arduino IDE (ebenfalls 1.819) ausprobieren. Üblicherweise benutze ich PlatformIO. Da funktioniert das anstandslos. Sonst hätte ich die Messungen ja auch nicht vornehmen können.

Wenn es dich so drängt, dann kommentiere die zwei ATOMIC_BLOCK Zeilen aus und schreibe das, was bei den Anweisungen zwischen den geschweiften Klammern steht, in eine eigene Zeile. Dann kommst Du ohne die Header Datei aus.

Also ICR1 = icr1; und OCR1A = ocr1a;

Sollte auch funktionieren…. ich habe ATOMIC_BLOCK nur als zusätzliche Sicherheit eingefügt, weil ich mir nicht sicher bin ob sich die 16Bit Werte immer schreiben lassen, ohne Interrupts kurz abzuschalten.

Teckelfreund · 21. November 2022

Hallo Kai,

ich habe Arduino1.8 .19 über Windows Store installiert, als ich mir den PC im Frühjahr gekauft habe.

Ich hatte schon das ganze AVR Verzeichnis durchsucht und auch die Arduino Corefiles. (hardware/ AVR /1.8.5 /cores / Arduino) Es gibt kein Verzeichnis /util mit der atomic.h Datei. Ich muss gestehen, mit dem Windows PC bin ich noch nicht so sehr vertraut, weil ich vorher immer mit einem Macbook PC gearbeitet habe.

KaiR · 21. November 2022

Achte darauf, den Sketch vollständig zu kopieren. Die atomic.h gehört zu den Arduino Corefiles und sollte vorhanden sein. Es muss nichts nachinstalliert werden.

Ich verwende die Arduino IDE nicht, aber wenn Software im WokWi-Simulator läuft und sich dort compilieren lässt, sollte sie auch in der Arduino IDE funktionieren. Ich werde das heute Abend mal mit der IDE prüfen.

Teckelfreund · 21. November 2022

Hallo Kai,

herzlichen Dank für deine große Mühe und Hilfsbereitschaft!

Nach dem Hochladen deines Sketch in den Arduino wird die Fehlermeldung "util/atomic.h: No such file or directory" angezeigt.

Die atomic.h sollte, wenn ich richtig gelesen und verstanden habe, in der AVR LIBc enthalten sein. Wenn ich diese im Arduino-Verzeichnis Libraries installieren will, erscheint der Hinweis, dass keine gültigen Dateien in der AVR LIB sind.

Grüße, Franz

KaiR · 20. November 2022

Ich habe mal eine kleine Klasse geschrieben mit der, neben der Frequenz, auch das Tastverhältnis von 0 bis 100% eingestellt werden.

Das zuvor in diesem Thread besprochene Programm habe ich entsprechend angepasst, dass beide Parameter über den Encoder eingegeben werden können.

Die Tone Bibliothek wird nicht mehr benötigt.

C

#include <RotaryEncoder.h>
#include <LiquidCrystal_I2C.h>
#include "Button.hpp"
/////////////////// Timer Klasse Anfang ////////////////////
#include <util/atomic.h>
constexpr uint16_t MAX_TOP{65535}; // 16 Bit Timer
constexpr uint16_t DEFAULT_HERTZ{1}; // In Hz
constexpr uint8_t DEFAULT_DUTYCYCLE{50}; // In %
class PwmTimer1 {
public:
static PwmTimer1& getInstance(){ // evil singleton
static PwmTimer1 instance;
// volatile uint8_t dummy{};
return instance;
}
PwmTimer1(const PwmTimer1 &) = delete; // prevent copy
PwmTimer1 &operator=(const PwmTimer1 &) = delete; // prevent assignment
void begin(uint16_t, uint8_t);
void setHz(uint16_t);
void setDutyCycle(uint8_t);
void startPwm();
void stopPwm();
private:
PwmTimer1() = default;
~PwmTimer1() = default;
uint16_t hertz;
const uint16_t psc[5]{1, 8, 64, 256, 1024};
uint8_t idx;
uint16_t icr1;
uint16_t ocr1a;
uint8_t dutyCycle;
};
void PwmTimer1::begin(uint16_t hz = DEFAULT_HERTZ, uint8_t dc = DEFAULT_DUTYCYCLE) {
DDRB |= _BV(PB1); // OCR1A Pin (PB1 / D9);
TCCR1A = _BV(COM1A1) | _BV(WGM11); // phase correct, clear ocr1a on compare match
TCCR1B = _BV(WGM13);
setHz(hz);
setDutyCycle(dc);
}
void PwmTimer1::setHz(uint16_t hz) {
hertz = hz;
idx=0;
icr1 = MAX_TOP;
// Find a suitable prescaler
for (auto p : psc) {
if ((F_CPU / (p * hertz)) <= MAX_TOP){
// Integer calculation with rounding up (one decimal place)
icr1 = static_cast<uint32_t>((((F_CPU * 10) / (2 * p * hertz)) + 5) / 10);
break;
}
++idx; // Needed for startPwm();
}
ATOMIC_BLOCK(ATOMIC_RESTORESTATE) { ICR1 = icr1; }
}
void PwmTimer1::setDutyCycle(uint8_t dc) {
if (dc > 100) {
dutyCycle = 100;
} else {
dutyCycle = dc;
}
ocr1a = (((static_cast<uint32_t>(icr1) * 10) * dutyCycle / 100) + 5) / 10;
ATOMIC_BLOCK(ATOMIC_RESTORESTATE) { OCR1A = ocr1a; }
}
void PwmTimer1::startPwm() {
TCCR1A |= _BV(COM1A1);
switch (idx) {
case 0: TCCR1B |= _BV(CS10); break;
case 1: TCCR1B |= _BV(CS11); break;
case 2: TCCR1B |= (_BV(CS11) | _BV(CS10)); break;
case 3: TCCR1B |= _BV(CS12); break;
case 4: TCCR1B |= (_BV(CS12) | _BV(CS10)); break;
default: break;
}
}
void PwmTimer1::stopPwm() {
TCCR1B &= ~(_BV(CS10) | _BV(CS11) | _BV(CS12));
TCCR1A &= ~(_BV(COM1A1));
PORTB &= ~(_BV(PB1)); // OCR1A Pin (PB1 / D9) to LOW
}
/////////////////// Timer Klasse Ende ////////////////////
constexpr byte MAX_HERTZ{15};
constexpr byte MIN_HERTZ{1};
constexpr byte pin_in1{2};
constexpr byte pin_in2{3};
constexpr byte pin_btn{4};
constexpr byte pin_led{13};
#ifndef LCD20x4
constexpr byte I2C_ADDR{0x27};
constexpr byte LCD_COLUMNS{16};
constexpr byte LCD_LINES{2};
#else
constexpr byte I2C_ADDR{0x3F};
constexpr byte LCD_COLUMNS{20};
constexpr byte LCD_LINES{4};
#endif
enum class ProgState : byte { adjust = 0, start, running, idle };
enum class InputState : byte { hertz = 0, duty };
struct EncoderData {
byte pos;
byte newPos;
byte hertz;
byte dutyc;
};
using namespace Btn;
ButtonSL btn{pin_btn};
LiquidCrystal_I2C lcd(I2C_ADDR, LCD_COLUMNS, LCD_LINES);
// RotaryEncoder encoder(pin_in1, pin_in2, RotaryEncoder::LatchMode::FOUR0);
RotaryEncoder encoder(pin_in1, pin_in2, RotaryEncoder::LatchMode::FOUR3);
//RotaryEncoder encoder(pin_in1, pin_in2, RotaryEncoder::LatchMode::TWO03);
EncoderData encData{0, 0, MIN_HERTZ, 50};
PwmTimer1& Pwm = PwmTimer1::getInstance();
bool askEncoder(EncoderData &, InputState);
void outputLcd(char*, EncoderData&, InputState);
void setup() {
Serial.begin(115200);
Serial.println("Start");
btn.begin();
btn.releaseOn();
btn.setDebounceTime_ms(150);
lcd.init();
lcd.backlight();
Pwm.begin(encData.hertz,encData.dutyc); // 1Hz, 50% Tastverhältnis
}
void loop() {
static bool lastBtnAction{false};
static char buffer[LCD_COLUMNS+1]; // Achtung: buffer an Textlänge + 1 anpassen. Sonst gibt es komische Effekte.
static ProgState state{ProgState::adjust};
static InputState inState{InputState::hertz};
if (askEncoder(encData, inState)) {
state = ProgState::adjust;
}
switch (state) {
case ProgState::adjust:
Pwm.stopPwm();
buffer[0] = ' ';
outputLcd(buffer, encData, inState);
state = ProgState::idle;
break;
case ProgState::start:
buffer[0] = 'R';
lcd.setCursor(0, 1);
lcd.print(buffer[0]);
state = ProgState::running;
[[fallthrough]] // https://en.cppreference.com/w/cpp/language/attributes/fallthrough
case ProgState::running:
Pwm.setHz(encData.hertz);
Pwm.setDutyCycle(encData.dutyc);
Pwm.startPwm();
state = ProgState::idle;
break;
default: break;
}
// Tasterabfrage
switch (btn.tick()) {
case ButtonState::longPressed:
lastBtnAction = !lastBtnAction;
if (lastBtnAction) {
state = ProgState::start; // Will swtich PWM on
} else {
state = ProgState::adjust; // Will switch PWM off
}
break;
case ButtonState::shortPressed:
switch(inState) {
case InputState::duty: inState = InputState::hertz; break;
case InputState::hertz: inState = InputState::duty; break;
default: break;
}
outputLcd(buffer, encData, inState);
break;
default: break;
}
}
bool askEncoder(EncoderData &data, InputState inState) {
encoder.tick();
data.newPos = encoder.getPosition();
if (data.pos != data.newPos) {
data.pos = data.newPos;
int dir = static_cast<int>(encoder.getDirection());
switch (inState) {
case InputState::hertz:
if (dir > 0) { data.hertz = (++data.hertz > MAX_HERTZ) ? MIN_HERTZ : data.hertz; }
if (dir < 0) { data.hertz = (--data.hertz < MIN_HERTZ) ? MAX_HERTZ : data.hertz; }
break;
case InputState::duty:
if (dir > 0) { data.dutyc = (++data.dutyc > 100) ? 0 : data.dutyc; } // 100% or less
if (dir < 0) { data.dutyc = (--data.dutyc > 100) ? 100 : data.dutyc; } // Unsigned! -1 becomes 255
break;
default: break;
}
return true;
}
return false;
}
void outputLcd(char *text, EncoderData &ed, InputState is) {
bool isRunning = (text[0] == 'R') ? true : false;
sprintf(text, "%3d Hz Tv: %3d%%", ed.hertz, ed.dutyc);
lcd.clear();
lcd.setCursor(0, 0);
lcd.print(text);
memset(text, 32, LCD_COLUMNS);
text[LCD_COLUMNS+1] = '\0';
switch (is) {
case InputState::hertz: text[2] = '^'; break;
case InputState::duty: text[14] = '^'; break;
default: break;
}
if (isRunning) { text[0] = 'R'; }
lcd.setCursor(0, 1);
lcd.print(text);
}

Alles anzeigen

Hier mal zwei Beispiele zur Ausgabe:

10Hz-50.PNG 12Hz-10.PNG

Links werden 10Hz mit 50% Tastverhältnis ausgegeben, rechts sind es 12Hz mit 15% Tastverhältnis.

Die Frequenzgenauigkeit hängt von Temperatur und Quarz des µControllers (evtl. auch vom Programm) ab. In meinem Beispiel ist die Frequenz etwas über 0,02 Hertz zu niedrig. Dafür ist der "Fehler" aber recht konstant. Der verwendete Modus ist "phasenkorrektes PWM" (Modus 10 nach ATmega Datenblatt Seite 109). Die Frequenzeingabe ist auf einen 16 Bit unsigned int Wert beschränkt. Somit wäre die maximal einstellbare Frequenz 65,535 KHz.

Ich habe mich in diesem Beispiel jedoch nur auf den, im vorherigen Programm behandelten, Frequenzbereich beschränkt.

Es wird der Timer1 des ATmega328P verwendet. Der Ausgabe-Pin ist auf D9 festgelegt. Das hängt mit dem verwendeten Timer-Mode zusammen und kann meines Wissens auch nicht so ohne weiteres geändert werden. Die Klasse funktioniert mit ATmega48A-PA ATmega 88A-PA ATmega 168A-PA und ATmega 328-P µControllern. In der "Arduinowelt" sind das der Nano, Uno und Pro-Mini.

Sollten Bibliotheken in einem Programm verwendet werden, die ebenfalls den Timer 1 verwenden dann "kracht" es. Funktionen wie millis() oder delay() sind davon aber nicht betroffen. Die werden durch Timer 0 gesteuert.

Wenn der Encoder nur kurz gedrückt wird (min. 150ms) wechselt die Eingabe zwischen den beiden Parametern Hertz und Tastverhältnis. Das drehen des Encoders ändert den ausgewählten Parameterwert. Gestartet wird die Frequenzausgabe, wenn der Encoder min. 1 Sekunde gedrückt wird.

Im vorliegenden Beispiel ist die Klassendefinition und das Hauptprogramm in einer Datei. Schöner ist es natürlich, dass in eine Header- und eine Programmdatei aufzuteilen.

Zum Ausprobieren:

https://wokwi.com/projects/348767179802411604

Knisterbein · 17. November 2022

Ich habe zwar keine Ahnung vom Arduino, aber ein Rechteck Signal mit einer definierten On/Off Zeit lässt sich, sieht man von einem leichten Jitter mal ab, leicht realisieren.

Ein Timer, der sagen wir mal mit einer Clock-Rate von 0.5mS zählt, löst immer dann einen Interrupt aus, wenn der Zähler den Wert (oder wenn man runter zählt 0) erreicht. In der Interrupt Routine wird dann die neue Zeit gesetzt und man wartet erneut, bis der Zähler das Ende erreicht hat.

Bei jedem erreichen der Ziel - Zeit wird gleichzeitig das Ausgangspin aktiviert oder deaktiviert.

Gruss

Pius

KaiR · 17. November 2022

Zitat

Könnte man das auch mit dem Tone Generator programmieren?

Meines Wissens nicht. Da ist das Tastverhältnis auf 50/50 festgelegt. Zumindest ist es so bei der Beschreibung der Tone Bibliothek beschrieben:

This is an Arduino Library to produce square-wave of the specified frequency (and 50% duty cycle) on any Arduino pin.

Zitat

Ist so eine Verschiebung überhaupt programmierbar?

Ja ist es.

Wie das geht, steht im Datenblatt des ATMega328 beschrieben. Da muss Du dich mit der Programmierung von Timern beschäftigen

Mit "normalen" Arduino Mitteln gibt es analogWrite(). Hier kann das Tastverhältnis einer Frequenz, die jedoch fest vorgegeben ist, verändert werden. Darum hilft das im vorliegenden Fall nicht. Andere Mittel sind mir nicht bekannt. Außer halt, einen Timer direkt über die Register des µControllers zu programmieren.

Teckelfreund · 17. November 2022

001.JPG

Hallo Kai ich wollte dir noch zeigen, wie schön das Signal von dem Generator ist. Auch mit einem Fluke gemessen stimmt die Frequenz genau.

Ich denke noch an eine Erweiterung.

Interessant wäre auch z.B. 12Hz = 83 ms Periode.

Dann ist das Signal 41,5 ms heigth und 41,5ms low.

Wenn das Signal aber Pro Periode einstellbar z.B 10ms hight und 73ms low sein soll. Könnte man das auch mit dem Tone Generator programmieren?

Ist so eine Verschiebung überhaupt programmierbar?

Grüße, Franz

KaiR · 16. November 2022

Freut mich das es klappt. Allerdings verstehe ich jetzt, beim letzten Schritt nicht wirklich, wo die Schwierigkeiten lagen, das mit der Tone Library und dem Programm zusammen zu bringen. Wenn Du Dir anschaust wo Generator.xxx eingefügt wurde, war das doch eigentlich ganz einfach .

Zitat

Deshalb habe ich in der Codezeile (ich meine Zeile 91)

const uint8_t PROGMEM tone_pin_to_timer_PGM[] = { 2, 1, 0 };

const uint8_t PROGMEM tone_pin_to_timer_PGM[] = { 1, 2, 0 };

OK. Das funktioniert in dem WokWi Simulator nicht, weil man dort nicht an die tone.cpp heran kommt.

Dann kannst Du aus dem Code die timeStamp Geschichte und doBlink ja auch herauswerfen. Das wird dann nicht mehr benötigt.

C

#include <RotaryEncoder.h>
#include <Tone.h>
/*
In Tone.cpp Codezeile 91 (oder 111)
const byte PROGMEM tone_pin_to_timer_PGM[] = { 2, 1, 0 };
in
const byte PROGMEM tone_pin_to_timer_PGM[] = { 1, 2, 0 };
ändern, damit Frequenzen < 32 Hz verwendet werden können.
*/
#include <LiquidCrystal_I2C.h>
#include "Button.hpp"
constexpr byte MAX_HERTZ{15};
constexpr byte MIN_HERTZ{1};
constexpr byte pin_in1{2};
constexpr byte pin_in2{3};
constexpr byte pin_btn{4};
constexpr byte pin_led{13};
constexpr byte I2C_ADDR{0x27};
constexpr byte LCD_COLUMNS{16};
constexpr byte LCD_LINES{2};
// constexpr byte I2C_ADDR{0x3F};
// constexpr byte LCD_COLUMNS{20};
// constexpr byte LCD_LINES{4};
enum class ProgState : byte { adjust = 0, start, running, stop, idle };
struct EncoderData {
byte pos;
byte newPos;
byte value;
};
LiquidCrystal_I2C lcd(I2C_ADDR, LCD_COLUMNS, LCD_LINES);
//RotaryEncoder encoder(pin_in1, pin_in2, RotaryEncoder::LatchMode::FOUR0);
RotaryEncoder encoder(pin_in1, pin_in2, RotaryEncoder::LatchMode::FOUR3);
// RotaryEncoder encoder(pin_in1, pin_in2, RotaryEncoder::LatchMode::TWO03);
Btn::Button btn{pin_btn};
EncoderData encData{0, 0, MIN_HERTZ};
Tone Generator;
void askEncoder(EncoderData &);
void setup() {
// Serial.begin(115200);
// Serial.println("Start");
btn.begin();
btn.setDebounceTime_ms(150);
lcd.init();
lcd.backlight();
Generator.begin(pin_led);
}
void loop() {
static bool lastBtnAction{false};
static byte oldValue{0};
static ProgState state{ProgState::adjust};
askEncoder(encData);
if (encData.value != oldValue) {
oldValue = encData.value;
state = ProgState::adjust;
}
switch (state) {
case ProgState::adjust:
Generator.stop();
char buffer[10]; // Achtung: buffer an Textlänge + 1 anpassen. Sonst gibt es komische Effekte.
sprintf(buffer, "%d Hz", encData.value);
lcd.clear();
lcd.setCursor(4, 0);
lcd.print(buffer);
lcd.setCursor(0, 1);
lcd.print("Aus...");
state = ProgState::idle;
break;
case ProgState::start:
lcd.setCursor(0, 1);
lcd.print("Ein...");
state = ProgState::running;
[[fallthrough]] // https://en.cppreference.com/w/cpp/language/attributes/fallthrough
case ProgState::running : Generator.play(encData.value);
state = ProgState::idle;
break;
default: break;
}
if (btn.tick()) { // Tasterabfrage
lastBtnAction = !lastBtnAction;
if (lastBtnAction) {
state = ProgState::start;
} else {
state = ProgState::adjust;
}
// Serial.println("Hertz übernommen");
}
}
void askEncoder(EncoderData &data) {
encoder.tick();
data.newPos = encoder.getPosition();
if (data.pos != data.newPos) {
data.pos = data.newPos;
int dir = static_cast<int>(encoder.getDirection());
if (dir > 0) { data.value = (++data.value > MAX_HERTZ) ? MIN_HERTZ : data.value; }
if (dir < 0) { data.value = (--data.value < MIN_HERTZ) ? MAX_HERTZ : data.value; }
}
}

Alles anzeigen

Teckelfreund · 16. November 2022

Kai, du bist der Größte!!

Es funktioniert super und auch genau.

Der Tonegenerator ist ToneLibrary-1.7.1

Dieser kann aber nur Frequenzen >32Hz.

Deshalb habe ich in der Codezeile (ich meine Zeile 91)

const uint8_t PROGMEM tone_pin_to_timer_PGM[] = { 2, 1, 0 };

const uint8_t PROGMEM tone_pin_to_timer_PGM[] = { 1, 2, 0 };

geändert.

Herzlichen Dank

Franz

KaiR · 16. November 2022

Dann musst du den Code schon korrekt kopieren. Ich habe den alten, auskommentierten Kram mal wieder raus geschmissen.

Teckelfreund · 16. November 2022

Beim kompilieren werden folgende Fehlermeldungen gelistet:

169:17: error: variable or field 'askEncoder' declared void

void askEncoder(EncoderData& data) {

^~~~~~~~~~~

neu:169:17: error: 'EncoderData' was not declared in this scope

neu:169:30: error: 'data' was not declared in this scope

void askEncoder(EncoderData& data) {

^~~~

C:\Users\fenge\OneDrive\Dokumente\Arduino\neu\neu.ino:169:30: note: suggested alternative: 'atan'

void askEncoder(EncoderData& data) {

^~~~

atan

neu:74:2: error: expected unqualified-id before '/' token

*/

^

neu:74:2: error: expected constructor, destructor, or type conversion before '/' token

neu:89:16: error: redefinition of 'constexpr const byte I2C_ADDR'

constexpr byte I2C_ADDR {0x27};

^~~~~~~~

C:\Users\fenge\OneDrive\Dokumente\Arduino\neu\neu.ino:18:16: note: 'constexpr const byte I2C_ADDR' previously defined here

constexpr byte I2C_ADDR {0x27};

^~~~~~~~

neu:90:16: error: redefinition of 'constexpr const byte LCD_COLUMNS'

constexpr byte LCD_COLUMNS {16};

^~~~~~~~~~~

C:\Users\fenge\OneDrive\Dokumente\Arduino\neu\neu.ino:19:16: note: 'constexpr const byte LCD_COLUMNS' previously defined here

constexpr byte LCD_COLUMNS {16};

^~~~~~~~~~~

neu:91:16: error: redefinition of 'constexpr const byte LCD_LINES'

constexpr byte LCD_LINES {2};

^~~~~~~~~

C:\Users\fenge\OneDrive\Dokumente\Arduino\neu\neu.ino:20:16: note: 'constexpr const byte LCD_LINES' previously defined here

constexpr byte LCD_LINES {2};

^~~~~~~~~

neu:101:23: error: redefinition of 'LiquidCrystal_I2C lcd'

LiquidCrystal_I2C lcd(I2C_ADDR, LCD_COLUMNS, LCD_LINES);

^~~~~~~~

C:\Users\fenge\OneDrive\Dokumente\Arduino\neu\neu.ino:21:19: note: 'LiquidCrystal_I2C lcd' previously declared here

LiquidCrystal_I2C lcd(I2C_ADDR, LCD_COLUMNS, LCD_LINES);

^~~

neu:102:1: error: 'RotaryEncoder' does not name a type; did you mean 'RotaryEncoder_h'?

RotaryEncoder encoder(pin_in1, pin_in2, RotaryEncoder::LatchMode::FOUR0);

^~~~~~~~~~~~~

RotaryEncoder_h

neu:106:6: error: redefinition of 'Tone Generator'

Tone Generator;

^~~~~~~~~

C:\Users\fenge\OneDrive\Dokumente\Arduino\neu\neu.ino:22:6: note: 'Tone Generator' previously declared here

Tone Generator;

^~~~~~~~~

C:\Users\fenge\OneDrive\Dokumente\Arduino\neu\neu.ino: In function 'void setup()':

neu:110:6: error: redefinition of 'void setup()'

void setup()

^~~~~

C:\Users\fenge\OneDrive\Dokumente\Arduino\neu\neu.ino:23:6: note: 'void setup()' previously defined here

void setup(){

^~~~~

C:\Users\fenge\OneDrive\Dokumente\Arduino\neu\neu.ino: In function 'void loop()':

neu:123:6: error: redefinition of 'void loop()'

void loop()

^~~~

C:\Users\fenge\OneDrive\Dokumente\Arduino\neu\neu.ino:32:6: note: 'void loop()' previously defined here

void loop(){

^~~~

neu:129:3: error: 'askEncoder' was not declared in this scope

askEncoder(encData);

^~~~~~~~~~

C:\Users\fenge\OneDrive\Dokumente\Arduino\neu\neu.ino: In function 'void askEncoder(EncoderData&)':

neu:170:3: error: 'encoder' was not declared in this scope

encoder.tick();

^~~~~~~

C:\Users\fenge\OneDrive\Dokumente\Arduino\neu\neu.ino:170:3: note: suggested alternative: 'askEncoder'

encoder.tick();

^~~~~~~

askEncoder

exit status 1

variable or field 'askEncoder' declared void

KaiR · 16. November 2022

Also ich habe das in WokWi jetzt zusammengefügt. Habe auch Deinen unten geposteten Sketch da laufen lassen. Da blinkt jedoch nichts. Nur Dauerleuchten.

Kann aber auch an der Simulation liegen. Oder an der verwendeten Tone Lib.

Jedenfalls kannst Du Dir den Code da abholen. Wenn es nicht funktioniert musst du halt weiter probieren..

Teckelfreund · 16. November 2022

Hallo Kai,

ich habe die Frequenz gemessen. Eingestellte z.B.12 Hz sind gemessen etwas schwankend 12,12 bis12,20 Hz.

Mit dem Tone Sketch ist die Frequenz nicht schwankend und genau. Ich habe das noch einmal getestet. Hier wird die Frequenz aus dem seriellen Monitor gelesen. (Siehe Sketch in #1 unten)

Danke für deine Hilfe.

Ich habe versucht beide Sketche zu verbinden, kriege das aber nicht hin.

Grüße, Franz

KaiR · 16. November 2022

Folgender Code lässt es Blinken:

C

#include <RotaryEncoder.h>
#include <LiquidCrystal_I2C.h>
#include "Button.hpp"
constexpr byte MAX_HERTZ {15};
constexpr byte MIN_HERTZ {1};
constexpr byte pin_in1 {2};
constexpr byte pin_in2 {3};
constexpr byte pin_btn {4};
constexpr byte pin_led {13};
constexpr byte I2C_ADDR {0x27};
constexpr byte LCD_COLUMNS {16};
constexpr byte LCD_LINES {2};
enum class ProgState : byte {adjust = 0, start, running, stop, idle};
struct EncoderData {
uint8_t pos;
uint8_t newPos;
uint8_t value;
};
LiquidCrystal_I2C lcd(I2C_ADDR, LCD_COLUMNS, LCD_LINES);
RotaryEncoder encoder(pin_in1, pin_in2, RotaryEncoder::LatchMode::FOUR0);
//RotaryEncoder encoder(pin_in1, pin_in2, RotaryEncoder::LatchMode::TWO03);
Btn::Button btn{pin_btn};
EncoderData encData {0, 0, MIN_HERTZ};
uint32_t timeStamp;
void setup()
{
Serial.begin(115200);
Serial.println("Start");
btn.begin();
btn.setDebounceTime_ms(150);
lcd.init();
lcd.backlight();
pinMode(pin_led,OUTPUT);
}
void loop()
{
static byte oldValue {1};
static ProgState state {ProgState::adjust};
static uint32_t duty_ms;
askEncoder(encData);
if (encData.value != oldValue) {
oldValue = encData.value;
state = ProgState::adjust;
}
switch (state) {
case ProgState::adjust:
digitalWrite(pin_led, LOW);
char buffer[10];
sprintf(buffer, "%d Hz", encData.value);
lcd.clear();
lcd.setCursor(4, 0);
lcd.print(buffer);
lcd.setCursor(0, 1);
lcd.print("Aus...");
state = ProgState::idle;
break;
case ProgState::start:
lcd.setCursor(0, 1);
lcd.print("Ein...");
state = ProgState::running;
duty_ms = 1000 / (encData.value << 1);
// duty_ms = (1000 / encData.value) / 2; // Entspicht obigem Ausdruck
Serial.print("Tastrate: ");Serial.print(duty_ms * 2);Serial.println(" ms");
timeStamp=millis();
break;
case ProgState::running:
doBlink(pin_led,duty_ms);
default:
break;
}
if (btn.tick()) { // Tasterabfrage
state = ProgState::start;
Serial.println("Hertz übernommen");
}
}
void askEncoder(EncoderData& data) {
encoder.tick();
data.newPos = encoder.getPosition();
if (data.pos != data.newPos) {
data.pos = data.newPos;
int dir = static_cast<int>(encoder.getDirection());
if (dir >= 0) {
data.value = (++data.value > MAX_HERTZ) ? MIN_HERTZ : data.value;
}
if (dir < 0) {
data.value = (--data.value < MIN_HERTZ) ? MAX_HERTZ : data.value;
}
}
}
void doBlink(uint8_t pin, uint32_t duty_ms) {
if (millis() - timeStamp >= duty_ms) {
digitalWrite(pin, !digitalRead(pin));
timeStamp=millis();
}
}

Alles anzeigen

Ist aber nicht besonders genau. Ein Frequenzgenerator ist das nicht . Aber so ungefähr geht es ...

Teckelfreund · 16. November 2022

Sorry, du hast recht.

KaiR · 16. November 2022

Zitat

Mir ist aufgefallen, dass in der Simulation der Taster an Pin 5 verdrahtet ist.

Nee, ist er nicht. Der Kontrast zwischen „Kabel“ und Controller ist etwas schwach. Die Verbindung macht an Pin 5 einen Knick und ist an Pin 4 angeschlossen.

Teckelfreund · 16. November 2022

Jetzt muss nur noch die LED am Ausgang 13 mit der eingestellten Frequenz blinken.

Mir ist aufgefallen, dass in der Simulation der Taster an Pin 5 verdrahtet ist.

Danke für deinen Code. Diesen Expertencode muss ich versuchen zu verstehen.

002.JPG

Teilen