// Programm für Arduino Giga mit Bildschirm
// Giga_008_Poti_Scala
// LED_PR1 = D51/PE5, LED_PR2 = D40/PE6, PR1 = A11/PA0_C, PR2 = A10/PA1_C

#include <Arduino_GigaDisplay_GFX.h>
#include <Arduino_GigaDisplay.h>
#include "Fonts/FreeMonoBold18pt7b.h"

GigaDisplay_GFX display; // create the object

#include <farbe16.h>

#define PR1 A11
#define PR2 A10
#define LED_PR1 51
#define LED_PR2 40
#define DRE_A   35
#define DRE_B   36
#define DRE_KN  34
#define GIGA_RED    86
#define GIGA_GREEN  87
#define GIGA_BLUE   88

// Einstellungen für Scala und Rahmen
#define SCALAEIN    0   // 1 = Scala eingeschaltet (Scala selbst, ohne Rahmen)
#define RAHMENEIN   1   // 1 = Rahmen eingeschaltet
#define MITME       2   // 1 = mittlere Marker eigene Größe, 0 = mittlere Marker allgemeine Größe
#define MITMETL     3   // 1 = mittlere Marker oben/links mit einer ungeraden Anzahl von Marker (und zwei Marker mit einer geraden Anzahl) eingeschaltet
#define MITMETR     4   // 1 = mittlere Marker unten/rechts mit einer ungeraden Anzahl von Marker (und zwei Marker mit einer geraden Anzahl) eingeschaltet
#define METLINKS    5   // 1 = alle Marker (außer mittleren) oben/links eingeschaltet
#define METRECHTS   6   // 1 = alle Marker (außer mittleren) unten/rechts eingeschaltet
#define ZIFLINKS    7   // 1 = Zeichen oben/links eingeschaltet
#define ZIFRECHTS   8   // 1 = Zeichen unten/rechts eingeschaltet
#define ZIFPOS      9   // 0 = Zeichenlage entsprechend Marker, 1 = Zeichenlage zwischen Marker
#define NULLUO      10  // 0 = Null unten/links, 1 = Null oben/rechts
#define VERTHOR     11  // 0 = vertikale Skala, 1 = horizontale Skala
#define GRUND       12  // leere Teil der Farbskala hat die Farbe 0 = Grundfarbe, 1 = Hintergrundfarbe
#define GRADIENT    13  // wirkende Teil der Skala: 0 = Scalafarbe, 1 = Gradient von Scalafarbeanf zu Scalafarbe

// Muster
/* ((0<<15)      // aus technischen Grund, unwirksam
  |(1<<SCALAEIN)   // 1 = Scala eingeschaltet (Scala selbst, ohne Rahmen)
  |(1<<RAHMENEIN)  // 1 = Rahmen eingeschaltet
  |(1<<MITME)      // 1 = mittlere Marker eigene Größe, 0 = mittlere Marker allgemeine Größe
  |(1<<MITMETL)    // 1 = mittlere Marker oben/links mit einer ungeraden Anzahl von Marker (und zwei Marker mit einer geraden Anzahl) eingeschaltet
  |(1<<MITMETR)    // 1 = mittlere Marker unten/rechts mit einer ungeraden Anzahl von Marker (und zwei Marker mit einer geraden Anzahl) eingeschaltet
  |(1<<METLINKS)   // 1 = alle Marker (außer mittleren) oben/links eingeschaltet
  |(1<<METRECHTS)  // 1 = alle Marker (außer mittleren) unten/rechts eingeschaltet
  |(1<<ZIFLINKS)   // 1 = Zeichen oben/links eingeschaltet
  |(1<<ZIFRECHTS)  // 1 = Zeichen unten/rechts eingeschaltet
  |(1<<ZIFPOS)     // 0 = Zeichenlage entsprechend Marker, 1 = Zeichenlage zwischen Marker
  |(1<<NULLUO)     // 0 = Null unten/links, 1 = Null oben/rechts
  |(1<<VERTHOR)    // 0 = vertikale Skala, 1 = horizontale Skala
  |(1<<GRUND)      // leere Teil der Farbskala hat die Farbe 0 = Grundfarbe, 1 = Hintergrundfarbe
  |(1<<GRADIENT)   // wirkende Teil der Skala: 0 = Scalafarbe, 1 = Gradient von Scalafarbeanf zu Scalafarbe
  ),   
*/

typedef struct{
  int16_t xo;  // x-Koordinaten (horizontal) der oberen linken Ecke der Skala (gesamt, mit Rahmen)
  int16_t yo;  // y-Koordinaten (vertikal) der oberen linken Ecke der Skala (gesamt, mit Rahmen)
  int16_t xu;  // x-Koordinaten (horizontal) der unteren rechten Ecke der Skala (gesamt, mit Rahmen)
  int16_t yu;  // y-Koordinaten (vertikal) der oberen linken Ecke der Skala (gesamt, mit Rahmen)
  float vollscala; // Vollscala-Wert
  uint16_t mode;  // Modi von Scala
  int16_t rahmendicke; // Rahmendicke
  uint8_t mzahl; // Anzahl des Markers
  int16_t m_metka; // Länge des mittleren Markers (vom Rahmen nach außen)
  int16_t m_mdicke;  // Dicke des mittleren Markers
  int16_t metka;  // Länge der anderen Marker (vom Rahmen nach außen)
  int16_t mdicke;   // Dicke der anderen Markers
  int16_t zifscala_xl;  // horizontale (vertikale) Einzug von den Rahmen links (oben)
  int16_t zifscala_yl;   // vertikale (horizontale) Korrektur anhand der Skalenmarkierungen links (oben)
  int16_t zifscala_xr;  // horizontaler (vertikaler) Einzug vom Rahmen für die Maßstabsangaben rechts (unten)
  int16_t zifscala_yr;   // vertikale (horizontale) Korrektur anhand der Skalenmarkierungen rechts (unten)
  int16_t anfzif;  // Nummer oben auf der Markierung
  int16_t difzif;  // Schrittweite der Zahlen
  uint16_t rahmenfarbe; // Rahmenfarbe
  uint16_t zifferfarbe; // Farbe der Zahlen
  uint16_t grundfarbe; // Farbe des leeren Teils der Skale
  uint16_t scalafarbe;  // die Farbe des wirkenden Teils der Skala, sowie die Farbe des Endes des relevanten Teils der Skala bei einer Gradientskala
  uint16_t scalafarbeanf;  // Farbe des Beginns des wirkenden Teils der Skala für eine Gradientskala
  uint16_t hintergrundfarbe;  // Die allgemeine Hintergrundfarbe des Bildschirms. Diese wird beispielsweise benötigt, um die Zahlen auf der Skala darzustellen
} scaladata;

