// Programm für Arduino Giga mit Bildschirm // Giga_010_Poti_Scala // LED_PR1 = D51/PE5, LED_PR2 = D40/PE6, PR1 = A11/PA0_C, PR2 = A10/PA1_C // Arbeit mit class #include #include #include "Fonts/FreeMonoBold18pt7b.h" GigaDisplay_GFX display; // create the object #include #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 class Maxim_scala{ public: // Beschreibung von Konstruktor. xo,yo,xu,yu - äußere Maße von Rahmen. // verthor 0/1 vertikal/horizontal, nulluo 0 = Null unten/links, 1 = Null oben/rechts // Andere Einstellungen default: // Scala vertikal, 7 Marker, einfarbig, einfachen Ziffer links Maxim_scala(int16_t _xo, int16_t _yo, int16_t _xu, int16_t _yu, boolean _verthor, boolean _nulluo); // Einstellungen // scalaein: 1 = Scala einschalten, // rahmenein: 1 = Rahmen einschalten, // verthor: 0 = vertikal, 1 = horizontal, // nulluo: 0 = Null unten/links / 1 = Null oben/rechts, // gradient: 0 = einfarbig-Scala, 1 = gradient-Scala, // grund = leere Scala-Teil mit Farbe: 0 = Grundfarbe, 1 = Hintergrundfarbe void setmodescala(boolean _scalaein, boolean _rahmenein, boolean _verthor, boolean _nulluo, boolean _gradient, boolean _grund); // mitme: 1 = Marker in der Mitte besondere Größe, 0 = Marker in der Mitte allgemeine Größe, // mitmetl: 1 = Marker in der Mitte links/oben mit einer ungeraden Anzahl von Marker (und zwei Marker mit einer geraden Anzahl) eingeschaltet, // mitmetr: 1 = Marker in der Mitte rechts/unten mit einer ungeraden Anzahl von Marker (und zwei Marker mit einer geraden Anzahl) eingeschaltet, // metlinks: 1 = Marker (außer in der Mitte) links/oben eingeschaltet, // metrechts: 1 = Marker (außer in der Mitte) rechts/unten eingeschaltet void setmodemetka(boolean _mitme, boolean _mitmetl, boolean _mitmetr, boolean _metlinks, boolean _metrechts); // ziflinks: 1 = Zeichen links/oben eingeschaltet, // zifrechts: 1 = Zeichen rechts/unten eingeschaltet, // zifpos: 0 = Zeichen gegen Marker, 1 = Zeichen zwischen Marker // ziftyp: 0 = Ziffer, es gelten anfzif und difzif, 1 = string, es gelten *sym und symzif void setmodezif(boolean _ziflinks, boolean _zifrechts, boolean _zifpos, boolean _ziftyp); // Einstellungsmethoden // xo,yo - Ecke oben links von Scala (mit Rahmen zusammen), // xu,yu - Ecke unten rechts von Scala (mit Rahmen zusammen) void setscalaxy(int16_t _xo, int16_t _yo, int16_t _xu, int16_t _yu); // Wert für volle (100%) Scala void setvollscala(float _vollscala); // rdicke: Dicke von Rahmen, // mzahl: Zahl von Marker // m_metka: Länge für mittlere Marker (von Rahmen nach außen), // m_mdicke: Dicke für mittlere Marker // metka: Länge für restlichen Marker (von Rahmen nach außen), // mdicke: Dicke für restlichen Marker void setrammetka(int16_t _rdicke, uint8_t _mzahl, int16_t _m_metka, int16_t _m_mdicke, int16_t _metka, int16_t _mdicke); // zifscala_xl = horizontale (vertikale) Zeichenabstand von Rahmen links (oben), // zifscala_yl = vertikale (horizontale) Zeichenabstand von Rahmen links (oben), // zifscala_xr = horizontale (vertikale) Zeichenabstand von Rahmen rechts (unten), // zifscala_yr = vertikale (horizontale) Zeichenabstand von Rahmen rechts (unten) void setabstand(int16_t _zifscala_xl, int16_t _zifscala_yl, int16_t _zifscala_xr, int16_t _zifscala_yr); // scalafarbe = Farbe für wirkende Scalateil, auch Farbe für Ende von wirkenden Scalateil für Gradientscala, // scalafarbeanf = Farbe für Anfang von wirkenden Scalateil für Gradientscala // rahmenfarbe = Farbe für Rahmen und Marker // zifferfarbe = Farbe für Zeichen // grundfarbe = Farbe für Leere Teil von Scala // hintergrundfarbe = Grundfarbe von Bildschirm. Wird z.B. für Zeichen gebraucht void setfarbe(uint16_t _scalafarbe, uint16_t _scalafarbeanf, uint16_t _rahmenfarbe, uint16_t _zifferfarbe, uint16_t _grundfarbe, uint16_t _hintergrundfarbe); // anfzif = Wert für oberste/rechte Ziffer bei Marker, difzif = Zifferschritt void setzif(int16_t _anfzif, int16_t _difzif); // *sym = Zeiger auf Zeichenarray für Scala, symzif = Zahl von Zeichen in Zeile einschließlich \0 in der Zeile bei Marker void setsymbol(char *_sym, uint8_t _symzif); /////////////////////////////////// // Hauptfunktion // Scala zeichnen. xx - Scalawert. rahmen - 1 = Scala, Marker und Zeichen zeichnen, 0 = Nur Scala selbst zeichnen void scala(uint16_t xx, uint8_t rahmen); private: // Scalamodi void set_scalaein(boolean xx); // 1 = Scala einschalten (Scala selbst, ohne Rahmen) boolean get_scalaein(void); void set_rahmenein(boolean xx); // 1 = Rahmen einschalten boolean get_rahmenein(void); void set_mitme(boolean xx); // 1 = Marker in der Mitte besondere Größe, 0 = Marker in der Mitte allgemeine Größe boolean get_mitme(void); void set_mitmetl(boolean xx); // 1 = Marker in der Mitte links/oben mit einer ungeraden Anzahl von Marker (und zwei Marker mit einer geraden Anzahl) eingeschaltet boolean get_mitmetl(void); void set_mitmetr(boolean xx); // 1 = Marker in der Mitte rechts/unten mit einer ungeraden Anzahl von Marker (und zwei Marker mit einer geraden Anzahl) eingeschaltet boolean get_mitmetr(void); void set_metlinks(boolean xx); // 1 = Marker (außer in der Mitte) links/oben eingeschaltet boolean get_metlinks(void); void set_metrechts(boolean xx); // 1 = Marker (außer in der Mitte) rechts/unten eingeschaltet boolean get_metrechts(void); void set_ziflinks(boolean xx); // 1 = Zeichen links/oben eingeschaltet boolean get_ziflinks(void); void set_zifrechts(boolean xx); // 1 = Zeichen rechts/unten eingeschaltet boolean get_zifrechts(void); void set_zifpos(boolean xx); // 0 = Zeichen gegen Marker, 1 = Zeichen zwischen Marker boolean get_zifpos(void); void set_ziftyp(boolean xx); // 0 = Ziffer, es gelten anfzif und difzif, 1 = string, es gelten *sym und symzif boolean get_ziftyp(void); void set_nulluo(boolean xx); // 0 = Null unten/links / 1 = Null oben/rechts boolean get_nulluo(void); void set_verthor(boolean xx); // 0 = vertikal, 1 = horizontal boolean get_verthor(void); void set_grund(boolean xx); // leere Scala-Teil mit Farbe: 0 = Grundfarbe, 1 = Hintergrundfarbe boolean get_grund(void); void set_gradient(boolean xx); // 0 = einfarbig-Scala, 1 = gradient-Scala boolean get_gradient(void); // Einstellungen für Scala int16_t xo; // x-Koordinate (horizontal) Ecke oben links von Scala (mit Rahmen zusammen) int16_t yo; // y-Koordinate (vertikal) Ecke oben links von Scala (mit Rahmen zusammen) int16_t xu; // x-Koordinate (horizontal) Ecke unten rechts von Scala (mit Rahmen zusammen) int16_t yu; // y-Koordinate (vertikal) Ecke unten rechts von Scala (mit Rahmen zusammen) uint16_t mode; // Scalamodi float vollscala; // Wert für volle (100%) Scala int16_t rdicke; // Rahmendicke uint8_t mzahl; // Anzahl des Markers int16_t m_metka; // Länge für mittlere Marker (von Rahmen nach außen) int16_t m_mdicke; // Dicke für mittlere Marker int16_t metka; // Länge für restlichen Marker (von Rahmen nach außen) int16_t mdicke; // Dicke für restlichen Marker int16_t zifscala_xl; // horizontale (vertikale) Zeichenabstand von Rahmen links (oben) int16_t zifscala_yl; // vertikale (horizontale) Zeichenabstand von Rahmen links (oben) int16_t zifscala_xr; // horizontale (vertikale) Zeichenabstand von Rahmen rechts (unten) int16_t zifscala_yr; // vertikale (horizontale) Zeichenabstand von Rahmen rechts (unten) uint16_t rahmenfarbe; // Farbe für Rahmen und Marker uint16_t zifferfarbe; // Farbe für Zeichen uint16_t grundfarbe; // Farbe für Leere Teil von Scala uint16_t scalafarbe; // Farbe für wirkende Scalateil, auch Farbe für Ende von wirkenden Scalateil für Gradientscala uint16_t scalafarbeanf; // Farbe für Anfang von wirkenden Scalateil für Gradientscala uint16_t hintergrundfarbe; // Grundfarbe von Bildschirm. Wird z.B. für Zeichen gebraucht int16_t anfzif; // Wert für oberste/rechte Ziffer bei Marker int16_t difzif; // Zifferschritt char *sym ; // Zeiger auf Zeichenarray für Scala uint8_t symzif; // Zahl von Zeichen in Zeile einschließlich \0 in der Zeile bei Marker // Methoden (Funktionen) zum Zeichnen einer Scala // Rahmen zeichnen. einaus: Wenn 0, hintergrundfarbe verwenden (Rahmen vom Bildschirm entfernen) void scala_rahmen(uint8_t einaus); // Marker in der Mitte zeichnen. einaus: Wenn 0, hintergrundfarbe verwenden (Marker vom Bildschirm entfernen) void scala_m_metka(uint8_t einaus); // Marker zeichnen (außer mittleren). einaus: Wenn 0, hintergrundfarbe verwenden (Marker vom Bildschirm entfernen) void scala_metka(uint8_t einaus); // Zechen zeichnen. einaus: Wenn 0, Wenn 0, hintergrundfarbe verwenden (Zechen vom Bildschirm entfernen) void scala_ziffer(uint8_t einaus); // Gradientscala zeichnen. xx ist der Skalanwert. void scala_gradient(uint16_t xx); // Skala zeichnen (einfach oder Gradient) void scala_inhalt(uint16_t xx); }; /////////////////////////////////////////////////// uint16_t WERT_L, WERT_R; long meintime = 0; int16_t zaehler = 0; long dauer = 0; #define SYMB_LINKE_ZAHL 5 char symb_linke[][SYMB_LINKE_ZAHL] = {"+6HT","+5HT","+4HT","+3HT","+2HT","+1HT"," 0HT","-1HT","-2HT","-3HT","-4HT","-5HT","-6HT"}; #define SYMB_RECHTE_ZAHL 5 char symb_rechte[][SYMB_RECHTE_ZAHL] = {"+50%","+25%","+15%","+10%"," +8%"," +5%"," +3%"," +2%"," +1%"," 0 "," -1%"," -2%"," -3%"," -5%"," -8%","-10%","-15%","-25%","-50%"}; #define SYMB_UNTEN_ZAHL 4 char symb_unten[][SYMB_UNTEN_ZAHL] = {" 2%","14%","26%","38%","50%","62%","74%","86%","98%"}; Maxim_scala scala_links(630, 35, 655, 475, 0, 0); // Scala schaffen: xo,yo,xu,yu,verthor,nulluo Maxim_scala scala_rechts(750, 35, 775, 475, 0, 0); // Scala schaffen xo,yo,xu,yu,verthor,nulluo Maxim_scala scala_unten(200, 420, 550, 445, 0, 0); // Scala schaffen xo,yo,xu,yu,verthor,nulluo // Beschreibung des Konstruktors. xo,yo,xu,yu - Äußere Abmessungen des Rahmens, // verthor 0/1 vertikal/horizontal, nulluo 0 = Null unten/links, 1 = Null oben/rechts // 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(" "); } // Hilfsfunktion für Korrektur der Wert-Mitte, da Center Detent nicht genau in der Mitte liegt uint16_t wertkorr(uint16_t inwert, uint16_t vollscala, int16_t kormit){ // inwert = Eingangswert, vollscala = 100% Scala, kormit = Korrektur für die Mitte int16_t kormitteil = kormit/9; uint16_t teiler = vollscala/20; if(((inwert >= 0) && (inwert < teiler))||((inwert > teiler*19) && (inwert <= vollscala))) return inwert; if(((inwert >= teiler) && (inwert < teiler*2))||((inwert > teiler*18) && (inwert <= teiler*19))) return (inwert += kormitteil); if(((inwert >= teiler*2) && (inwert < teiler*3))||((inwert > teiler*17) && (inwert <= teiler*18))) return (inwert += 2*kormitteil); if(((inwert >= teiler*3) && (inwert < teiler*4))||((inwert > teiler*16) && (inwert <= teiler*17))) return (inwert += 3*kormitteil); if(((inwert >= teiler*4) && (inwert < teiler*5))||((inwert > teiler*15) && (inwert <= teiler*16))) return (inwert += 4*kormitteil); if(((inwert >= teiler*5) && (inwert < teiler*6))||((inwert > teiler*14) && (inwert <= teiler*15))) return (inwert += 5*kormitteil); if(((inwert >= teiler*6) && (inwert < teiler*7))||((inwert > teiler*13) && (inwert <= teiler*14))) return (inwert += 6*kormitteil); if(((inwert >= teiler*7) && (inwert < teiler*8))||((inwert > teiler*12) && (inwert <= teiler*13))) return (inwert += 7*kormitteil); if(((inwert >= teiler*8) && (inwert < teiler*9))||((inwert > teiler*11) && (inwert <= teiler*12))) return (inwert += 8*kormitteil); return (inwert += kormit); } 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_links.setmodescala(1,1,0,0,1,0); // Scala und Rahmen: scalaein,rahmenein,verthor,nulluo,gradient,grund scala_links.setmodemetka(1,1,1,1,1); // Marker: mitme,mitmetl,mitmetr,metlinks,metrechts scala_links.setmodezif(1,0,1,1); // Zeichen: ziflinks,zifrechts,zifpos,ziftyp scala_links.setscalaxy(630, 35, 655, 475); // xo,yo - Ecke oben links von Scala (mit Rahmen zusammen), xu,yu - Ecke unten rechts von Scala (mit Rahmen zusammen) scala_links.setvollscala(1023.0); // Wert für volle (100%) Scala scala_links.setrammetka(4, 14, 14, 4, 10, 2); // rdicke,mzahl,m_metka,m_mdicke,metka,mdicke scala_links.setabstand(50, 6, 10, 6); // zifscala_xl,zifscala_yl,zifscala_xr,zifscala_yr scala_links.setfarbe(ROT, GRUENGELB, GELB, WASSER, BLAU, SCHWARZ); // scala,scalaanf,rahmen,ziffer,grund,hintergrund scala_links.setzif(6, -1); // anfzif = Wert für oberste/rechte Ziffer bei Marker, difzif = Zifferschritt scala_links.setsymbol(*symb_linke, SYMB_LINKE_ZAHL); // *sym = Zeiger auf Zeichenarray für Scala, symzif = Zahl von Zeichen in Zeile einschließlich \0 in der Zeile bei Marker scala_links.scala(1023,1); // linke Scala in voller Wert mit Rahmen zeichnen scala_rechts.setmodescala(1,1,0,0,0,0); // Scala und Rahmen: scalaein,rahmenein,verthor,nulluo,gradient,grund scala_rechts.setmodemetka(1,1,1,1,1); // Marker: mitme,mitmetl,mitmetr,metlinks,metrechts scala_rechts.setmodezif(1,0,0,0); // Zeichen: ziflinks,zifrechts,zifpos,ziftyp scala_rechts.setscalaxy(750, 35, 775, 475); // xo,yo - Ecke oben links von Scala (mit Rahmen zusammen), xu,yu - Ecke unten rechts von Scala (mit Rahmen zusammen) scala_rechts.setvollscala(1023.0); // Wert für volle (100%) Scala scala_rechts.setrammetka(4, 19, 14, 4, 10, 2); // rdicke,mzahl,m_metka,m_mdicke,metka,mdicke scala_rechts.setabstand(55, 6, 20, 6); // zifscala_xl,zifscala_yl,zifscala_xr,zifscala_yr scala_rechts.setfarbe(ROT, GRUEN, GELB, WASSER, BLAU, SCHWARZ); // scala,scalaanf,rahmen,ziffer,grund,hintergrund scala_rechts.setzif(9, -1); // anfzif = Wert für oberste/rechte Ziffer bei Marker, difzif = Zifferschritt scala_rechts.setsymbol(*symb_rechte, SYMB_RECHTE_ZAHL); // *sym = Zeiger auf Zeichenarray für Scala, symzif = Zahl von Zeichen in Zeile einschließlich \0 in der Zeile bei Marker scala_rechts.scala(1023,1); // rechte Scala in voller Wert mit Rahmen zeichnen scala_unten.setmodescala(1,1,1,0,1,0); // Scala und Rahmen: scalaein,rahmenein,verthor,nulluo,gradient,grund scala_unten.setmodemetka(1,1,1,1,1); // Marker: mitme,mitmetl,mitmetr,metlinks,metrechts scala_unten.setmodezif(1,1,0,1); // Zeichen: ziflinks,zifrechts,zifpos,ziftyp scala_unten.setscalaxy(200, 420, 550, 445); // xo,yo - Ecke oben links von Scala (mit Rahmen zusammen), xu,yu - Ecke unten rechts von Scala (mit Rahmen zusammen) scala_unten.setvollscala(1023.0); // Wert für volle (100%) Scala scala_unten.setrammetka(4, 9, 14, 4, 10, 2); // rdicke,mzahl,m_metka,m_mdicke,metka,mdicke scala_unten.setabstand(32, -14, 18, -14); // zifscala_xl,zifscala_yl,zifscala_xr,zifscala_yr scala_unten.setfarbe(ROT, GRUEN, GELB, WASSER, BLAU, SCHWARZ); // scala,scalaanf,rahmen,ziffer,grund,hintergrund scala_unten.setzif(4, -1); // anfzif = Wert für oberste/rechte Ziffer bei Marker, difzif = Zifferschritt scala_unten.setsymbol(*symb_unten, SYMB_UNTEN_ZAHL); // *sym = Zeiger auf Zeichenarray für Scala, symzif = Zahl von Zeichen in Zeile einschließlich \0 in der Zeile bei Marker scala_unten.scala(1023,1); // untere Scala in voller Wert mit Rahmen zeichnen } 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)); meintime = millis(); WERT_L = (uint16_t)analogRead(PR1); WERT_R = (uint16_t)analogRead(PR2); WERT_L = wertkorr(WERT_L, 1023, -6); // inwert, vollscala, kormit WERT_R = wertkorr(WERT_R, 1023, -5); // inwert, vollscala, kormit //meintime = millis(); scala_links.scala(WERT_L,0); // Scala ohne Rahmen zeichnen scala_rechts.scala(WERT_R,0); // Scala ohne Rahmen zeichnen scala_unten.scala(((WERT_L+WERT_R)/2),0); // Scala ohne Rahmen zeichnen 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); } delay(20); } ///////////////////////////////////////////////////// //////////////////// // Hauptfunktion // Scala zeichnen. xx - Scalawert. rahmen - 1 = Scala, Marker und Zeichen zeichnen, 0 = Nur Scala selbst zeichnen void Maxim_scala::scala(uint16_t xx, uint8_t rahmen) { if(rahmen){ scala_rahmen(1); scala_m_metka(1); scala_metka(1); scala_ziffer(1); } scala_inhalt(xx); // Zeichnen der Scalen } ///////// // Beschreibung von Konstruktor. xo,yo,xu,yu - äußere Maße von Rahmen. // verthor 0/1 vertikal/horizontal, nulluo 0 = Null unten/links, 1 = Null oben/rechts // Andere Einstellungen default: // Scala vertikal, 7 Marker, einfarbig, einfachen Ziffer links Maxim_scala::Maxim_scala(int16_t _xo, int16_t _yo, int16_t _xu, int16_t _yu, boolean _verthor, boolean _nulluo){ setscalaxy(_xo, _yo, _xu, _yu); setmodescala(1, 1, _verthor, _nulluo, 0, 0); setmodemetka(1, 1, 1, 1, 1); setmodezif(1, 0, 0, 0); setvollscala(1023.0); // Wert für volle (100%) Scala setrammetka(4, 7, 14, 4, 10, 2); // rdicke,mzahl,m_metka,m_mdicke,metka,mdicke setabstand(50, 6, 10, 6); // zifscala_xl,zifscala_yl,zifscala_xr,zifscala_yr setfarbe(ROT, GELB, GELB, WASSER, BLAU, SCHWARZ); // scala,scalaanf,rahmen,ziffer,grund,hintergrund setzif(6, -1); // anfzif = Wert für oberste/rechte Ziffer bei Marker, difzif = Zifferschritt setsymbol(NULL, 5); // *sym = Zeiger auf Zeichenarray für Scala, symzif = Zahl von Zeichen in Zeile einschließlich \0 in der Zeile bei Marker } ///// // Einstellungen // scalaein: 1 = Scala einschalten, // rahmenein: 1 = Rahmen einschalten, // verthor: 0 = vertikal, 1 = horizontal, // nulluo: 0 = Null unten/links / 1 = Null oben/rechts, // gradient: 0 = einfarbig-Scala, 1 = gradient-Scala, // grund = leere Scala-Teil mit Farbe: 0 = Grundfarbe, 1 = Hintergrundfarbe void Maxim_scala::setmodescala(boolean _scalaein, boolean _rahmenein, boolean _verthor, boolean _nulluo, boolean _gradient, boolean _grund){ set_scalaein(_scalaein); set_rahmenein(_rahmenein); set_verthor(_verthor); set_nulluo(_nulluo); set_gradient(_gradient); set_grund(_grund); } // mitme: 1 = Marker in der Mitte besondere Größe, 0 = Marker in der Mitte allgemeine Größe, // mitmetl: 1 = Marker in der Mitte links/oben mit einer ungeraden Anzahl von Marker (und zwei Marker mit einer geraden Anzahl) eingeschaltet, // mitmetr: 1 = Marker in der Mitte rechts/unten mit einer ungeraden Anzahl von Marker (und zwei Marker mit einer geraden Anzahl) eingeschaltet, // metlinks: 1 = Marker (außer in der Mitte) links/oben eingeschaltet, // metrechts: 1 = Marker (außer in der Mitte) rechts/unten eingeschaltet void Maxim_scala::setmodemetka(boolean _mitme, boolean _mitmetl, boolean _mitmetr, boolean _metlinks, boolean _metrechts){ set_mitme(_mitme); set_mitmetl(_mitmetl); set_mitmetr(_mitmetr); set_metlinks(_metlinks); set_metrechts(_metrechts); } // ziflinks: 1 = Zeichen links/oben eingeschaltet, // zifrechts: 1 = Zeichen rechts/unten eingeschaltet, // zifpos: 0 = Zeichen gegen Marker, 1 = Zeichen zwischen Marker // ziftyp: 0 = Ziffer, es gelten anfzif und difzif, 1 = string, es gelten *sym und symzif void Maxim_scala::setmodezif(boolean _ziflinks, boolean _zifrechts, boolean _zifpos, boolean _ziftyp){ set_ziflinks(_ziflinks); set_zifrechts(_zifrechts); set_zifpos(_zifpos); set_ziftyp(_ziftyp); } // Scalamodi void Maxim_scala::set_scalaein(boolean xx){ // 1 = Scala einschalten (Scala selbst, ohne Rahmen) if(xx){ mode |= (1<<0); }else{ mode &= ~(1<<0);} } boolean Maxim_scala::get_scalaein(void){ if(mode & (1<<0)){ return 1; }else{ return 0; } } void Maxim_scala::set_rahmenein(boolean xx){ // 1 = Rahmen einschalten if(xx){ mode |= (1<<1); }else{ mode &= ~(1<<1);} } boolean Maxim_scala::get_rahmenein(void){ if(mode & (1<<1)){ return 1; }else{ return 0; } } void Maxim_scala::set_mitme(boolean xx){ // 1 = Marker in der Mitte besondere Größe, 0 = Marker in der Mitte allgemeine Größe if(xx){ mode |= (1<<2); }else{ mode &= ~(1<<2);} } boolean Maxim_scala::get_mitme(void){ if(mode & (1<<2)){ return 1; }else{ return 0; } } void Maxim_scala::set_mitmetl(boolean xx){ // 1 = Marker in der Mitte links/oben mit einer ungeraden Anzahl von Marker (und zwei Marker mit einer geraden Anzahl) if(xx){ mode |= (1<<3); }else{ mode &= ~(1<<3);} } boolean Maxim_scala::get_mitmetl(void){ if(mode & (1<<3)){ return 1; }else{ return 0; } } void Maxim_scala::set_mitmetr(boolean xx){ // 1 = Marker in der Mitte rechts/unten mit einer ungeraden Anzahl von Marker (und zwei Marker mit einer geraden Anzahl) if(xx){ mode |= (1<<4); }else{ mode &= ~(1<<4);} } boolean Maxim_scala::get_mitmetr(void){ if(mode & (1<<4)){ return 1; }else{ return 0; } } void Maxim_scala::set_metlinks(boolean xx){ // 1 = Marker (außer in der Mitte) links/oben eingeschaltet if(xx){ mode |= (1<<5); }else{ mode &= ~(1<<5);} } boolean Maxim_scala::get_metlinks(void){ if(mode & (1<<5)){ return 1; }else{ return 0; } } void Maxim_scala::set_metrechts(boolean xx){ // 1 = Marker (außer in der Mitte) rechts/unten eingeschaltet if(xx){ mode |= (1<<6); }else{ mode &= ~(1<<6);} } boolean Maxim_scala::get_metrechts(void){ if(mode & (1<<6)){ return 1; }else{ return 0; } } void Maxim_scala::set_ziflinks(boolean xx){ // 1 = Zeichen links/oben eingeschaltet if(xx){ mode |= (1<<7); }else{ mode &= ~(1<<7);} } boolean Maxim_scala::get_ziflinks(void){ if(mode & (1<<7)){ return 1; }else{ return 0; } } void Maxim_scala::set_zifrechts(boolean xx){ // 1 = Zeichen rechts/unten eingeschaltet if(xx){ mode |= (1<<8); }else{ mode &= ~(1<<8);} } boolean Maxim_scala::get_zifrechts(void){ if(mode & (1<<8)){ return 1; }else{ return 0; } } void Maxim_scala::set_zifpos(boolean xx){ // 0 = Zeichen gegen Marker, 1 = Zeichen zwischen Marker if(xx){ mode |= (1<<9); }else{ mode &= ~(1<<9);} } boolean Maxim_scala::get_zifpos(void){ if(mode & (1<<9)){ return 1; }else{ return 0; } } void Maxim_scala::set_ziftyp(boolean xx){ // 0 = Ziffer, es gelten anfzif und difzif, 1 = string, es gelten *sym und symzif if(xx){ mode |= (1<<10); }else{ mode &= ~(1<<10);} } boolean Maxim_scala::get_ziftyp(void){ if(mode & (1<<10)){ return 1; }else{ return 0; } } void Maxim_scala::set_nulluo(boolean xx){ // 0 = Null unten/links / 1 = Null oben/rechts if(xx){ mode |= (1<<11); }else{ mode &= ~(1<<11);} } boolean Maxim_scala::get_nulluo(void){ if(mode & (1<<11)){ return 1; }else{ return 0; } } void Maxim_scala::set_verthor(boolean xx){ // 0 = vertikal, 1 = horizontal if(xx){ mode |= (1<<12); }else{ mode &= ~(1<<12);} } boolean Maxim_scala::get_verthor(void){ if(mode & (1<<12)){ return 1; }else{ return 0; } } void Maxim_scala::set_grund(boolean xx){ // leere Scala-Teil mit Farbe: 0 = Grundfarbe, 1 = Hintergrundfarbe if(xx){ mode |= (1<<13); }else{ mode &= ~(1<<13);} } boolean Maxim_scala::get_grund(void){ if(mode & (1<<13)){ return 1; }else{ return 0; } } void Maxim_scala::set_gradient(boolean xx){ // 0 = einfarbig-Scala, 1 = gradient-Scala if(xx){ mode |= (1<<14); }else{ mode &= ~(1<<14);} } boolean Maxim_scala::get_gradient(void){ if(mode & (1<<14)){ return 1; }else{ return 0; } } // Einstellungsmethoden // xo,yo - Ecke oben links von Scala (mit Rahmen zusammen), // xu,yu - Ecke unten rechts von Scala (mit Rahmen zusammen) void Maxim_scala::setscalaxy(int16_t _xo, int16_t _yo, int16_t _xu, int16_t _yu){ xo = _xo; yo = _yo; xu = _xu; yu = _yu; } // Wert für volle (100%) Scala void Maxim_scala::setvollscala(float _vollscala){ vollscala = _vollscala; } // rdicke: Dicke von Rahmen, // mzahl: Zahl von Marker // m_metka: Länge für mittlere Marker (von Rahmen nach außen), // m_mdicke: Dicke für mittlere Marker // metka: Länge für restlichen Marker (von Rahmen nach außen), // mdicke: Dicke für restlichen Marker void Maxim_scala::setrammetka(int16_t _rdicke, uint8_t _mzahl, int16_t _m_metka, int16_t _m_mdicke, int16_t _metka, int16_t _mdicke){ rdicke = _rdicke; mzahl = _mzahl; m_metka = _m_metka; m_mdicke = _m_mdicke; metka = _metka; mdicke = _mdicke; } // zifscala_xl = horizontale (vertikale) Zeichenabstand von Rahmen links (oben), // zifscala_yl = vertikale (horizontale) Zeichenabstand von Rahmen links (oben), // zifscala_xr = horizontale (vertikale) Zeichenabstand von Rahmen rechts (unten), // zifscala_yr = vertikale (horizontale) Zeichenabstand von Rahmen rechts (unten) void Maxim_scala::setabstand(int16_t _zifscala_xl, int16_t _zifscala_yl, int16_t _zifscala_xr, int16_t _zifscala_yr){ zifscala_xl = _zifscala_xl; zifscala_yl = _zifscala_yl; zifscala_xr = _zifscala_xr; zifscala_yr = _zifscala_yr; } // scalafarbe = Farbe für wirkende Scalateil, auch Farbe für Ende von wirkenden Scalateil für Gradientscala, // scalafarbeanf = Farbe für Anfang von wirkenden Scalateil für Gradientscala // rahmenfarbe = Farbe für Rahmen und Marker // zifferfarbe = Farbe für Zeichen // grundfarbe = Farbe für Leere Teil von Scala // hintergrundfarbe = Grundfarbe von Bildschirm. Wird z.B. für Zeichen gebraucht void Maxim_scala::setfarbe(uint16_t _scalafarbe, uint16_t _scalafarbeanf, uint16_t _rahmenfarbe, uint16_t _zifferfarbe, uint16_t _grundfarbe, uint16_t _hintergrundfarbe){ scalafarbe = _scalafarbe; scalafarbeanf = _scalafarbeanf; rahmenfarbe = _rahmenfarbe; zifferfarbe = _zifferfarbe; grundfarbe = _grundfarbe; hintergrundfarbe = _hintergrundfarbe; } // anfzif = Wert für oberste/rechte Ziffer bei Marker, difzif = Zifferschritt void Maxim_scala::setzif(int16_t _anfzif, int16_t _difzif){ anfzif = _anfzif; difzif = _difzif; } // *sym = Zeiger auf Zeichenarray für Scala, symzif = Zahl von Zeichen in Zeile einschließlich \0 in der Zeile bei Marker void Maxim_scala::setsymbol(char *_sym, uint8_t _symzif){ sym = _sym; symzif = _symzif; } /////////////////////////////// // Methoden (Funktionen) zum Zeichnen einer Scala // Rahmen zeichnen. einaus: Wenn 0, hintergrundfarbe verwenden (Rahmen vom Bildschirm entfernen) void Maxim_scala::scala_rahmen(uint8_t einaus){ if(0 == get_rahmenein()) return; if(rdicke < 1) return; uint16_t farbe = hintergrundfarbe; if(einaus) farbe = 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 } */ 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 } // Marker in der Mitte zeichnen. einaus: Wenn 0, hintergrundfarbe verwenden (Marker vom Bildschirm entfernen) void Maxim_scala::scala_m_metka(uint8_t einaus){ // wenn mittlere Marker von keiner Seite eingeschaltet, aus if((0 == get_mitmetl()) && (0 == get_mitmetr())) return; uint16_t farbe = hintergrundfarbe; if(einaus) farbe = rahmenfarbe; int16_t _m_metka; int16_t _m_mdicke; if(get_mitme()){ // wenn eigene Größe mittleres Markers _m_metka = m_metka; _m_mdicke = m_mdicke; }else{ _m_metka = metka; _m_mdicke = mdicke; } if(get_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(get_mitmetl()){ // wenn obere mittlere Marker ein display.fillRect(xm,ym,_m_mdicke,_m_metka,farbe); // oberhalb des Rahmens } if(get_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(get_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(get_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(get_mitmetl()){ // wenn linke mittlere Marker eingschaltet display.fillRect(xm,ym,_m_metka,_m_mdicke,farbe); // links von Rahmen } if(get_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(get_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(get_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 } } } } // Marker zeichnen (außer mittleren). einaus: Wenn 0, hintergrundfarbe verwenden (Marker vom Bildschirm entfernen) void Maxim_scala::scala_metka(uint8_t einaus){ // wenn Marker weder links noch rechts eingeschaltet, aus if((0 == get_metlinks()) && (0 == get_metrechts())) return; uint16_t farbe = hintergrundfarbe; if(einaus) farbe = rahmenfarbe; int16_t innenscala = (yu - yo) - 2 * rdicke; // Höhe (Länge) der Skala ohne Rahmen, vertikale Scala if(get_verthor()){ innenscala = (xu - xo) - 2 * rdicke; } // Horizontale Scala if(get_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(get_metlinks()){ // wenn obere Marker ein for(int16_t i = mitte+diff;ixo+mdicke;i-=diff){ display.fillRect(i,ymo,mdicke,metka,farbe); } } if(get_metrechts()){ // wenn untere Marker ein for(int16_t i = mitte+diff;ixo+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(get_metlinks()){ // wenn obere Marker ein for(int16_t i = mitte+diff+diff/2;ixo+mdicke;i-=diff){ display.fillRect(i,ymo,mdicke,metka,farbe); } } if(get_metrechts()){ // wenn untere Marker ein for(int16_t i = mitte+diff+diff/2;ixo+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(get_metlinks()){ // wenn linke Marker ein for(int16_t i = mitte+diff;iyo+mdicke;i-=diff){ display.fillRect(xmo,i,metka,mdicke,farbe); } } if(get_metrechts()){ // wenn rechte Marker ein for(int16_t i = mitte+diff;iyo+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(get_metlinks()){ // wenn linke Marker ein for(int16_t i = mitte+diff+diff/2;iyo+mdicke;i-=diff){ display.fillRect(xmo,i,metka,mdicke,farbe); } } if(get_metrechts()){ // wenn rechte Marker ein for(int16_t i = mitte+diff+diff/2;iyo+mdicke;i-=diff){ display.fillRect(xu,i,metka,mdicke,farbe); } } } } } // Zechen zeichnen. einaus: Wenn 0, Wenn 0, hintergrundfarbe verwenden (Zechen vom Bildschirm entfernen) void Maxim_scala::scala_ziffer(uint8_t einaus){ // wenn weder rechte noch linke Marker eingeschaltet, aus if((0 == get_ziflinks()) && (0 == get_zifrechts())) return; uint16_t farbe = hintergrundfarbe; if(einaus) farbe = zifferfarbe; int16_t breite = xu - xo + 1; int16_t hoehe = yu - yo + 1; display.setFont(NULL); display.setTextSize(2); //adjust text size display.setTextColor(farbe,hintergrundfarbe); if(get_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(get_zifpos()) metxo -= diff/2; // wenn Zeichenlage zwischen Marker int8_t zifnum = anfzif; // einfache Bezifferung if(get_ziftyp()) zifnum = 0; // string-Bezifferung for(int16_t i=0;i= 0)) display.print(" "); display.print(zifnum); } } if(get_zifrechts()){ // wenn untere Marker ein display.setCursor(metxo + zifscala_yr, yo + hoehe + zifscala_xr); //x,y if(get_ziftyp()){ // string-Bezifferung int8_t zz = zifnum; for(uint8_t y=0;y= 0)) display.print(" "); display.print(zifnum); } } if(get_ziftyp()){ zifnum += symzif; // string-Bezifferung }else{ zifnum += difzif; // einfache Bezifferung } metxo -= diff; if(metxo < xo+rdicke) break; } }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(get_zifpos()) metyo += diff/2; // wenn Zeichenlage zwischen Marker int8_t zifnum = anfzif; // einfache Bezifferung if(get_ziftyp()) zifnum = 0; // string-Bezifferung for(int16_t i=0;i= 0)) display.print(" "); display.print(zifnum); } } if(get_zifrechts()){ // wenn rechte Marker ein display.setCursor(xo + breite + zifscala_xr, metyo - zifscala_yr); //x,y if(get_ziftyp()){ // string-Bezifferung int8_t zz = zifnum; for(uint8_t y=0;y= 0)) display.print(" "); display.print(zifnum); } } if(get_ziftyp()){ zifnum += symzif; // string-Bezifferung }else{ zifnum += difzif; // einfache Bezifferung } metyo += diff; if(metyo > yu-rdicke) break; } } } // Gradientscala zeichnen. xx ist der Skalanwert void Maxim_scala::scala_gradient(uint16_t xx){ int16_t af = scalafarbeanf; // Anfangsfarbe der Scala int16_t ef = scalafarbe; // Endfarbe der Scala int16_t innenscala = (yu - yo) - 2 * rdicke; // Höhe (Länge) der Skala ohne Rahmen, vertikale Scala if(get_verthor()){ innenscala = (xu - xo) - 2 * rdicke; } // Horizontale Scala int16_t saule = (int16_t)(((float)xx/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(get_verthor()){ // Horizontal if(get_nulluo()){ // Null rechts for(int16_t i=0;i>9),(uint8_t)(fgu>>9),(uint8_t)(fbu>>9))); fru += frd; fgu += fgd; fbu += fbd; } }else{ // Null links for(int16_t i=0;i>9),(uint8_t)(fgu>>9),(uint8_t)(fbu>>9))); fru += frd; fgu += fgd; fbu += fbd; } } }else{ // Vertikal if(get_nulluo()){ // Null oben for(int16_t i=0;i>9),(uint8_t)(fgu>>9),(uint8_t)(fbu>>9))); fru += frd; fgu += fgd; fbu += fbd; } }else{ // Null unten for(int16_t i=0;i>9),(uint8_t)(fgu>>9),(uint8_t)(fbu>>9))); fru += frd; fgu += fgd; fbu += fbd; } } } } // Skala zeichnen (einfach oder Gradient) void Maxim_scala::scala_inhalt(uint16_t xx){ int16_t breite = xu-xo+1; int16_t hoehe = yu-yo+1; uint16_t _grundfarbe = grundfarbe; if(get_grund()) _grundfarbe = hintergrundfarbe; int16_t innenscala = (yu - yo) - 2 * rdicke;; // Höhe (Länge) der Skala ohne Rahmen, vertikale Scala if(get_verthor()) innenscala = (xu - xo) - 2 * rdicke; // Horizontale Scala int16_t saule = (int16_t)(((float)xx/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(get_verthor()){ // horizontal if(get_nulluo()){ // Null rechts if(get_scalaein()){ display.fillRect(xoram,yoram,leer+1,horam,_grundfarbe); // leere Scalateil if(saule != 0){ if(get_gradient()){ // Gradientscala scala_gradient(xx); }else{ // einfarbige Scala display.fillRect(xoram+leer,yoram,saule+1,horam,scalafarbe); } } }else{ // Wenn die Scala ausgeschaltet, Scala voll mit Hintergrundfarbe (löschen) display.fillRect(xoram,yoram,innenscala,horam,hintergrundfarbe); } }else{ // Null links if(get_scalaein()){ display.fillRect(xoram+saule,yoram,leer+1,horam,_grundfarbe); // leere Scalateil if(saule != 0){ if(get_gradient()){ // Gradientscala scala_gradient(xx); }else{ // einfarbige Scala display.fillRect(xoram,yoram,saule+1,horam,scalafarbe); } } }else{ // Wenn die Scala ausgeschaltet, Scala voll mit Hintergrundfarbe (löschen) display.fillRect(xoram,yoram,innenscala,horam,hintergrundfarbe); } } }else{ // vertikal if(get_nulluo()){ // Null oben if(get_scalaein()){ display.fillRect(xoram,yoram+saule,brram,leer+1,_grundfarbe); // leere Scalateil if(saule != 0){ if(get_gradient()){ // Gradientscala scala_gradient(xx); }else{ // einfarbige Scala display.fillRect(xoram,yoram,brram,saule+1,scalafarbe); } } }else{ // Wenn die Scala ausgeschaltet, Scala voll mit Hintergrundfarbe (löschen) display.fillRect(xoram,yoram,brram,innenscala,hintergrundfarbe); } }else{ // Null unten if(get_scalaein()){ display.fillRect(xoram,yoram,brram,leer+1,_grundfarbe); // leere Scalateil if(saule != 0){ if(get_gradient()){ // Gradientscala scala_gradient(xx); }else{ // einfarbige Scala display.fillRect(xoram,yoram+leer,brram,saule+1,scalafarbe); } } }else{ // Wenn die Scala ausgeschaltet, Scala voll mit Hintergrundfarbe (löschen) display.fillRect(xoram,yoram,brram,innenscala,hintergrundfarbe); } } } }