<rotary.h> mit bool "ein" und Ausschalten.

[oldeurope O. (Gast)]

Ich habe den AD7C-VFO so erweitert, dass ich damit meinen
cquam-Modulator steuern kann.

Der Boolean "ein" Zeile 42, geht nach Tastendruck für eine
einstellbare Zeit HIGH, Zeile 169, schaltet die Displaybeleuchtung
und die Aussteuerungsanzeige ein.

Ich hätte das gerne so, dass auch der Rotary erst durch den
bool "ein" aktiviert wird.

Ich habe keine Ahnung wie diese Rotary.h da ausgewertet wird
und wo ich mit dem bool die Auswertung ein- und ausschalten
kann. Momentan kann ich bei dunklem Display die Frequenz
ändern, was ich nicht so toll finde.

Alternativ könnte ich den bool "ein" HIGH machen, wenn der
Rotary gedreht wird. Auch dazu erkenne ich nichts, was
ich in die if Bedingung Zeile 169 einbringen kann.

Bitte um Hilfe.

LG
old.

[Stefan F. (Gast)]

Die Formatierung des Code ist eine schlechte Zumutung. Wie oft hat da 
jemand von anderen Kopiert, um das so zu verunstalten?

Lasst uns den folgenden formatierten Quelltext als Diskussionsgrundlage 
verwenden:

#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <rotary.h>
#include <EEPROM.h>

LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE); // 27=A4=SDA, Pin28=A5=SCL

int volt = A1;                          // 24 Atmega Eingang Spannungskontrolle

int spg;
bool start, obi, unterspg, flagspg;
unsigned long unterspgstart, unterspgist;
unsigned long flagspgstart, flagspgist;
unsigned long unterspgverz = 21;

bool ul, uh, uth, utl, uts, us;
unsigned long startul, istul, startuh, istuh;

int sumeing = A3;                       // 26 Atmega Eingang Summensignal
int diffeing = A2;                      // 25 Atmega Eingang Differenzsignal

int c;
int d;
int L;
int R;

int rot = 13;                           // 19 Atmega  Anzeige Clippgrenze erreicht
int gelb = 12;                          // 18 Atmega  Anzeige Vollaussteuerung
int gruen = 7;                          // 13 Atmega  Anzeige Summensignal (Mono)
int blau = 4;                           // 6 Atmega  Anzeige Differenzsignal (Stereo)

bool clip;
unsigned long cstart;
unsigned long cist;
unsigned long causverz = 200;           // MF Clippanzeige

bool voll;
unsigned long vstart;
unsigned long vist;
unsigned long vausverz = 500;           // MF Vollaussteuerung

bool sum;
unsigned long sumstart;
unsigned long sumist;
unsigned long sumausverz = 1000;        // MF Summensignal

bool diff;
unsigned long diffstart;
unsigned long diffist;
unsigned long diffausverz = 1000;       // MF Differenzsignal

int pwmDuty;
long sineINC;

bool ein;
unsigned long einstart;
unsigned long einist;
unsigned long eindauer = 1200000;       //20min (nach Tastendruck)

bool button;
unsigned long buttonstart;
unsigned long buttonist;
unsigned long buttoneinverz = 1000;     //Tastverzögerung
unsigned long previoushMillis = 0;
const long intervalh = 1250;            //Sperrzeit Herztaster

long n;

//Setup some items
#define W_CLK 8                         // Pin 8 - connect to AD9850 module word load clock pin (CLK) 14 Atmega
#define FQ_UD 9                         // Pin 9 - connect to freq update pin (FQ)                    15 Atmega
#define DATA 10                         // Pin 10 - connect to serial data load pin (DATA)            16 Atmega
#define RESET 11                        // Pin 11 - connect to reset pin (RST)                        17 Atmega
#define pulseHigh(pin) {
    digitalWrite(pin, HIGH);
    digitalWrite(pin, LOW);
}

Rotary r = Rotary(2, 3);                // sets the pins the rotary encoder uses.  Must be interrupt pins.

int_fast32_t rx = 1233000;              // Starting frequency of VFO (1233KHz)
int_fast32_t rx2 = 1;                   // variable to hold the updated frequency
int_fast32_t increment = 9000;          // starting VFO update increment in HZ.
int buttonstate = 0;