uint16_t WERT_L, WERT_R;
long meintime = 0;
int16_t zaehler = 0;
long dauer = 0;


scaladata scala_linke = {   // Structur schaffen und inizialisieren
  600, // int16_t xo; x-Koordinaten (horizontal) der oberen linken Ecke der Skala (gesamt, mit Rahmen)
  35,  // int16_t yo; y-Koordinaten (vertikal) der oberen linken Ecke der Skala (gesamt, mit Rahmen)
  625, // int16_t xu; x-Koordinaten (horizontal) der unteren rechten Ecke der Skala (gesamt, mit Rahmen)
  475, // int16_t yu; y-Koordinaten (vertikal) der oberen linken Ecke der Skala (gesamt, mit Rahmen)
  1023.0, // float vollscala; Vollscala-Wert
  ((0<<15)      // aus technischen Grund, unwirksam
  |(1<<SCALAEIN)   // 1 = Scala eingeschaltet (Scala selbst, ohne Rahmen)
  |(1<<RAHMENEIN)  // 1 = Rahmen eingeschaltet
  |(1<<MITME)      // 1 = mittlere Marker eigene Größe, 0 = mittlere Marker allgemeine Größe
  |(1<<MITMETL)    // 1 = mittlere Marker oben/links mit einer ungeraden Anzahl von Marker (und zwei Marker mit einer geraden Anzahl) eingeschaltet
  |(1<<MITMETR)    // 1 = mittlere Marker unten/rechts mit einer ungeraden Anzahl von Marker (und zwei Marker mit einer geraden Anzahl) eingeschaltet
  |(1<<METLINKS)   // 1 = alle Marker (außer mittleren) oben/links eingeschaltet
  |(1<<METRECHTS)  // 1 = alle Marker (außer mittleren) unten/rechts eingeschaltet
  |(1<<ZIFLINKS)   // 1 = Zeichen oben/links eingeschaltet
  |(1<<ZIFRECHTS)  // 1 = Zeichen unten/rechts eingeschaltet
  |(1<<ZIFPOS)     // 0 = Zeichenlage entsprechend Marker, 1 = Zeichenlage zwischen Marker
//  |(1<<NULLUO)     // 0 = Null unten/links, 1 = Null oben/rechts
//  |(1<<VERTHOR)    // 0 = vertikale Skala, 1 = horizontale Skala
//  |(1<<GRUND)      // leere Teil der Farbskala hat die Farbe 0 = Grundfarbe, 1 = Hintergrundfarbe
  |(1<<GRADIENT)     // wirkende Teil der Skala: 0 = Scalafarbe, 1 = Gradient von Scalafarbeanf zu Scalafarbe
  ),   // uint16_t mode;  Modi von Scala 
  4, // int16_t rahmendicke; Rahmendicke
  14, // uint8_t mzahl; Anzahl des Markers
  14, // int16_t m_metka; Länge des mittleren Markers (vom Rahmen nach außen)
  4,  // int16_t m_mdicke; Dicke des mittleren Markers
  10,  // int16_t metka; Länge der anderen Marker (vom Rahmen nach außen)
  2,   // int16_t mdicke; Dicke der anderen Markers
  40,  // int16_t zifscala_xl;  // horizontale (vertikale) Einzug von den Rahmen links (oben)
  6,   // int16_t zifscala_yl;   // vertikale (horizontale) Korrektur anhand der Skalenmarkierungen links (oben)
  10,   // int16_t zifscala_xr;  // horizontaler (vertikaler) Einzug vom Rahmen für die Maßstabsangaben rechts (unten)
  6,   // int16_t zifscala_yr;   // vertikale (horizontale) Korrektur anhand der Skalenmarkierungen rechts (unten)
  6,   // int16_t anfzif;  // Nummer oben auf der Markierung
  -1,   // int16_t difzif;  // Schrittweite der Zahlen
  GELB, // uint16_t rahmenfarbe; Rahmenfarbe
  WASSER, // uint16_t zifferfarbe; Farbe der Zahlen
  BLAU, // uint16_t grundfarbe; Farbe des leeren Teils der Skale
  ROT,  // uint16_t scalafarbe; die Farbe des wirkenden Teils der Skala, sowie die Farbe des Endes des relevanten Teils der Skala bei einer Gradientskala
  GELB,  // uint16_t scalafarbeanf; Farbe des Beginns des wirkenden Teils der Skala für eine Gradientskala
  SCHWARZ  // uint16_t hintergrundfarbe; Die allgemeine Hintergrundfarbe des Bildschirms. Diese wird beispielsweise benötigt, um die Zahlen auf der Skala darzustellen

};

scaladata scala_rechte = {   // Structur schaffen und inizialisieren
  725, // int16_t xo; x-Koordinaten (horizontal) der oberen linken Ecke der Skala (gesamt, mit Rahmen)
  35,  // int16_t yo; y-Koordinaten (vertikal) der oberen linken Ecke der Skala (gesamt, mit Rahmen)
  750, // int16_t xu; x-Koordinaten (horizontal) der unteren rechten Ecke der Skala (gesamt, mit Rahmen)
  475, // int16_t yu; y-Koordinaten (vertikal) der oberen linken Ecke der Skala (gesamt, mit Rahmen)
  1023.0, // float vollscala; Vollscala-Wert
  ((0<<15)      // aus technischen Grund, unwirksam
  |(1<<SCALAEIN)   // 1 = Scala eingeschaltet (Scala selbst, ohne Rahmen)
  |(1<<RAHMENEIN)  // 1 = Rahmen eingeschaltet
  |(1<<MITME)      // 1 = mittlere Marker eigene Größe, 0 = mittlere Marker allgemeine Größe
  |(1<<MITMETL)    // 1 = mittlere Marker oben/links mit einer ungeraden Anzahl von Marker (und zwei Marker mit einer geraden Anzahl) eingeschaltet
  |(1<<MITMETR)    // 1 = mittlere Marker unten/rechts mit einer ungeraden Anzahl von Marker (und zwei Marker mit einer geraden Anzahl) eingeschaltet
  |(1<<METLINKS)   // 1 = alle Marker (außer mittleren) oben/links eingeschaltet
  |(1<<METRECHTS)  // 1 = alle Marker (außer mittleren) unten/rechts eingeschaltet
  |(1<<ZIFLINKS)   // 1 = Zeichen oben/links eingeschaltet
  |(1<<ZIFRECHTS)  // 1 = Zeichen unten/rechts eingeschaltet
//  |(1<<ZIFPOS)     // 0 = Zeichenlage entsprechend Marker, 1 = Zeichenlage zwischen Marker
//  |(1<<NULLUO)     // 0 = Null unten/links, 1 = Null oben/rechts
//  |(1<<VERTHOR)    // 0 = vertikale Skala, 1 = horizontale Skala
//  |(1<<GRUND)      // leere Teil der Farbskala hat die Farbe 0 = Grundfarbe, 1 = Hintergrundfarbe
//  |(1<<GRADIENT)   // wirkende Teil der Skala: 0 = Scalafarbe, 1 = Gradient von Scalafarbeanf zu Scalafarbe
  ),   // uint16_t mode;  Modi von Scala 
  4, // int16_t rahmendicke; Rahmendicke
  19, // uint8_t mzahl; Anzahl des Markers
  14, // int16_t m_metka; Länge des mittleren Markers (vom Rahmen nach außen)
  4,  // int16_t m_mdicke; Dicke des mittleren Markers
  10,  // int16_t metka; Länge der anderen Marker (vom Rahmen nach außen)
  2,   // int16_t mdicke; Dicke der anderen Markers
  45,  // int16_t zifscala_xl;  // horizontale (vertikale) Einzug von den Rahmen links (oben)
  6,   // int16_t zifscala_yl;   // vertikale (horizontale) Korrektur anhand der Skalenmarkierungen links (oben)
  20,   // int16_t zifscala_xr;  // horizontaler (vertikaler) Einzug vom Rahmen für die Maßstabsangaben rechts (unten)
  6,   // int16_t zifscala_yr;   // vertikale (horizontale) Korrektur anhand der Skalenmarkierungen rechts (unten)
  9,    // int16_t anfzif;  // Nummer oben auf der Markierung
  -1,    // int16_t difzif;  // Schrittweite der Zahlen
  GELB, // uint16_t rahmenfarbe; Rahmenfarbe
  WASSER, // uint16_t zifferfarbe; Farbe der Zahlen
  BLAU, // uint16_t grundfarbe; Farbe des leeren Teils der Skale
  ROT,  // uint16_t scalafarbe; die Farbe des wirkenden Teils der Skala, sowie die Farbe des Endes des relevanten Teils der Skala bei einer Gradientskala
  HELLGRUEN,  // uint16_t scalafarbeanf; Farbe des Beginns des wirkenden Teils der Skala für eine Gradientskala
  SCHWARZ  // uint16_t hintergrundfarbe; Die allgemeine Hintergrundfarbe des Bildschirms. Diese wird beispielsweise benötigt, um die Zahlen auf der Skala darzustellen
};

scaladata scala_unten = {   // Structur schaffen und inizialisieren
  200, // int16_t xo; x-Koordinaten (horizontal) der oberen linken Ecke der Skala (gesamt, mit Rahmen)
  420,  // int16_t yo; y-Koordinaten (vertikal) der oberen linken Ecke der Skala (gesamt, mit Rahmen)
  520, // int16_t xu; x-Koordinaten (horizontal) der unteren rechten Ecke der Skala (gesamt, mit Rahmen)
  445, // int16_t yu; y-Koordinaten (vertikal) der oberen linken Ecke der Skala (gesamt, mit Rahmen)
  1023.0, // float vollscala; Vollscala-Wert
  ((0<<15)      // aus technischen Grund, unwirksam
  |(1<<SCALAEIN)   // 1 = Scala eingeschaltet (Scala selbst, ohne Rahmen)
  |(1<<RAHMENEIN)  // 1 = Rahmen eingeschaltet
  |(1<<MITME)      // 1 = mittlere Marker eigene Größe, 0 = mittlere Marker allgemeine Größe
  |(1<<MITMETL)    // 1 = mittlere Marker oben/links mit einer ungeraden Anzahl von Marker (und zwei Marker mit einer geraden Anzahl) eingeschaltet
  |(1<<MITMETR)    // 1 = mittlere Marker unten/rechts mit einer ungeraden Anzahl von Marker (und zwei Marker mit einer geraden Anzahl) eingeschaltet
  |(1<<METLINKS)   // 1 = alle Marker (außer mittleren) oben/links eingeschaltet
  |(1<<METRECHTS)  // 1 = alle Marker (außer mittleren) unten/rechts eingeschaltet
  |(1<<ZIFLINKS)   // 1 = Zeichen oben/links eingeschaltet
  |(1<<ZIFRECHTS)  // 1 = Zeichen unten/rechts eingeschaltet
//  |(1<<ZIFPOS)     // 0 = Zeichenlage entsprechend Marker, 1 = Zeichenlage zwischen Marker
//  |(1<<NULLUO)     // 0 = Null unten/links, 1 = Null oben/rechts
  |(1<<VERTHOR)    // 0 = vertikale Skala, 1 = horizontale Skala
//  |(1<<GRUND)      // leere Teil der Farbskala hat die Farbe 0 = Grundfarbe, 1 = Hintergrundfarbe
  |(1<<GRADIENT)     // wirkende Teil der Skala: 0 = Scalafarbe, 1 = Gradient von Scalafarbeanf zu Scalafarbe
  ),   // uint16_t mode;  Modi von Scala 
  4, // int16_t rahmendicke; Rahmendicke
  9, // uint8_t mzahl; Anzahl des Markers
  14, // int16_t m_metka; Länge des mittleren Markers (vom Rahmen nach außen)
  4,  // int16_t m_mdicke; Dicke des mittleren Markers
  10,  // int16_t metka; Länge der anderen Marker (vom Rahmen nach außen)
  2,   // int16_t mdicke; Dicke der anderen Markers
  32,  // int16_t zifscala_xl;  // horizontale (vertikale) Einzug von den Rahmen links (oben)
  -14,   // int16_t zifscala_yl;   // vertikale (horizontale) Korrektur anhand der Skalenmarkierungen links (oben)
  18,   // int16_t zifscala_xr;  // horizontaler (vertikaler) Einzug vom Rahmen für die Maßstabsangaben rechts (unten)
  -14,   // int16_t zifscala_yr;   // vertikale (horizontale) Korrektur anhand der Skalenmarkierungen rechts (unten)
  4,    // int16_t anfzif;  // Nummer oben auf der Markierung
  -1,    // int16_t difzif;  // Schrittweite der Zahlen
  GELB, // uint16_t rahmenfarbe; Rahmenfarbe
  WASSER, // uint16_t zifferfarbe; Farbe der Zahlen
  BLAU, // uint16_t grundfarbe; Farbe des leeren Teils der Skale
  ROT,  // uint16_t scalafarbe; die Farbe des wirkenden Teils der Skala, sowie die Farbe des Endes des relevanten Teils der Skala bei einer Gradientskala
  HELLGRUEN,  // uint16_t scalafarbeanf; Farbe des Beginns des wirkenden Teils der Skala für eine Gradientskala
  SCHWARZ  // uint16_t hintergrundfarbe; Die allgemeine Hintergrundfarbe des Bildschirms. Diese wird beispielsweise benötigt, um die Zahlen auf der Skala darzustellen
};