String hertz = "Raster      9KHz";
int hertzPosition = 0;

byte ones, tens, hundreds, 
thousands, tenthousands, 
hundredthousands, millions;             //Placeholders

String freq;                            // string to hold the frequency
int_fast32_t timepassed = millis();     // int to hold the arduino miilis since startup

int memstatus = 1;                      // value to notify if memory is current or old. 0=old, 1=current.
int ForceFreq = 1;                      // Change this to 0 after you upload and run a working sketch to activate the EEPROM memory.  
                                        // YOU MUST PUT THIS BACK TO 0 AND UPLOAD THE SKETCH AGAIN AFTER STARTING FREQUENCY IS SET!


void setup() {
    pinMode(rot, OUTPUT);
    pinMode(gelb, OUTPUT);
    pinMode(gruen, OUTPUT);
    pinMode(blau, OUTPUT);
    pinMode(A0, INPUT);                 // Connect to a button that goes to GND on push

    digitalWrite(A0, HIGH);
    lcd.begin(16, 2);
    // lcd.backlight();

    PCICR |= (1 << PCIE2);
    PCMSK2 |= (1 << PCINT18) | (1 << PCINT19);
    sei();

    pinMode(FQ_UD, OUTPUT);
    pinMode(W_CLK, OUTPUT);
    pinMode(DATA, OUTPUT);
    pinMode(RESET, OUTPUT);

    pulseHigh(RESET);
    pulseHigh(W_CLK);
    pulseHigh(FQ_UD);                   // this pulse enables serial mode on the AD9850 - Datasheet page 12.

    lcd.setCursor(hertzPosition, 1);
    lcd.print(hertz);

    // Load the stored frequency  
    if (ForceFreq == 0) {
        freq = String(EEPROM.read(0)) + 
               String(EEPROM.read(1)) + 
               String(EEPROM.read(2)) + 
               String(EEPROM.read(3)) + 
               String(EEPROM.read(4)) + 
               String(EEPROM.read(5)) + 
               String(EEPROM.read(6));
        rx = freq.toInt();
    }
}