// Hilfsfunktionen
// Modi der Scala einstellen
void set_scala_mode(scaladata *userscala, uint16_t mode){
  userscala->mode |= mode;
}

void reset_scala_mode(scaladata *userscala, uint16_t mode){
  userscala->mode &= ~(mode);
}

void ust_scala_mode(scaladata *userscala, uint16_t mode){
  userscala->mode = mode;
}

uint16_t get_scala_mode(scaladata *userscala, uint16_t mode){
  return userscala->mode & mode;
}

// Hilfsfunktion
// Rahmen zeichnen. einaus: wenn 0, Hintergrundfarbe benutzen (Rahmen vom Bildschirm löschen)
void scala_rahmen(scaladata *userscala, uint8_t einaus){

    uint16_t mode = userscala->mode;
    // xo,yo,xu-xo+1,yu-yo+1,rahmendicke = dicke,rahmenfarbe = farbe
    if((mode & (1<<RAHMENEIN)) == 0) return;

    int16_t rdicke = userscala->rahmendicke;
    if(rdicke < 1){ return; }

    int16_t xo = userscala->xo;
    int16_t xu = userscala->xu;
    int16_t yo = userscala->yo;
    int16_t yu = userscala->yu;
    uint16_t farbe = userscala->hintergrundfarbe;
    if(einaus) farbe = userscala->rahmenfarbe; 
    
    if(rdicke < 2){   // wenn 1 Pixel
      display.drawRect(xo,yo,xu-xo+1,yu-yo+1,farbe);
    }else{  // wenn mehr als 1 Pixel
      int16_t breite = xu-xo+1;
      int16_t hoehe = yu-yo+1;
      display.fillRect(xo,yo,rdicke,hoehe,farbe); // links
      display.fillRect(xo+breite-rdicke,yo,rdicke,hoehe,farbe); // rechts
      display.fillRect(xo+rdicke,yo,breite-rdicke*2,rdicke,farbe); // obere
      display.fillRect(xo+rdicke,yo+hoehe-rdicke,breite-rdicke*2,rdicke,farbe); // untere
    }
}