void loop() {

    /*    
    // Anzeige Unterspannung
    
    spg = analogRead (volt);

    if(millis() > 500) {
        start = HIGH;
    } 
    else {
        start = LOW;
    }
    if( spg < 292) {
        obi = HIGH;
    } 
    else {
        obi = LOW;
    }

    unterspg = obi && start;
    if(unterspg == LOW) {
        flagspgist = millis();
        if(flagspgist - flagspgstart > unterspgverz){
            flagspg = LOW;
        }
    }
    else {
        flagspgstart = millis(); 
        flagspg = HIGH;
    }
   
    if(flagspg == LOW) {
        istul = millis();
        if(istul - startul > unterspgverz){
            ul = LOW;
        }
    }
    else{
        startul = millis(); 
        ul = HIGH;
    } 
    
    utl = (ul && !flagspg);
 
    if(!flagspg == LOW) {
        istuh = millis();
        if(istuh - startuh > unterspgverz){
            uh = LOW;
        }
    }
    else {
        startuh = millis(); 
        uh = HIGH;
    }
    
    uth = (uh && flagspg);
    
    if(uth == HIGH) {
        lcd.setCursor(0,1); 
        lcd.print("Unterspannung   ");
    }
    
    if(utl == HIGH){
        lcd.setCursor(0,1); 
        lcd.print(hertz);
    } 
    
    // Ende Anzeige Unterspannung 
    */
    
    if (ein == HIGH) {
        lcd.backlight();
    } else {
        lcd.noBacklight();
    }
    
    c = analogRead(sumeing);
    c -= 511;                           // Nullinie wird von 511 auf 0 geschoben.
    
    d = analogRead(diffeing);
    d -= 511;                           // Nullinie wird von 511 auf 0 geschoben.
    
    R = (c + d);
    L = (c - d);
    
    if (R < -481 || R > 481 || 
        L < -481 || L > 481 || 
        d < -481 || d > 481) {
        clip = HIGH;
    }                                   // Clipp Abstand 30,
    else {
        clip = LOW;
    }
    
    if (clip == LOW)                    // MonoFlop für Clippanzeige
    {
        cist = millis();
        if (cist - cstart > causverz) {
            digitalWrite(rot, LOW);
        }
    } else {
        cstart = millis();
        digitalWrite(rot, HIGH);
    }
    
    if ((R < -356 || R > 356 || 
         L < -356 || L > 356 || 
         d < -179 || d > 179
        ) && ein) {
        voll = HIGH;
    } //Vollausst. (511*0,7) (255*0,7) >-3dB
    else {
        voll = LOW;
    }
    
    if (voll == LOW)                    // MonoFlop für Vollaussteuerungsanzeige
    {
        vist = millis();
        if (vist - vstart > vausverz) {
            digitalWrite(gelb, LOW);
        }
    } else {
        vstart = millis(); // 
        digitalWrite(gelb, HIGH);
    }
    
    if ((c < -50 || c > 50) && ein) {
        sum = HIGH;
    } else {
        sum = LOW;
    } //Summenanzeige
    
    if (sum == LOW)                     // MonoFlop für Summenanzeige
    {
        sumist = millis();
        if (sumist - sumstart > sumausverz) {
            digitalWrite(gruen, LOW);
        }
    } 
    else {
        sumstart = millis(); 
        digitalWrite(gruen, HIGH);
    }
    
    if ((d < -50 || d > 50) && ein) {
        diff = HIGH;
    } //Differenzsignal
    else {
        diff = LOW;
    }
    
    if (diff == LOW)                    // MonoFlop für Differenzsignalanzeige
    {
        diffist = millis();
        if (diffist - diffstart > diffausverz) {
            digitalWrite(blau, LOW);
        }
    } else {
        diffstart = millis(); 
        digitalWrite(blau, HIGH);
    }
    
    n = rx / 7843;
    analogWrite(6, n);                  // Spannung als funktion der Frequenz PWM an Pin11 Atmega
    pwmDuty = 128 + 126 * 
        sin(micros() * 0.000157);
    analogWrite(5, pwmDuty);            // 25Hz PWM an Pin12 Atmega
    
    if (rx != rx2) {
        showFreq();
        sendFrequency(rx);
        rx2 = rx;
    }
    
    buttonstate = digitalRead(A0);
    if (buttonstate == LOW) {
        buttonist = millis();
        if (buttonist - buttonstart > buttoneinverz) {
            button = LOW;
        }
    } else {
        buttonstart = millis();
        button = HIGH;
    }
    
    if (button == LOW) {
        setincrement();
    };
    
    if (buttonstate == HIGH) {
        einist = millis();              //Einschalten mit Tastendruck für Einschaltdauer.
        if (einist - einstart > eindauer) {
            ein = LOW;
        }
    } else {
        einstart = millis();
        ein = HIGH;
    }
    
    if (memstatus == 0) {               // Write the frequency to memory if not stored and 2 (10sek) seconds have passed since the last frequency change.
        if (timepassed + 10000 < millis()) {
            storeMEM();
        }
    }
}



ISR(PCINT2_vect) {
    unsigned char result = r.process();
    if (result) {
        if (result == DIR_CW) {
            rx = rx + increment;
        } else {
            rx = rx - increment;
        };
        if (rx >= 2000000) {
            rx = rx2;
        };                              // UPPER VFO LIMIT
        if (rx <= 100000) {
            rx = rx2;
        };                              // LOWER VFO LIMIT
    }
}



// frequency calc from datasheet page 8 
// = <sys clock> * <frequency tuning word>/2^32

void sendFrequency(double frequency) {
    int32_t freq = frequency * 
        4294967295 / 125000000;                     // 4294967295*2=8589934590 note 125 MHz clock on 9850.  
                                                    // You can make 'slight' tuning variations here by 
                                                    // adjusting the clock frequency.
    for (int b = 0; b < 4; b++, freq >>= 8) {
        tfr_byte(freq & 0xFF);
    }
    tfr_byte(0x000);                                // Final control byte, all 0 for 9850 chip
    pulseHigh(FQ_UD);                               // Done!  Should see output
}



// transfers a byte, a bit at a time, 
// LSB first to the 9850 via serial DATA line

void tfr_byte(byte data) {
    for (int i = 0; i < 8; i++, data >>= 1) {
        digitalWrite(DATA, data & 0x01);
        pulseHigh(W_CLK); //after each bit sent, CLK is pulsed high
    }
}