// Hilfsfunktion
// Marker in der Mitte zeichnen  einaus: wenn 0, Hintergrundfarbe benutzen (Marker vom Bildschirm löschen)
void scala_m_metka(scaladata *userscala, uint8_t einaus){

  uint16_t mode = userscala->mode;
    // wenn mittlere Marker von keiner Seite eingeschaltet, aus
  if(((mode & (1<<MITMETL)) == 0) && ((mode & (1<<MITMETR))) == 0) return;

  uint16_t farbe = userscala->hintergrundfarbe;
    if(einaus) farbe = userscala->rahmenfarbe; 
  int16_t xo = userscala->xo;
  int16_t xu = userscala->xu;
  int16_t yo = userscala->yo;
  int16_t yu = userscala->yu;
  int16_t rdicke = userscala->rahmendicke;
  uint8_t mzahl = userscala->mzahl;
  int16_t m_metka;
  int16_t m_mdicke;
  if(mode & (1<<MITME)){   // wenn eigene Größe mittleres Markers
    m_metka = userscala->m_metka;
    m_mdicke = userscala->m_mdicke;
  }else{
    m_metka = userscala->metka;
    m_mdicke = userscala->mdicke;
  }

  if(mode & (1<<VERTHOR)){ // horizontal
    int16_t ym = yo-m_metka; // obere y-Koordinate des oberen Markers
    int16_t ymu = yu+1;   // obere y-Koordinate des unteren Markers
    if(mzahl % 2){ // wenn eine ungerade Anzahl von Marker
        int16_t xm = xo+(xu-xo+1-m_mdicke)/2; // obere x-Koordinate des Markers
        if(mode & (1<<MITMETL)){  // wenn obere mittlere Marker ein
            display.fillRect(xm,ym,m_mdicke,m_metka,farbe); // oberhalb des Rahmens
        }
        if(mode & (1<<MITMETR)){  // wenn untere mittlere Marker ein
            display.fillRect(xm,ymu,m_mdicke,m_metka,farbe); // unterhalb des Rahmens
        }
    }else{ // wenn eine gerade Anzahl von Marker
        int16_t diff = (xu-xo-2*rdicke)/(mzahl - 1); // zwischen Marker
        int16_t xml = xo+(xu-xo+1-m_mdicke)/2 - diff/2; // linke x-Koordinate des linken Markers
        int16_t xmr = xo+(xu-xo+1-m_mdicke)/2 + diff/2; // linke x-Koordinate der rechten Markers
        if(mode & (1<<MITMETL)){  // wenn obere mittlere Marker ein
            display.fillRect(xml,ym,m_mdicke,m_metka,farbe); // links, oberhalb des Rahmens
            display.fillRect(xmr,ym,m_mdicke,m_metka,farbe); // rechts, oberhalb des Rahmens
        }
        if(mode & (1<<MITMETR)){  // wenn untere mittlere Marker ein
            display.fillRect(xml,ymu,m_mdicke,m_metka,farbe); // links, unterhalb des Rahmens
            display.fillRect(xmr,ymu,m_mdicke,m_metka,farbe); // rechts, unterhalb des Rahmens
        }
    }  
  }else{ // vertikal
    int16_t xm = xo-m_metka; // obere x-Koordinate des linken Markers
    int16_t xmr = xu+1;   // obere x-Koordinate des rechten Markers
    if(mzahl % 2){ // wenn eine ungerade Anzahl von Marker
        int16_t ym = yo+(yu-yo+1-m_mdicke)/2; // obere y-Koordinate des Markers
        if(mode & (1<<MITMETL)){  // wenn linke mittlere Marker eingschaltet
            display.fillRect(xm,ym,m_metka,m_mdicke,farbe); // links von Rahmen
        }
        if(mode & (1<<MITMETR)){  // wenn rechte mittlere Marker eingschaltet
            display.fillRect(xmr,ym,m_metka,m_mdicke,farbe); // rechts von Rahmen
        }  
    }else{ // wenn eine gerade Anzahl von Marker
        int16_t diff = (yu-yo-2*rdicke)/(mzahl - 1); // zwischen Marker
        int16_t ymo = yo+(yu-yo+1-m_mdicke)/2 + diff/2; // Linke y-Koordinate des oberen mittleren Markers
        int16_t ymu = yo+(yu-yo+1-m_mdicke)/2 - diff/2; // Linke y-Koordinate des unteren mittleren Markers
        if(mode & (1<<MITMETL)){  // wenn linke mittlere Marker eingschaltet
            display.fillRect(xm,ymo,m_metka,m_mdicke,farbe); // oben, links von Rahmen
            display.fillRect(xm,ymu,m_metka,m_mdicke,farbe); // unten, links von Rahmen
        }
        if(mode & (1<<MITMETR)){  // wenn rechte mittlere Marker eingschaltet
            display.fillRect(xmr,ymo,m_metka,m_mdicke,farbe); // oben, rechts von Rahmen
            display.fillRect(xmr,ymu,m_metka,m_mdicke,farbe); // unten, rechts von Rahmen
        }  
    } 
  }
}

// Hilfsfunktion
// Marker (außer mittleren) zeichnen  einaus: wenn 0, Hintergrundfarbe benutzen (Marker vom Bildschirm löschen)
void scala_metka(scaladata *userscala, uint8_t einaus){
  uint16_t mode = userscala->mode;
    // wenn Marker weder linls noch rechts eingeschaltet, aus
  if(((mode & (1<<METLINKS)) == 0) && ((mode & (1<<METRECHTS))) == 0) return;

  uint16_t farbe = userscala->hintergrundfarbe;
    if(einaus) farbe = userscala->rahmenfarbe; 

  int16_t xo = userscala->xo;
  int16_t xu = userscala->xu;
  int16_t yo = userscala->yo;
  int16_t yu = userscala->yu;
  int16_t rdicke = userscala->rahmendicke;
  uint8_t mzahl = userscala->mzahl;
  int16_t metka = userscala->metka;
  int16_t mdicke = userscala->mdicke;
  int16_t innenscala = (yu - yo) - 2 * rdicke;  // Höhe (Länge) der Skala ohne Rahmen, vertikale Scala
    if(mode & (1<<VERTHOR)){ innenscala = (xu - xo) - 2 * rdicke;  } // Horizontale Scala

// горизонтальная
  if(mode & (1<<VERTHOR)){  // horizontal
    int16_t mitte = (xo + xu - mdicke) / 2;
    int16_t ymo = yo - metka;
    int16_t diff = (xu-xo-2*rdicke)/(mzahl - 1); // Scala zwischen Marker
    if(mzahl % 2){  // Bei einer ungeraden Anzahl von Marker von der Mitte nach oben und unten
      if(mode & (1<<METLINKS)){ // wenn obere Marker ein
        for(int16_t i = mitte+diff;i<xu-mdicke;i+=diff){
          display.fillRect(i,ymo,mdicke,metka,farbe);
        }
        for(int16_t i = mitte-diff;i>xo+mdicke;i-=diff){
         display.fillRect(i,ymo,mdicke,metka,farbe);
        }
      }
      if(mode & (1<<METRECHTS)){ // wenn untere Marker ein
        for(int16_t i = mitte+diff;i<xu-mdicke;i+=diff){
          display.fillRect(i,yu,mdicke,metka,farbe);
        }
        for(int16_t i = mitte-diff;i>xo+mdicke;i-=diff){
         display.fillRect(i,yu,mdicke,metka,farbe);
        }
      }
    }else{  // Bei einer geraden Anzahl von Marker von der Mitte nach oben und unten, erste Marker überspringen
      if(mode & (1<<METLINKS)){ // wenn obere Marker ein
        for(int16_t i = mitte+diff+diff/2;i<xu-mdicke;i+=diff){
          display.fillRect(i,ymo,mdicke,metka,farbe);
        }
        for(int16_t i = mitte-diff-diff/2;i>xo+mdicke;i-=diff){
         display.fillRect(i,ymo,mdicke,metka,farbe);
        }
      }
      if(mode & (1<<METRECHTS)){ // wenn untere Marker ein
        for(int16_t i = mitte+diff+diff/2;i<xu-mdicke;i+=diff){
          display.fillRect(i,yu,mdicke,metka,farbe);
        }
        for(int16_t i = mitte-diff-diff/2;i>xo+mdicke;i-=diff){
         display.fillRect(i,yu,mdicke,metka,farbe);
        }
      }
    }
  }else{ // vertikal
    int16_t mitte = (yo + yu - mdicke) / 2;
    int16_t xmo = xo - metka;
    int16_t diff = (yu-yo-2*rdicke)/(mzahl - 1); // Scala zwischen Marker
    if(mzahl % 2){  // Bei einer ungeraden Anzahl von Marker von der Mitte nach oben und unten
      if(mode & (1<<METLINKS)){ // wenn linke Marker ein
        for(int16_t i = mitte+diff;i<yu-mdicke;i+=diff){
          display.fillRect(xmo,i,metka,mdicke,farbe);
        }
        for(int16_t i = mitte-diff;i>yo+mdicke;i-=diff){
         display.fillRect(xmo,i,metka,mdicke,farbe);
        }
      }
      if(mode & (1<<METRECHTS)){ // wenn rechte Marker ein
        for(int16_t i = mitte+diff;i<yu-mdicke;i+=diff){
          display.fillRect(xu,i,metka,mdicke,farbe);
        }
        for(int16_t i = mitte-diff;i>yo+mdicke;i-=diff){
         display.fillRect(xu,i,metka,mdicke,farbe);
        }
      }
    }else{  // Bei einer geraden Anzahl von Marker von der Mitte nach oben und unten, erste Marker überspringen
      if(mode & (1<<METLINKS)){ // wenn linke Marker ein
        for(int16_t i = mitte+diff+diff/2;i<yu-mdicke;i+=diff){
          display.fillRect(xmo,i,metka,mdicke,farbe);
        }
        for(int16_t i = mitte-diff-diff/2;i>yo+mdicke;i-=diff){
         display.fillRect(xmo,i,metka,mdicke,farbe);
        }
      }
      if(mode & (1<<METRECHTS)){ // wenn rechte Marker ein
        for(int16_t i = mitte+diff+diff/2;i<yu-mdicke;i+=diff){
          display.fillRect(xu,i,metka,mdicke,farbe);
        }
        for(int16_t i = mitte-diff-diff/2;i>yo+mdicke;i-=diff){
         display.fillRect(xu,i,metka,mdicke,farbe);
        }
      }
    }
  }
}