void setincrement() {
    unsigned long currenthMillis = millis(); //delay Herzbutton
    if (currenthMillis - previoushMillis >= intervalh) {
        previoushMillis = currenthMillis;
        
        if (increment == 9000) {
            increment = 1;
            hertz = "Raster       1Hz";
        } else if (increment == 1) {
            increment = 10;
            hertz = "Raster      10Hz";
        } else if (increment == 10) {
            increment = 100;
            hertz = "Raster     100Hz";
        } else if (increment == 100) {
            increment = 1000;
            hertz = "Raster      1KHz";
        } else if (increment == 1000) {
            increment = 10000;
            hertz = "Raster     10KHz";
        } else if (increment == 10000) {
            increment = 99000;
            hertz = "Raster     99KHz";
        } else if (increment == 99000) {
            increment = 100000;
            hertz = "Raster    100KHz";
        } else {
            increment = 9000;
            hertz = "Raster      9KHz";
        }
        
        lcd.setCursor(0, 1);
        lcd.print(hertz);
    }
}


void showFreq() {
    millions = int(rx / 1000000);
    hundredthousands = ((rx / 100000) % 10);
    tenthousands = ((rx / 10000) % 10);
    thousands = ((rx / 1000) % 10);
    hundreds = ((rx / 100) % 10);
    tens = ((rx / 10) % 10);
    ones = ((rx / 1) % 10);
    lcd.setCursor(0, 0);
    lcd.print("                ");
    
    if (millions > 9) {
        lcd.setCursor(1, 0);
    } else {
        lcd.setCursor(2, 0);
    }
    
    lcd.print(millions);
    lcd.print(".");
    lcd.print(hundredthousands);
    lcd.print(tenthousands);
    lcd.print(thousands);
    lcd.print(".");
    lcd.print(hundreds);
    lcd.print(tens);
    lcd.print(ones);
    lcd.print("  Hz  ");
    timepassed = millis();
    memstatus = 0; // Trigger memory write
};

void storeMEM() {
    //Write each frequency section to a EPROM slot. 
    // Yes, it's cheating but it works!
    EEPROM.write(0, millions);
    EEPROM.write(1, hundredthousands);
    EEPROM.write(2, tenthousands);
    EEPROM.write(3, thousands);
    EEPROM.write(4, hundreds);
    EEPROM.write(5, tens);
    EEPROM.write(6, ones);
    memstatus = 1; // Let program know memory has been written
};


/*
VFO code by Richard Visokey AD7C - www.ad7c.com
20190528, delay entfernt, Pilotton Sinus auf pin3Atmega
https://radio-bastler.de/forum/showthread.php?tid=8756&pid=154185#pid154185
20190614 Frequenzabhängige Steuerspannung auf pin11Atmega
20190906 I2C-Display https://www.instructables.com/id/How-to-Connect-I2C-Lcd-Display-to-Arduino-Uno/ 
20190920 Herztaster Tastverzögerung gegen versehentliches Antippen des Tasters.
20190924 Audiopegelanzeige mit LEDs
20190929 Unterspannungsanzeige
*/

Nächstes mal bitte selber aufräumen, bevor du andere um Hilfe bittest!

[Wolfgang (Gast)]

Aus der W. schrieb:
> Ich habe keine Ahnung wie diese Rotary.h da ausgewertet wird
> und wo ich mit dem bool die Auswertung ein- und ausschalten
> kann.

Woher sollen wir das wissen, was in deiner Rotary-Bibliothek passiert.
Für Details wirst du vermutlich auch nach einer Rotary.ino gucken 
müssen.

[Stefan F. (Gast)]

Wo wird denn hier der Rotary Encoder überhaupt benutzt? Ich sehe es 
nicht.

[Stefan F. (Gast)]

Ich glaube ich hab's: Vermutlich ist die ISR das Kernstück der Rotary 
encoder Abfrage. Vorschlag:

Ändere die bool Variable "ein" in den Typ "volatile bool". Und füge in 
die ISR ganz am Anfang eine Zeile ein:

if (!ein) return;

Warum das mit dem volatile sein muss, liest du am besten in der 
Dokumentation der avr-libc nach. Oder benutze die Suchfunktion dieses 
Forums. Das wird hier gefühlt jeden Monat erneut erklärt.