// Hilfsfunktion
// Scalenziffer zeichnen  einaus: wenn 0, Hintergrundfarbe benutzen (Marker vom Bildschirm löschen)
void scala_ziffer(scaladata *userscala, uint8_t einaus){

  uint16_t mode = userscala->mode;
    // wenn weder rechte noch linke Marker eingeschaltet, aus
  if(((mode & (1<<ZIFLINKS)) == 0) && ((mode & (1<<ZIFRECHTS))) == 0) return;

  uint16_t farbe = userscala->hintergrundfarbe;
    if(einaus) farbe = userscala->zifferfarbe; 
  uint16_t hintergrundfarbe = userscala->hintergrundfarbe;

  int16_t xo = userscala->xo;
  int16_t xu = userscala->xu;
  int16_t yo = userscala->yo;
  int16_t yu = userscala->yu;
  int16_t rdicke = userscala->rahmendicke;
  uint8_t mzahl = userscala->mzahl;
  int16_t breite = xu - xo + 1;
  int16_t hoehe = yu - yo + 1;
  int16_t zifscala_xl = userscala->zifscala_xl;  // horizontale (vertikale) Einzug von den Rahmen links (oben)
  int16_t zifscala_yl = userscala->zifscala_yl;  // vertikale (horizontale) Korrektur anhand der Skalenmarkierungen links (oben)
  int16_t zifscala_xr = userscala->zifscala_xr;  // horizontaler (vertikaler) Einzug vom Rahmen für die Maßstabsangaben rechts (unten)
  int16_t zifscala_yr = userscala->zifscala_yr;  // vertikale (horizontale) Korrektur anhand der Skalenmarkierungen rechts (unten)

  display.setFont(NULL);
  display.setTextSize(2); //adjust text size
  display.setTextColor(farbe,hintergrundfarbe);


  if(mode & (1<<VERTHOR)){  // horizontal
    int16_t mitte = (xo + xu) / 2; // Scalamitte nach Länge
    int16_t diff = (xu-xo-2*rdicke)/(mzahl - 1); // zwischen Marker
    int16_t metxo = mitte + diff/2 + diff * ((mzahl / 2) - 1);  // x-Position des linken Markers
        if(mzahl % 2) metxo = mitte + diff * (mzahl / 2); // wenn die Anzahl des Markers ungerade ist
        if(mode & (1<<ZIFPOS)) metxo -= diff/2; // wenn Zeichenlage zwischen Marker
    int8_t zifnum = userscala->anfzif;

    //for(int16_t xd = metxo; xd < xu-rdicke; xd+diff){
    for(int16_t i=0;i<mzahl;i++){
      if(mode & (1<<ZIFLINKS)){ // wenn obere Marker ein
        display.setCursor(metxo + zifscala_yl, yo -zifscala_xl); //x,y
        if((zifnum < 10)&&(zifnum >= 0)) display.print(" ");
        display.println(zifnum);
      }
      if(mode & (1<<ZIFRECHTS)){ // wenn untere Marker ein
        display.setCursor(metxo + zifscala_yr, yo + hoehe + zifscala_xr); //x,y
        if((zifnum < 10)&&(zifnum >= 0)) display.print(" ");
        display.println(zifnum);
      }
      metxo -= diff;
      if(metxo < xo+rdicke) break;
      zifnum += userscala->difzif;
    }
  }else{ // vertikal
    int16_t mitte = (yo + yu) / 2; // Scalamitte nach Höhe
    int16_t diff = (yu-yo-2*rdicke)/(mzahl - 1); // zwischen Marker
    int16_t metyo = mitte - diff/2 - diff * ((mzahl / 2) - 1);  // y-Position des linken Markers
        if(mzahl % 2) metyo = mitte - diff * (mzahl / 2); // wenn die Anzahl des Markers ungerade ist
        if(mode & (1<<ZIFPOS)) metyo += diff/2; // wenn Zeichenlage zwischen Marker
    int8_t zifnum = userscala->anfzif;

    //for(int16_t yd = metyo; yd < yu-rdicke; yd+diff){
    for(int16_t i=0;i<mzahl;i++){
      if(mode & (1<<ZIFLINKS)){ // wenn linke Marker ein
        display.setCursor(xo - zifscala_xl, metyo - zifscala_yl); //x,y
        if((zifnum < 10)&&(zifnum >= 0)) display.print(" ");
        display.println(zifnum);
      }
      if(mode & (1<<ZIFRECHTS)){ // wenn rechte Marker ein
        display.setCursor(xo + breite + zifscala_xr, metyo - zifscala_yr); //x,y
        if((zifnum < 10)&&(zifnum >= 0)) display.print(" ");
        display.println(zifnum);
      }
      metyo += diff;
      if(metyo > yu-rdicke) break;
      zifnum += userscala->difzif;
    }
  }
}

// Hilfsfunktion
// Gradientscala zeichnen
void scala_gradient(scaladata *userscala, uint16_t xx){
  int16_t af = userscala->scalafarbeanf;  // Anfangsfarbe der Scala
  int16_t ef = userscala->scalafarbe;     // Endfarbe der Scala
  uint16_t mode = userscala->mode;
  int16_t xo = userscala->xo;
  int16_t xu = userscala->xu;
  int16_t yo = userscala->yo;
  int16_t yu = userscala->yu;
  int16_t rdicke = userscala->rahmendicke;
  int16_t innenscala = (yu - yo) - 2 * rdicke;  // Höhe (Länge) der Skala ohne Rahmen, vertikale Scala
    if(mode & (1<<VERTHOR)){ innenscala = (xu - xo) - 2 * rdicke;  } // Horizontale Scala
  int16_t saule = (int16_t)(((float)xx/userscala->vollscala)*innenscala); // Höhe (Länge) des wirksamen Teils der Skala (ohne Rahmen)
  int16_t leer = innenscala - saule;  // Höhe (Länge) des leeren Teils der Skala (ohne Rahmen)
  
      // Farben entpacken
  int16_t fru = (int16_t)((af & 0xf800)>>1);		// Anfangsfarbe Rot
	int16_t fgu = (int16_t)((af & 0x07e0)<<4);		// Anfangsfarbe Grün
	int16_t fbu = (int16_t)((af & 0x001f)<<10);	  // Anfangsfarbe Blau
	int16_t fro = (int16_t)((ef & 0xf800)>>1);		// Endfarbe Rot
	int16_t fgo = (int16_t)((ef & 0x07e0)<<4);		// Endfarbe Grün
	int16_t fbo = (int16_t)((ef & 0x001f)<<10);	  // Endfarbe Blau

  int16_t frd = (fro - fru)/(int16_t)innenscala;	// Gradient Rot
	int16_t fgd = (fgo - fgu)/(int16_t)innenscala;	// Gradient Grün
	int16_t fbd = (fbo - fbu)/(int16_t)innenscala;	// Gradient Blau 

  if(mode & (1<<VERTHOR)){ // Horizontal
    if(mode & (1<<NULLUO)){ // Null rechts
      if(saule == 0) return;
      for(int16_t i=0;i<saule+1;i++){
        display.writeFastVLine(xo+innenscala+rdicke-i, yo+rdicke, yu-yo-2*rdicke+1,
            FARBE((uint8_t)(fru>>9),(uint8_t)(fgu>>9),(uint8_t)(fbu>>9))); 
				fru += frd;
				fgu += fgd;
				fbu += fbd;
      }
    }else{ // Null links
      for(int16_t i=0;i<saule+1;i++){
        display.writeFastVLine(xo+rdicke+i, yo+rdicke, yu-yo-2*rdicke+1,
            FARBE((uint8_t)(fru>>9),(uint8_t)(fgu>>9),(uint8_t)(fbu>>9))); 
				fru += frd;
				fgu += fgd;
				fbu += fbd;
      }
    }
  }else{ // Vertikal
    if(mode & (1<<NULLUO)){ // Null oben
      for(int16_t i=0;i<saule+1;i++){
        display.writeFastHLine(xo+rdicke, yo+rdicke+i, xu-xo-2*rdicke+1,
            FARBE((uint8_t)(fru>>9),(uint8_t)(fgu>>9),(uint8_t)(fbu>>9))); 
				fru += frd;
				fgu += fgd;
				fbu += fbd;
      }
    }else{ // Null unten
      if(saule == 0) return;
      for(int16_t i=0;i<saule+1;i++){
        display.writeFastHLine(xo+rdicke, yo+rdicke+innenscala-i, xu-xo-2*rdicke+1,
            FARBE((uint8_t)(fru>>9),(uint8_t)(fgu>>9),(uint8_t)(fbu>>9))); 
				fru += frd;
				fgu += fgd;
				fbu += fbd;
      }
    }
  }
}