[oldeurope O. (Gast)]

Stefanus F. schrieb:
> Ich sehe es
> nicht.

Na wenn Du das nicht siehst, wie soll ich das dann schaffen?

Übrigens finde ich es total doof, dass Du den Code in Deinen
Beitrag kopiert hast. Dazu gibt es doch die Codeansicht.
(Leider ohne Zeilennummerierung, aber die hast Du ja auch nicht
drin.

LG
old.

[Wolfgang (Gast)]

Stefanus F. schrieb:
> Ändere die bool Variable "ein" in den Typ "volatile bool". Und füge in
> die ISR ganz am Anfang eine Zeile ein:
>
> if (!ein) return;

Da ist es wohl deutlich stilvoller, den Interrupt gar nicht erst 
freizugeben, i.e. das zugehörigen IE-Bit nur zu setzen, wenn der Encoder 
aktiv sein soll.

[Stefan F. (Gast)]

Aus der W. schrieb:
> Na wenn Du das nicht siehst, wie soll ich das dann schaffen?

Ich dachte du bist der Autor des Programms, dann musst du doch wissen, 
wie es funktioniert.

> Übrigens finde ich es total doof, dass Du den Code in Deinen
> Beitrag kopiert hast (statt anzuhängen)

Kritik angenommen

[oldeurope O. (Gast)]

Stefanus F. schrieb:
> Ich glaube ich hab's: Vermutlich ist die ISR das Kernstück der
> Rotary
> encoder Abfrage. Vorschlag:
>
> Ändere die bool Variable "ein" in den Typ "volatile bool". Und füge in
> die ISR ganz am Anfang eine Zeile ein:
>
> if (!ein) return;

Das hört sich gut an. Werde ich nachher probieren und berichten.

LG
old.

[oldeurope O. (Gast)]

Stefanus F. schrieb:
> if (!ein) return;

Wunderbar, klasse Lösung. Zeile 178

volatile ist nicht erforderlich.
Danke für "return"
https://www.arduino.cc/reference/de/language/structure/control-structure/return/
Warum muss return nicht in geschweifte Klammern?

LG
old.

[Stefan F. (Gast)]

Aus der W. schrieb:
> volatile ist nicht erforderlich.

Doch ist es. Ansonsten ist das Gelingen reine Glückssache.

Eine andere Compiler Version, oder ein paar Zeilen neuer Code an ganz 
anderer Stelle können sonst schon zum Versagen führen.

> Warum muss return nicht in geschweifte Klammern?

Klammern fassen Blöcke von Befehlen zusammen. Hier soll nach der 
Bedingung nur ein einziger Befehl ausgeführt werden, daher sind die 
Klammern optional. Wenn du den Code mit Klammern besser lesbar findest, 
dann füge sie hinzu. Auf der Arbeit muss ich das tun (gemeinsam 
abgestimmte Code-Style Regel).

[oldeurope O. (Gast)]

Also, ich habe jetzt die Klammern und das volatile hinzugefügt.
Keine Ahnung warum gerade dieser boolean das brauchen könnte und
die anderen booleans nicht. Jedenfalls funktioniert das so.

LG
old.

[Stefan F. (Gast)]

Aus der W. schrieb:
> Keine Ahnung warum gerade dieser boolean das brauchen könnte

Ich dachte ich hätte dich dazu animiert, es zu googeln.

Der Compiler berücksichtigt nicht, dass dein Programm durch Interrupts 
unterbrochen werden kann.

Wenn der Interrupt eine Variable liest, die das Hauptprogramm ändert 
(oder anders herum), kann zu eifriges Cachen in CPU Registern dazu 
führen, das die eine Seite (ISR) nicht sieht, was die andere Seite 
(Hauptprogramm) gemacht hat.

Volatile verhindert diesen Konflikt. Mehr Details bitte googeln, ich 
habe keine Lust das immer wieder durchzukauen.

[oldeurope O. (Gast)]

Also weil der <rotary.h> über Interrupts arbeitet, muss der
boolean da volatile sein. OK, merke ich mir.

Als nächstes versuche ich mal mit dem Rotary eine
Spannung über einen PWM-Pin zur Pegeleinstellung zu gewinnen.
Ich muss ein großes Tandempoti los werden.

LG
old.