void scala_inhalt(scaladata *userscala, uint16_t xx){
  uint16_t mode = userscala->mode;
  int16_t xo = userscala->xo;
  int16_t yo = userscala->yo;
  int16_t xu = userscala->xu;
  int16_t yu = userscala->yu;
  int16_t rdicke = userscala->rahmendicke;
  int16_t breite = userscala->xu-userscala->xo+1;
  int16_t hoehe = userscala->yu-userscala->yo+1;
  uint16_t scalafarbe = userscala->scalafarbe;
  uint16_t hintergrundfarbe = userscala->hintergrundfarbe;
  uint16_t grundfarbe = userscala->grundfarbe;
    if(mode & (1<<GRUND)) grundfarbe = userscala->hintergrundfarbe;

  int16_t innenscala = (yu - yo) - 2 * rdicke;;  // Höhe (Länge) der Skala ohne Rahmen, vertikale Scala
    if(mode & (1<<VERTHOR)) innenscala = (xu - xo) - 2 * rdicke;  // Horizontale Scala
  int16_t saule = (int16_t)(((float)xx/userscala->vollscala)*innenscala); // Höhe (Länge) des wirkenden Teils der Skala (ohne Rahmen)
  int16_t leer = innenscala - saule;  // Höhe (Länge) des leeren Teils der Scala (ohne Rahmen)

  int16_t xoram = xo+rdicke;
  int16_t yoram = yo+rdicke;
  int16_t brram = breite-2*rdicke;
  int16_t horam = hoehe-2*rdicke;

  if(mode & (1<<VERTHOR)){  // horizontal
    if(mode & (1<<NULLUO)){ // Null rechts
      if(mode & (1<<SCALAEIN)){
        display.fillRect(xoram,yoram,leer+1,horam,grundfarbe); // leere Scalateil
        if(mode & (1<<GRADIENT)){ // Gradientscala
          scala_gradient(userscala, xx);
        }else{ // einfarbige Scala
          display.fillRect(xoram+leer,yoram,saule,horam,scalafarbe); 
        }
      }else{ // Wenn die Scala ausgeschaltet, Scala voll mit Hintergrundfarbe (löschen)
        display.fillRect(xoram,yoram,innenscala,horam,hintergrundfarbe); 
      }
    }else{  // Null links
      if(mode & (1<<SCALAEIN)){
        display.fillRect(xoram+saule,yoram,leer+1,horam,grundfarbe); // leere Scalateil
        if(mode & (1<<GRADIENT)){ // Gradientscala
          scala_gradient(userscala, xx);
        }else{ // einfarbige Scala
          display.fillRect(xoram,yoram,saule,horam,scalafarbe); 
        }
      }else{ // Wenn die Scala ausgeschaltet, Scala voll mit Hintergrundfarbe (löschen)
        display.fillRect(xoram,yoram,innenscala,horam,hintergrundfarbe); 
      }
    }
  }else{  // vertikal
    if(mode & (1<<NULLUO)){ // Null oben
      if(mode & (1<<SCALAEIN)){
        display.fillRect(xoram,yoram+saule,brram,leer+1,grundfarbe); // leere Scalateil
        if(mode & (1<<GRADIENT)){ // Gradientscala
          scala_gradient(userscala, xx);
        }else{ // einfarbige Scala
          display.fillRect(xoram,yoram,brram,saule,scalafarbe); 
        }
      }else{ // Wenn die Scala ausgeschaltet, Scala voll mit Hintergrundfarbe (löschen)
        display.fillRect(xoram,yoram,brram,innenscala,hintergrundfarbe); 
      }
    }else{  // Null unten
      if(mode & (1<<SCALAEIN)){
        display.fillRect(xoram,yoram,brram,leer+1,grundfarbe); // leere Scalateil
        if(mode & (1<<GRADIENT)){ // Gradientscala
          scala_gradient(userscala, xx);
        }else{ // einfarbige Scala
          display.fillRect(xoram,yoram+leer,brram,saule,scalafarbe); 
        }
      }else{ // Wenn die Scala ausgeschaltet, Scala voll mit Hintergrundfarbe (löschen)
        display.fillRect(xoram,yoram,brram,innenscala,hintergrundfarbe);
      }    
    }
  }
}

// xx: wirkender Teil der Skala, rahmen: 1 = Rahmen, Beschriftungen und Marker zeichnen. 0 = Nur Scala zeichnen. 
void scala(scaladata *userscala, uint16_t xx, uint8_t rahmen){
  if(rahmen){ 
    scala_rahmen(userscala,1);
    scala_m_metka(userscala,1);
    scala_metka(userscala,1);
    scala_ziffer(userscala,1);
  }
  scala_inhalt(userscala, xx);  // Zeichnen der Scalen
}



// Hilfsfunktion zum Formatieren von Zahlen
void probel10b(uint16_t wert){
  if(wert < 1000) display.print(" ");
  if(wert < 100) display.print(" ");
  if(wert < 10) display.print(" ");
}

void setup() {
  // put your setup code here, to run once:
  display.begin(); //init library
  display.setRotation(3); // umgekehrt
  display.fillScreen(0);
  display.setTextColor(ROT,SCHWARZ);
  display.setCursor(10,40); //x,y
  display.setFont(NULL);
  display.setTextSize(4); //adjust text size
  display.print("MEN\x09a f\x081r Gottesdienst");

  pinMode(LED_PR1, OUTPUT);
  pinMode(LED_PR2, OUTPUT);
  pinMode(GIGA_RED, OUTPUT);
  pinMode(GIGA_GREEN, OUTPUT);
  pinMode(GIGA_BLUE, OUTPUT);
  pinMode(DRE_A, INPUT);
  pinMode(DRE_B, INPUT);
  pinMode(DRE_KN, INPUT);

  scala(&scala_linke,1023,1);
  scala(&scala_rechte,1023,1);
  scala(&scala_unten,1023,1);

  Serial.begin(115200);

}

void loop() {
  // put your main code here, to run repeatedly:
  digitalWrite(LED_PR1,digitalRead(DRE_A));
  digitalWrite(LED_PR2,digitalRead(DRE_B));
  digitalWrite(GIGA_RED,digitalRead(DRE_KN));

  WERT_L = (uint16_t)analogRead(PR1);
  WERT_R = (uint16_t)analogRead(PR2);

  meintime = millis();

  scala(&scala_linke,WERT_L,0);
  scala(&scala_rechte,WERT_R,0);
  scala(&scala_unten,((WERT_L+WERT_R)/2),0);

  dauer = millis() - meintime;

  zaehler++;
  if(zaehler > 10){
    zaehler = 0;
    display.setFont(&FreeMonoBold18pt7b);
    display.setTextSize(2); //adjust text size

    display.setTextColor(GELB,BLAU);
    display.fillRect(0,290,180,80,BLAU);
    display.setCursor(0,350); //x,y
    probel10b(WERT_L);
    display.println(WERT_L);
    display.setTextColor(WASSER,BLAU);
    display.fillRect(0,390,180,80,BLAU);
    display.setCursor(0,450); //x,y
    probel10b(WERT_R);;
    display.println(WERT_R);
    display.setTextColor(OLIVE,SCHWARZ);
    display.fillRect(0,190,180,80,SCHWARZ);
    display.setCursor(0,250); //x,y
    display.println(dauer);

    Serial.print(scala_linke.mode);
    Serial.print("  ");
    Serial.print(scala_rechte.mode);
    Serial.print("  ");
    Serial.println(scala_unten.mode); 
  }
  delay(20);

}