Code
- JX_Wave_Generator_8.7.7.ino
- JXWG_Defs.h
- JXWG_Graphics.h
JX_Wave_Generator_8.7.7.inoC/C++
Version 8.7.7. Geringfügige Überarbeitung am 16.01.2021/* Copyright (c) 2020 Janux Die Erlaubnis wird hiermit kostenlos jeder Person erteilt, die eine Kopie dieser Software und der zugehörigen Dokumentationsdateien (die "Software") erhält, um zu handeln an der Software ohne Einschränkung, einschließlich und ohne Einschränkung der Rechte, Kopien der Software zu verwenden, zu kopieren, zu modifizieren, zusammenzuführen, zu veröffentlichen, zu verteilen, zu unterlizenzieren und/oder zu verkaufen und Personen, denen die Software zur Verfügung gestellt wird, dies zu gestatten, vorbehaltlich zu den folgenden Bedingungen:Der obige Urheberrechtshinweis und dieser Genehmigungshinweis müssen in alle Kopien oder wesentlichen Teile der Software aufgenommen werden. DIE SOFTWARE WIRD "WIE BESEHEN" BEREITGESTELLT, OHNE JEGLICHE AUSDRÜCKLICHE ODER STILLSCHWEIGENDE GEWÄHRLEISTUNG, EINSCHLIESSLICH, ABER NICHT BESCHRÄNKT AUF DIE GEWÄHRLEISTUNGEN DER MARKTFÄHIGKEIT, EIGNUNG FÜR EINEN BESTIMMTEN ZWECK UND NICHTVERLETZUNG VON VERLETZUNGEN. IN KEINEM FALL HAFTEN DIE AUTOREN ODER URHEBERRECHTSINHABER FÜR ANSPRÜCHE, SCHÄDEN ODER SONSTIGE HAFTUNG, OB AUS VERTRAGLICHEM, SCHLECHTER ODER ANDERWEITIGEM, DIE SICH AUS, AUS ODER IN VERBINDUNG MIT DER SOFTWARE ODER DER NUTZUNG ODER ANDEREN HANDELN IN DER SOFTWARE. Der Code zum Speichern und Laden von Konfigurationen ist eine Entwicklung einer ursprünglichen Idee des Artikels "How to Load and Save Configurations on an Arduino" von Ragnar Ranyen Homb auf der Norwegian Creation-Website.*/#include "JXWG_Defs.h"#include "JXWG_Graphics .h"void setup () {// Wenn Sie einen einfachen Encoder und 3x10K Pullup-Widerstände verwenden, wenden Sie diese Einstellungen unter pinMode (PinA, INPUT) an; pinMode (PinB, EINGANG); pinMode (Pins, EINGANG); // Wenn Sie einen einfachen Encoder ohne 3x10K-Widerstände verwenden, verwenden Sie die nächste Baumreihe // PinMode (PinA, INPUT_PULLUP); //pinMode (PinB, INPUT_PULLUP); // PinMode (PinS, INPUT_PULLUP); // DIE MEISTEN PCB-GESCHWEISSENEN ENCODER HABEN BEREITS PULLUP-WIDERSTÄNDE AN PIN A UND B, ABER NICHT AN SCHALTERPIN // Verwenden Sie dann die Einstellungen unten // PinMode (PinA, INPUT); // PinMode (PinB, EINGANG); // PinMode (PinS, INPUT_PULLUP); digitalWrite (PinA, HIGH); digitalWrite (PinB, HIGH); digitalWrite (Pins, HOCH); pinMode (PinCoupling, AUSGANG); // Kopplungsmodus Encoder.setDebounceDelay (5); display.begin(SH1106_SWITCHCAPVCC, 0x3C); // mit der I2C-Adresse 0x3C (für 128x64) initialisieren display.clearDisplay(); //display.setRotation(2); // Kommentieren Sie diese Zeile, wenn Sie das Display auf den Kopf stellen möchten Wire.begin (); // i2c-Bus als Master beitreten TWBR =5; // Freq =615 kHz Periode =1,625 uS // Weist Encoder-Schalter-Push-Ereignis dem Interrupt 1 zu Pin 3 von Arduino attachInterrupt (digitalPinToInterrupt (PinS), EncoderSwitch, FALLING); DDS_Init(); //Das DDS-Modul initialisieren; setConfig(); //Konfiguration laden und Startwerte setzen} //---> Setup beenden()void loop() { JX_WaveGenerator_MAIN();}//------------------ -------------------------------------------------- -------------------------------------------------- ------------------// JX WaveGenerator MAIN-Funktion //------------------------ -------------------------------------------------- -------------------------------------------------- -------------void JX_WaveGenerator_MAIN() { byte encoderSpin =Encoder.rotate(); // Drehrichtung des Drehgebers 1=CW, 2=CCW Byte EncoderLongPush =Encoder.pushLong(1000); // Encoder langes Push-Ereignis lang lStep =0; // aktueller Frequenzschrittwert lang wTime =600000; //10 min if (encoderPush) delay(250); if (encoderSpin) { cTime =millis (); aufrechtzuerhalten. Sonst { if (millis() - cTime> wTime) { ScreenSaver(); } } switch (mode) { case LOGARITHMIC://0 //---------------------------------- -------------------------------------------------- ---------------------------------------------------------- // Modus LOGARITHMISCH :Änderungsfrequenz der Drehgeberdrehung in logaritmischen Schritten 1,10,100,1000,10000,100000 Hz //----------------------------------------- -------------------------------------------------- -------------------------------------------------- - if (encoderSpin) { if (lFreq>=1) { lStep =AutoStep (lFreq, EncoderSpin); // Logaritmischen Schritt berechnen} else if (_CouplingMode ==OFF) {//wenn der Kopplungsmodus auf OFF gesetzt ist resetCouplingMode(); // Standard-Kopplungsmodus einstellen, wenn Frequenz nicht 0 ist EncoderSpin =0; // ersten Spin überspringen} if (encoderSpin ==CW &&lFreq <=999999 - lStep) { // Spin CW inkrementiere die Frequenz lFreq +=lStep; } if (encoderSpin ==CCW &&lFreq>=lStep + 1) {//spin CCW dekrementiere die Frequenz lFreq -=lStep; } DDS_FrequencySet(lFreq, Wave[_WaveType]); // den Frequenzwert an das DDS-Modul senden displayFrequency (lFreq); // Formatierte Freq senden, um lLastFreq =lFreq anzuzeigen; //Aktuelle Freq speichern} //----------------------------------------------------- -------------------------------------------------- --------------------------------------- // Arbeitsmodus LOGARITHMIC:Encoder-Druckschalter in den OPTIONS-Modus //------------------------------------------------ -------------------------------------------------- --------------------------------- if (encoderPush) { EncoderPush =false; // Push-Flag löschen drawSymbol(1); // Pfeilsymbol zeichnen selectIcon (0, WEISS); // einen Rahmen um das erste Symbol zeichnen idx =0; idy =0; // Zeiger zurücksetzen var mode =OPTIONS; // Gehe in den Modus OPTIONS } break; //Endmodus LOGARITHMIC case SINGLEDIGIT:// //------------------------------------------------ -------------------------------------------------- ---------- // Submode SINGLEDIGIT:Encoder-Rotation Cursor nach links und rechts bewegen //------------- -------------------------------------------------- --------------------------------------------- if (encoderSpin) { if (encoderSpin ==CW &&idx 0) idx--; //Verkleinerungszeiger gegen den Uhrzeigersinn //------------------------------------------------------ -------------------------------------------------- -------------- // wenn idx zwischen 0 und 5 liegt, wählen Sie die Frequenzziffern //------------ -------------------------------------------------- ------------------------------------- if (idx>=0 &&idx =MAXDIGIT &&idx <=MAXDIGIT + 2) {//wenn die aktuelle Position außerhalb der Ziffern liegt hideCursor(MAXDIGIT - 1); // Cursor an der letzten Stelle ausblenden drawSymbol(1); // dn-Pfeil zeichnen selectIcon (idx - MAXDIGIT, WEISS); //Symbol auswählen } } //----------------------------------------------------- -------------------------------------------------- --------------------------------------- // Submode SINGLEDIGIT:Encoder Push Event //- -------------------------------------------------- -------------------------------------------------- ------------------------------ if (encoderPush) { EncoderPush =false; //------------------------------------------------ -------------------------------------------------- -------------- // Wenn eine Ziffer von 0 bis 5 ausgewählt ist, gehe in den Modus DIGITCHANGE //------------ -------------------------------------------------- ------------------------------------- if (idx <=MAXDIGIT - 1) { hideCursor(idx ); // Flash-Cursor-Verzögerung (250); //für selectDigit(idx); //visuelle Bestätigung drawSymbol(2); // Turn-Icon-Modus zeichnen =DIGITCHANGE; //Modus ändern} //------------------------------------------------------- -------------------------------------------------- ---------------- // Andernfalls ist ein Symbol ausgewählt, dann gehen Sie zu OPTIONEN //-------------------- -------------------------------------------------- --------------------------------------- else { if (idx>=MAXDIGIT &&idx <=MAXDIGIT + 2) {idy =idx - MAXDIGIT; selectOption(idy); idy =Optionen[idy]; } } } brechen; //Endmodus SINGLEDIGIT case SWEEP://2 //------------------------------------------------ -------------------------------------------------- -------------------------- // workmode SWEEP:Encoder-Rotation Cursor nach links und rechts bewegen für Optionsauswahl //-------- -------------------------------------------------- -------------------------------------------------- ---- if (encoderSpin) { if (encoderSpin ==CW &&idy <2) idy++; if (encoderSpin ==CCW &&idy> 0) idy--; selectIcon(idy, WEISS); } if (encoderPush) { //------------------------------------------ -------------------------------------------------- --------------------------------------- // workmode SWEEP:Encoder push gehe zu OPTIONS, SWEEP-OPTIONEN oder START/STOP-Sweep //----------------------------------------------------- -------------------------------------------------- ---------------------------------------- EncoderPush =false; Schalter (idy) { Fall 0:lFreq =atol(Freq); selectOption(idy); idy =Optionen[idy]; Verzögerung (100); if (_WorkMode !=2) displayFrequency(lLastFreq); SweepReset(); brechen; Fall 1:lFreq =atol(Freq); drawSymbol(9); drawSymbol(1); displaySweepIcons(); selectIcon(0, WEISS); idy =0; displayFrequency(_Sweep(idy)); Verzögerung (100); SweepReset(); Modus =OPTSWEEP; brechen; Fall 2://** SweepStatus:STILL 0 (nie gestartet), 1 BREAK, 2 PAUSE ** if (sweepStatus ==STILL || SweepStatus ==PAUSE) { drawSymbol(3); // Pausensymbol zeichnen selectIcon (2, WEISS); // Wählen Sie das Symbol FrequencySweep (); // Sweep ausführen} else { // wenn angehalten drawSymbol (4); // Abspielsymbol zeichnen SweepStatus =PAUSE; } brechen; } } if (sweepStatus ==PAUSE) flashIcon(250); // blinkende Pause Textumbruch; // Modus SWEEP beenden Fall OPTIONS://3 if (encoderLongPush) reset(); //------------------------------------------------ -------------------------------------------------- --------------------------------- // mode OPTIONS:Encoder Spin Select Option zum Ändern (Workmode, Wavetype, Couplingmode) ) //----------------------------------------------------------- -------------------------------------------------- ---------------------------------- if (encoderSpin) { if (encoderSpin ==CW &&idy <2) idy++; if (encoderSpin ==CCW &&idy> 0) idy--; selectIcon(idy, WEISS); } //----------------------------------------------------------- -------------------------------------------------- ---------------------------------- // mode OPTIONS:Encoder-Druckschalter in den relativen Modus //--- -------------------------------------------------- -------------------------------------------------- ---------------------------------------- if (encoderPush) { EncoderPush =false; // selectIcon (idy, SCHWARZ); selectOption(idy); ausblendenCursor(0); idy =Optionen[idy]; } brechen; //Endmodus OPTIONS case OPTMODE://4 //------------------------------------- -------------------------------------------------- -------------------------------------------------------- // Modus OPTMODE:Encoder Symbole für den Spin-Select-Modus (logarithmisch, einstellig, Sweep) //------------------------------------------------ -------------------------------------------------- -------------------------------------------------------- if (encoderSpin) { if (encoderSpin ==CW &&idy <2) idy++; if (encoderSpin ==CCW &&idy> 0) idy--; selectIcon(idy, WEISS); } //----------------------------------------------------------- -------------------------------------------------- ---------------------------------- // mode OPTMODE:Encoder push select workmode to set (gespeichert in Option[ 0]) //--------------------------------------------------------- -------------------------------------------------- ------------------------------------ if (encoderPush) { EncoderPush =false; Byte pMode =_WorkMode; switch (idy) { case 0:hideCursor(0); drawSymbol(0); lFreq =lLastFreq; displayFrequency(lFreq); _setWorkMode (LOGARITHMISCH); brechen; Fall 1:drawSymbol(0); selectDigit(0); lFreq =lLastFreq; displayFrequency(lFreq); _setWorkMode (SINGLEDIGIT); brechen; Fall 2:lLastFreq =lFreq; displayFrequency(_SweepMin); // startbereit _setWorkMode (SWEEP); brechen; } mode =_WorkMode; if (pMode !=_WorkMode) saveConfig(); if (_CouplingMode ==OFF) resetCouplingMode(); idx =0; drawAllIcons(); } brechen; //Endmodus OPTMODE case OPTWAVE://5 //------------------------------------- -------------------------------------------------- -------------------------- // Modus OPTWAVE:Encoder-Rotation bewegt den Cursor nach links und rechts für die Wellenauswahl (sqr, sin, tri) //- -------------------------------------------------- -------------------------------------------------- ---------- if (encoderSpin) { if (encoderSpin ==CW &&idy <2) idy++; if (encoderSpin ==CCW &&idy> 0) idy--; selectIcon(idy, WEISS); } //----------------------------------------------------------- -------------------------------------------------- ------------------- // mode OPTWAVE:Encoder push set new wave type //----------------- -------------------------------------------------- ------------------------------------------------ wenn ( EncoderPush) { EncoderPush =false; if (_WaveType !=idy) { _setWaveType(idy); saveConfig(); } Aktualisierungsfrequenz(); // aktualisiert den Wellentyp drawAllIcons (); idx =0; Modus =_WorkMode; } brechen; //Endmodus OPTWAVE case OPTCOUP://6 //------------------------------------- -------------------------------------------------- -------------------------- // Modus OPTCOUP:Drehgeberrotation Cursor nach links und rechts bewegen für Auswahl des Kopplungsmodus //------ -------------------------------------------------- -------------------------------------------------- ----- if (encoderSpin) { if (encoderSpin ==CW &&idy <2) idy++; if (encoderSpin ==CCW &&idy> 0) idy--; selectIcon(idy, WEISS); } //----------------------------------------------------------- -------------------------------------------------- ------------------- // mode OPTCOUP:Encoder push select current Kopplungsmodus //----------------- -------------------------------------------------- ------------------------------------------------ wenn ( EncoderPush) { EncoderPush =false; setCouplingMode(idy); drawAllIcons(); idx =0; Modus =_WorkMode; } brechen; //Endmodus OPTCOUP case OPTSWEEP://7 //------------------------------------------------ -------------------------------------------------- ------------------ // Modus OPTSWEEP:Drehgeber-Spin wählt Sweep-Werte zum Bearbeiten aus //--------- -------------------------------------------------- -------------------------------------------------- --------- if (encoderSpin) { if (encoderSpin ==CW &&idy <2) idy++; // Zeiger im Uhrzeigersinn erhöhen if (encoderSpin ==CCW &&idy> 0) idy--; // gegen den Uhrzeigersinn verringern Zeiger selectIcon (idy, WEISS); // Erstes Symbol auswählen displayFrequency (_Sweep (idy)); // aktuellen Sweep-Wert anzeigen} if (encoderPush) { EncoderPush =false; //------------------------------------------------ -------------------------------------------------- ------------------ // Modus OPTSWEEP:Encoder drücken, Sweep-Werte zum Bearbeiten bestätigen //-------------------- -------------------------------------------------- ------------------------------------------------ drawSymbol( 0); selectDigit(0); selectIcon(idy, WEISS); idx =0; displayFrequency(_Sweep(idy)); Modus =SWEEPEDIT; } brechen; //Endmodus OPTSWEEP case SWEEPEDIT://8 //------------------------------------------------ -------------------------------------------------- -------------------------- // mode SWEEPEDIT:Drehgeber-Drehzahl zum Ändern auswählen //------------- -------------------------------------------------- ---------------------------------------------- if (encoderSpin) { if (encoderSpin ==CW &&idx 0) idx--; //Verkleinerungszeiger gegen den Uhrzeigersinn selectDigit(idx); } //----------------------------------------------------------- -------------------------------------------------- ------------- // mode SWEEPEDIT:Encoder longpush Edit verlassen und zurück zu SWEEP //------------ -------------------------------------------------- --------------------------------------- if (encoderLongPush ==LONGPUSH) { EncoderPush =false; drawAllIcons(); displayFrequency(_SweepMin); HideCursor(idx); _setWorkMode (SWEEP); SweepReset(); Modus =_WorkMode; Verzögerung (250); } if (encoderPush) { EncoderPush =false; //------------------------------------------------ -------------------------------------------------- ----------- // mode SWEEPEDIT:Encoder drücken geht in den Mode DIGITCHANGE //------------------------- -------------------------------------------------- --------------------------------- hideCursor(idx); // Flash-Cursor-Verzögerung (250); //für selectDigit(idx); //visuelle Bestätigung drawSymbol(2); // Turn-Icon-Modus zeichnen =DIGITCHANGE; // Modus ändern } Pause; // Modus beenden SWEEPEDIT case DIGITCHANGE://9 //----------------------------------------- -------------------------------------------------- ------------------------- // mode DIGITCHANGE:Encoder-Longpush-Ausstieg aus DIGITCHANGE im SWEEP-Modus //--------- -------------------------------------------------- ---------------------------------------------- if (encoderLongPush ==LONGPUSH &&_WorkMode ==SWEEP) { EncoderPush =false; HideCursor(idx); drawSymbol(1); Modus =OPTSWEEP; Verzögerung (250); } //----------------------------------------------------------- -------------------------------------------------- -------- // mode DIGITCHANGE:Encoder-Rotationsänderung Digitwert (0 -> 9 ->0 usw.) //-------------------- -------------------------------------------------- ------------------------------------- if (encoderSpin) {//Encoder-Rotation if (encoderSpin ==CW) {// Richtung im Uhrzeigersinn Freq[idx]++; if (Freq[idx]> '9') Freq[idx] ='0'; aufrechtzuerhalten. Sonst {// gegen den Uhrzeigersinn Freq[idx]--; if (Freq[idx] <'0') Freq[idx] ='9'; } updateDigit(idx, Freq[idx]); //Ziffer auf dem Display aktualisieren} //---------------------------------------------------- -------------------------------------------------- -------------- // Modus DIGITCHANGE:Encoder drücken zurück in den Modus SINGLEDIGIT oder SWEEPEDIT //------------ -------------------------------------------------- ---------------------------------- if (encoderPush) {//Encoder Push Flag gesetzt durch Interrupt EncoderPush =false; // Event-Flag zurücksetzen hideCursor (idx); // Flash-Cursor-Verzögerung (250); //für selectDigit(idx); //visuelle Bestätigung drawSymbol (0); if (_WorkMode ==SWEEP) { long ltemp =_Sweep(idy); //Wert speichern _setSweep(idy, atol(Freq)); //neuen Wert von Array in Long konvertieren if (_SweepMax> 0 &&_SweepMax> _SweepMin &&_SweepStep>
0) { //Kongruenz des neuen Sweep-Wertes prüfen if (_Sweep(idy) !=ltemp) saveConfig(); // wenn sich der Wert geändert hat, neuen Wert in EEPROM schreiben displayFrequency (_Sweep (idy)); Modus =SWEEPEDIT; // Modus ändern} else { _displayErrMsg; // Fehlermeldung anzeigen, die im Flash-Speicher gespeichert ist delay (1000); _setSweep(idy, ltemp); // Gespeicherten Wert wiederherstellen displayFrequency (_Sweep (idy)); // Wert erneut anzeigen drawSymbol (2); // Turn-Icon neu zeichnen}} Else {//wenn nicht im Sweep-Modus if (_CouplingMode ==OFF) {//wenn Kopplungsmodus wenn OFF lLastFreq =atol (Freq); // aktuelle Frequenz speichern resetCouplingMode (); // Standard-Kopplungsmodus einstellen} UpdateFrequency(); // Frequenz an DDS-Modulmodus senden =SINGLEDIGIT; // Modus ändern } } Pause; //Endmodus DIGITCHANGE default:break; }}//---------------------------------------------------------- -------------------------------------------------- -----------------------------------// Push-Encoder-Ereignis - Aufruf durch Interrupt//---- -------------------------------------------------- -------------------------------------------------- ---------------------------------------void encoderSwitch(void) { EncoderPush =true;}//--------- -------------------------------------------------- -------------------------------------------------- ---------------------// Dienstprogrammfunktionen//----------------------- -------------------------------------------------- -------------------------------------------------- --------// Grafikschnittstelle zeichnen//---------------------------------- -------------------------------------------------- ---------------------------void drawInterface() { display.clearDisplay(); display.display(); Verzögerung (1000); display.drawRoundRect(0, 0, 128, 64, 3, WEISS); // externen Rahmen zeichnen display.fillRect (1, 1, 126, 14, WEISS); // Bildunterschriftsrahmen zeichnen displayText (12, 4, strFromFlash (0), BLACK, WHITE, SMALL); // Verzögerung des Untertiteltitels drucken (1000); if (cTime ==1) {//nur beim Einschalten von displayText (XPOS - 6, YPOS + 10, strFromFlash (1), WHITE, BLACK, BIG); // Verzögerung der Begrüßungsnachricht anzeigen (1000); display.fillRect(2, 16, display.width() - 3, 35, BLACK); //clear Welcome message cTime =0; } display.display(); displayText(XPOS + 84, YPOS + 4, strFromFlash(2), WHITE, BLACK, SMALL); //print "Hz" sprintf(Freq, "%06li", lFreq); //put frequency value into char array with template "000000" for (int i =MAXDIGIT - 1; i>=0; i--) { display.drawChar(XPOS + 2 + i * DELTAX, YPOS, Freq[i] , WHITE, BLACK, BIG); //Display with animation effect from right to left display.display(); }}//end drawInterface()//----------------------------------------------------------------------------------------------------------------// Print string in x,y pos with specified colors and size//----------------------------------------------------------------------------------------------------------------void displayText(byte x, byte y, const char *str, byte foreColor, byte backColor, byte textSize) { display.setTextSize(textSize); //textsize:SMALL or BIG global const display.setTextColor(foreColor, backColor); //colors WHITE or BLACK global const of the library display.setCursor(x, y); //set the cursor position display.print(str); //str is the pointer to the string of chars display.display(); //update display}//----------------------------------------------------------------------------------------------------------------// Copies element [i] of the string_table array from flash memory to the ram buffer and returns the pointer to the buffer//----------------------------------------------------------------------------------------------------------------char* strFromFlash(byte i) { strcpy_P(buffer, (char*)pgm_read_word(&(string_table[i]))); return (char*)buffer;}//----------------------------------------------------------------------------------------------------------------// Draw or clear a border around selected icon after clearing border of the previous one//----------------------------------------------------------------------------------------------------------------void selectIcon(byte icon, byte color) { static byte prevIcon; display.drawRect(XPOS - 10 + prevIcon * 32, YPOS + 19, 29, 20, BLACK); display.drawRect(XPOS - 10 + icon * 32, YPOS + 19, 29, 20, color); display.display(); prevIcon =icon;}//----------------------------------------------------------------------------------------------------------------// Display all workmode icons//----------------------------------------------------------------------------------------------------------------void displayWorkModeIcons(void) { byte const *bitmap[3] ={imgLog, imgDigit, imgSweep}; _clearIconsArea; for (byte i =0; i <=2; i++) { display.drawBitmap(XPOS - 8 + i * 32, YPOS + 21, bitmap[i], 25, 16, WHITE); } display.display();}//----------------------------------------------------------------------------------------------------------------// Display all wavetype icons//----------------------------------------------------------------------------------------------------------------void displayWaveTypeIcons(void) { byte const *bitmap[3] ={imgSqr, imgSin, imgTri}; _clearIconsArea; for (byte i =0; i <=2; i++) { display.drawBitmap(XPOS - 8 + i * 32, YPOS + 21, bitmap[i], 25, 16, WHITE); } display.display();}//----------------------------------------------------------------------------------------------------------------// Display all coupling mode icons//----------------------------------------------------------------------------------------------------------------void displayCouplingModeIcons(void) { byte const *bitmap[3] ={imgCoAc, imgCoDc, imgCoOff}; _clearIconsArea; for (byte i =0; i <=2; i++) { display.drawBitmap(XPOS - 8 + i * 32, YPOS + 21, bitmap[i], 25, 16, WHITE); } display.display();}//----------------------------------------------------------------------------------------------------------------// Display all sweep icons//----------------------------------------------------------------------------------------------------------------void displaySweepIcons(void) { byte const *bitmap[3] ={imgSwMax, imgSwMin, imgSwStep}; _clearIconsArea; for (byte i =0; i <=2; i++) { display.drawBitmap(XPOS - 8 + i * 32, YPOS + 21, bitmap[i], 25, 16, WHITE); } display.display();}//----------------------------------------------------------------------------------------------------------------// Draw all icons//----------------------------------------------------------------------------------------------------------------void drawAllIcons(void) { _clearIconsArea; drawModeIcon(); if (_WorkMode ==SWEEP || _WorkMode ==SWEEPEDIT ) { display.drawBitmap(XPOS + 24, YPOS + 21, imgSwOpt, 25, 16, WHITE); display.drawBitmap(XPOS + 56, YPOS + 21, imgSwStart, 25, 16, WHITE); drawSymbol(1); idy =2; selectIcon(idy, WHITE); //ready to sweep drawSmallWaveIcon(); drawSmallCouplingIcon(); } else { drawWaveIcon(); drawCouplingIcon(); drawSymbol(0); if (_WorkMode ==SINGLEDIGIT) selectDigit(0); } display.display();}//----------------------------------------------------------------------------------------------------------------// Draws the icon based on the value of relative option//----------------------------------------------------------------------------------------------------------------void drawModeIcon(void) { byte x =XPOS - 8, y =YPOS + 21; byte const *bitmap[3] ={imgLog, imgDigit, imgSweep}; display.fillRect(x, y, 25, 16, BLACK); display.drawBitmap(x, y, bitmap[_WorkMode], 25, 16, WHITE); display.display();}void drawWaveIcon(void) { byte x =XPOS + 24, y =YPOS + 21; const byte *bitmap[3] ={imgSqr, imgSin, imgTri}; display.fillRect(x, y, 25, 16, BLACK); display.drawBitmap(x, y, bitmap[_WaveType], 25, 16, WHITE); display.display(); drawSmallWaveIcon();}void drawCouplingIcon(void) { byte x =XPOS + 56, y =YPOS + 21; const byte *bitmap[3] ={imgCoAc, imgCoDc, imgCoOff}; display.fillRect(x, y, 25, 16, BLACK); display.drawBitmap(x, y, bitmap[_CouplingMode], 25, 16, WHITE); display.display(); drawSmallCouplingIcon();}//----------------------------------------------------------------------------------------------------------------// Draws small wave icon based on the value of relative option//----------------------------------------------------------------------------------------------------------------void drawSmallWaveIcon(void) { byte x =114, y =41; const byte *bitmap[3] ={imgSqrSmall, imgSinSmall, imgTriSmall}; display.fillRect(x, y, 9, 8, BLACK); display.drawBitmap(x, y, bitmap[_WaveType], 9, 8, WHITE); display.display();}//----------------------------------------------------------------------------------------------------------------// Draws small coupling icon based on the value of relative option//----------------------------------------------------------------------------------------------------------------void drawSmallCouplingIcon(void) { byte x =114, y =50; const byte *bitmap[3] ={imgAcSmall, imgDcSmall, imgOffSmall}; display.fillRect(x, y, 9, 8, BLACK); display.drawBitmap(x, y, bitmap[_CouplingMode], 9, 8, WHITE); display.display();}//----------------------------------------------------------------------------------------------------------------// Show cursor at x position//----------------------------------------------------------------------------------------------------------------void showCursor(byte x) { display.drawChar(XPOS + 2 + x * DELTAX, YPOS + DELTAY, CURSOR, WHITE, WHITE, BIG); display.display();}//----------------------------------------------------------------------------------------------------------------// Hide cursor at x position//----------------------------------------------------------------------------------------------------------------void hideCursor(byte x) { display.drawChar(XPOS + 2 + x * DELTAX, YPOS + DELTAY, CURSOR, BLACK, BLACK, BIG); display.display();}//----------------------------------------------------------------------------------------------------------------// Show cursor at x position after hiding previous one//----------------------------------------------------------------------------------------------------------------void selectDigit(byte x) { static byte lastDigit; hideCursor(lastDigit); display.drawChar(XPOS + 2 + x * DELTAX, YPOS + DELTAY, CURSOR, WHITE, WHITE, BIG); display.display(); lastDigit =x;}//----------------------------------------------------------------------------------------------------------------// Update single digit frequency to chr value//----------------------------------------------------------------------------------------------------------------void updateDigit(byte digit, char chr) { display.drawChar(XPOS + 2 + digit * DELTAX, YPOS, chr , WHITE, BLACK, BIG); display.display();}//----------------------------------------------------------------------------------------------------------------// Drwaw or clear some symbols/icons//----------------------------------------------------------------------------------------------------------------void drawSymbol(byte symbol) { switch (symbol) { case 0://Top arrow display.fillRect(2, 20, 25, 16, BLACK); display.fillRect(2, 43, 14, 16, BLACK); display.drawChar(XPOS - 20 , YPOS + 4, ARROW, WHITE, BLACK, SMALL); //draw top arrow top break; case 1://Bottom arrow display.fillRect(2, 20, 25, 16, BLACK); display.fillRect(2, 43, 14, 16, BLACK); display.drawChar(XPOS - 20 , YPOS + 25, ARROW, WHITE, BLACK, SMALL); //draw bottom arrow break; case 2://Turn icon display.fillRect(2, 20, 25, 16, BLACK); display.drawBitmap(XPOS - 21, YPOS + 1, imgTurn, 13, 13, WHITE); //draw turn icon break; case 3://Play icons display.fillRect(4, 23, 23, 11, BLACK); //clear pause icon display.drawBitmap(4, 23, imgSwRun, 23, 11, WHITE); //draw sweep icon display.fillRect(XPOS + 56, YPOS + 21, 25, 16, BLACK); //clear icon area display.drawBitmap(XPOS + 56, YPOS + 21, imgSwPause, 25, 16, WHITE); //drwaw sweep play symbol icon break; case 4://Pause icons display.fillRect(4, 23, 23, 11, BLACK); //clear sweep icon display.drawBitmap(4, 23, imgSwPsd, 23, 11, WHITE); //draw pause icon display.fillRect(XPOS + 56, YPOS + 21, 25, 16, BLACK); //clear icon area display.drawBitmap(XPOS + 56, YPOS + 21, imgSwStart, 25, 16, WHITE); //draw sweep pause symbol icon break; case 9://Simply clear symbol area display.fillRect(2, 20, 25, 16, BLACK); //clear top symbol area display.fillRect(2, 43, 14, 16, BLACK); //clear bottom symbol area break; default:break; } display.display();}//---------------------------------------------------------------------------------------------------------------// Set current frequency in DDS module, if frequency is 0 it will be set to 1//---------------------------------------------------------------------------------------------------------------void UpdateFrequency(void) { lFreq =atol(Freq); //convert char array to long if (lFreq <1) { //the frequency at zero makes no sense ++Freq[MAXDIGIT - 1]; //increase the right most digit lFreq =1; //set frequency to 1 } displayFrequency(lFreq); //update the display DDS_FrequencySet(lFreq, Wave[_WaveType]); //send the frequency value to DDS module lLastFreq =lFreq; //save current freq}//---------------------------------------------------------------------------------------------------------------// Display the frequency with the six-zero template//---------------------------------------------------------------------------------------------------------------void displayFrequency(long f) { sprintf(Freq, "%06li", f); //convert long to char with template '000000' displayText(XPOS + 2, YPOS, Freq , WHITE, BLACK, BIG); //print frequency on display display.display(); //refresh display}//---------------------------------------------------------------------------------------------------------------// Reset coupling mode to default//---------------------------------------------------------------------------------------------------------------void resetCouplingMode(void) { if (lFreq ==0 &&_CouplingMode ==OFF) { setCouplingMode(AC); drawCouplingIcon(); }}//---------------------------------------------------------------------------------------------------------------// Set a specific coupling mode//---------------------------------------------------------------------------------------------------------------void setCouplingMode(byte cMode) { byte pMode =_CouplingMode; switch (cMode) { case 0:if (lLastFreq> 0) lFreq =lLastFreq; digitalWrite(PinCoupling, LOW); _setCouplingMode(AC); brechen; case 1:if (lLastFreq> 0) lFreq =lLastFreq; digitalWrite(PinCoupling, HIGH); _setCouplingMode(DC); brechen; case 2:lLastFreq =lFreq; lFreq =0; digitalWrite(PinCoupling, LOW); _setCouplingMode(OFF); brechen; } DDS_FrequencySet(lFreq, Wave[_WaveType]); displayFrequency(lFreq); if (cMode !=pMode) saveConfig();}//---------------------------------------------------------------------------------------------------------------// Select options//---------------------------------------------------------------------------------------------------------------void selectOption(byte opt) { selectIcon(opt, BLACK); switch (opt) { case 0://workMode; displayWorkModeIcons(); selectIcon(_WorkMode, WHITE); mode =OPTMODE; brechen; case 1://waveType; displayWaveTypeIcons(); selectIcon(_WaveType, WHITE); mode =OPTWAVE; brechen; case 2://couplingMode; displayCouplingModeIcons(); selectIcon(_CouplingMode, WHITE); mode =OPTCOUP; brechen; }}//----------------------------------------------------------------------------------------------------------------// Calculate logarithmic steps of the frequency//----------------------------------------------------------------------------------------------------------------long AutoStep(long value, byte spin) { if (spin ==CW) { if (value>=100000) return 100000; if (value>=10000) return 10000; if (value>=1000) return 1000; if (value>=100) return 100; if (value>=10) return 10; if (value>=1) return 1; return 0; // Invalid value } else { if (value <=10) return 1; if (value <=100) return 10; if (value <=1000) return 100; if (value <=10000) return 1000; if (value <=100000) return 10000; if (value <=1000000) return 100000; return 0; // Invalid value }}//-------------------------------------------------------------------------------------------// Start Sweep or restart it from where it came from before the pause//-------------------------------------------------------------------------------------------void FrequencySweep() { do { if (sweepDnPausedVal ==0) { //if sweepDown has not been stopped if (sweepUpPausedVal> 0) { //and sweepUp has been stopped sweepUpPausedVal =SweepUp(sweepUpPausedVal); //continues from current value } else { sweepUpPausedVal =SweepUp(_SweepMin); //else start from min } } if (sweepStatus !=BREAK) { //if sweep has been stopped if (sweepDnPausedVal> 0) { //and sweepDn has been stopped sweepDnPausedVal =SweepDn(sweepDnPausedVal); //continues from current value } else { sweepDnPausedVal =SweepDn(_SweepMax); //else start from max } } } while (sweepStatus !=BREAK); //continues sweep until stopped}//-----------------------------------------------------------------------------------------// Sweep Up from sweepmin push encoder to pause//-----------------------------------------------------------------------------------------long SweepUp(long sweepmin) { long f; for (f =sweepmin; f <_SweepMax; f +=_SweepStep) { DDS_FrequencySet(f, Wave[_WaveType]); displayFrequency(f); if (encoderPush) { sweepStatus =BREAK; brechen; } } if (sweepStatus ==BREAK) return f; return 0;}//-----------------------------------------------------------------------------------------// Sweep down from sweepmax push encoder to pause//-----------------------------------------------------------------------------------------long SweepDn(long sweepmax) { long f; for (f =sweepmax; f> _SweepMin; f -=_SweepStep) { DDS_FrequencySet(f, Wave[_WaveType]); displayFrequency(f); if (encoderPush) { sweepStatus =BREAK; brechen; } } if (sweepStatus ==BREAK)return f; return 0;}//-----------------------------------------------------------------------------------------// Clear global sweep vars and restore display//-----------------------------------------------------------------------------------------void SweepReset(void) { sweepStatus =STILL; sweepUpPausedVal =0; sweepDnPausedVal =0; display.fillRect(4, 23, 23, 11, BLACK); //clear sweep text display.display();}//-----------------------------------------------------------------------------------------// Flash sweep pause icon//-----------------------------------------------------------------------------------------void flashIcon(int interval) { static long previousMillis; static boolean picShow; if (millis() - previousMillis>=interval) { previousMillis =millis(); picShow =!picShow; if (picShow) { display.drawBitmap(4, 23, imgSwPsd, 23, 11, WHITE); //drwaw sweep pause icon display.display(); } else { display.fillRect(4, 23, 23, 11, BLACK); //clear sweep pause icon display.display(); } }}//-----------------------------------------------------------------------------------------// Arduino software reset//-----------------------------------------------------------------------------------------void reset(void) { display.fillRect(1, 16, 125, 46, BLACK); display.display(); displayText(30, 30, strFromFlash(4), WHITE, BLACK, BIG); char str[2]; for (byte i =3; i> 0; i--) { sprintf(str, "%d", i); displayText(95, 30, str, WHITE, BLACK, BIG);...This file has been truncated, please download it to see its full contents. JXWG_Defs.hC/C++
Declarections section// This file is an integral part of the JX_WaveGenerator.ino and must be// distributed together with the main file to allow it to function correctly.// The same license of the main file applies to this file.// Janux 01/04/2021 on Turin, Italy.#ifndef JXWG_Defs#define JXWG_Defs#include #include //Encoder library, see https://www.arduino.cc/reference/en/libraries/simplerotary/#include // //adaptation of the library for SSD1306 to the SH1106 display, see https://github.com/wonho-maker/Adafruit_SH1106#include #define DEBUG 0#define OLED_RESET -1Adafruit_SH1106 display(OLED_RESET);#define PinA 5 //Encoder pin A#define PinB 4 //Encoder pin B #define PinS 3 //Encoder pin SwitchSimpleRotary Encoder(PinA, PinB, PinS);//list of loop mode#define LOGARITHMIC 0 //+workmode#define SINGLEDIGIT 1 //+workmode#define SWEEP 2 //+workmode#define OPTIONS 3 //-submode of LOGARITHMIC and SINGLEDIGIT#define OPTMODE 4 //-submode of OPTIONS#define OPTWAVE 5 //-submode of OPTIONS#define OPTCOUP 6 //-submode of OPTIONS#define OPTSWEEP 7 //-submode of SWEEP#define SWEEPEDIT 8 //-submode of OPTSWEEP#define DIGITCHANGE 9 //-submode of SINGLEDIGIT and SWEEPEDIT#define PinCoupling 7 //Coupling mode pin (relay pin)//constants #define XPOS 28#define YPOS 21#define DELTAX 12#define DELTAY 4#define SMALL 1#define BIG 2#define CW 1#define CCW 2#define PUSH 1#define LONGPUSH 1//Num Freq digit#define MAXDIGIT 6//Wave type#define SQUARE 0#define SINE 1#define TRIANGLE 2//Coupling mode#define AC 0#define DC 1#define OFF 2//Sweep status#define STILL 0#define BREAK 1#define PAUSE 2//Symbols chars#define CURSOR 0x5F#define ARROW 0x10//AD9833 module Pin connection#define DDS_FSY 9#define DDS_CLK 10#define DDS_DAT 11//AD9833 Wave Type const#define wSquare 0x28#define wSine 0x00#define wTriangle 0x02//-----------------------------------------------------------------------------// Variables declarections //-----------------------------------------------------------------------------//Strings constants placed in flash memory save ram spaceconst char str1[] PROGMEM ="JX WAVE GENERATOR"; // 18 byteconst char str2[] PROGMEM ="WELCOME"; // 8 byteconst char str3[] PROGMEM ="Hz"; // 3 byteconst char str4[] PROGMEM ="ERROR!"; // 7 byteconst char str5[] PROGMEM ="RESET"; // 6 byte //42 byte totalconst char* const string_table[] PROGMEM ={str1, str2, str3, str4, str5};char buffer[18]; //local buffer for string, make sure this is large enough for the largest string it must holdlong lFreq =1000; //main frequency variablelong lLastFreq =1000; //used to save the current freq value in some situationslong sweepUpPausedVal =0; //value of sweep when pusedlong sweepDnPausedVal =0; //value of sweep when pusedlong lSweep[3] ={20000, 0, 100}; //Sweep Hz default value MAX, MIN, STEP;byte sweepStatus =STILL; //current status of the sweep processconst byte Wave[] ={wSquare, wSine, wTriangle}; //array for WaveTypevolatile boolean encoderPush =false; //var used in the routine called by interruptchar Freq[MAXDIGIT + 1]; //array for display frequency in 6 digit template "000000"byte mode =0; //current loop modebyte idx =0; //pointer to digit index (0 to 5)byte idy =0; //same of idx in submodelong cTime =1; //screensaver counter//default startup preferencesbyte options[3] ={LOGARITHMIC, SINE, DC}; //mode, wavetype, couplingmode//define others macros#define _WorkMode options[0]#define _setWorkMode(x) options[0]=x#define _WaveType options[1]#define _setWaveType(x) options[1]=x#define _CouplingMode options[2]#define _setCouplingMode(x) options[2]=x#define _reservedbyte 0xFF#define _SweepMax lSweep[0]#define _SweepMin lSweep[1]#define _SweepStep lSweep[2]#define _Sweep(x) lSweep[x]#define _setSweep(x,f) lSweep[x]=f#define _setSweepMax(x) lSweep[0]=x#define _setSweepMin(x) lSweep[1]=x#define _setSweepStep(x) lSweep[2]=x//define short functions macros#define _clearIconsArea display.fillRect(XPOS - 11, YPOS + 18, 94, 24, BLACK)#define _displayErrMsg displayText(XPOS + 2, YPOS, strFromFlash(3), WHITE, BLACK, BIG);//define CONFIG consts &vars #define CONFIG_START 32 //EEPROM Memory start location#define CONFIG_VERSION "JXWG1" //Config version ID//define custom type structtypedef struct { char version[6]; byte workmode; byte wavetype; byte couplingmode; byte reservedbyte; long sweepmax; long sweepmin; long sweepstep;} config_type;//create new struct and load it with default valueconfig_type CONFIG ={ CONFIG_VERSION, _WorkMode, _WaveType, _CouplingMode, _reservedbyte, _SweepMax, _SweepMin, _SweepStep,};//define processor reset functionvoid(*ATmegaReset)(void) =0;#endif
JXWG_Graphics.hC/C++
Icon resource data file// This file is an integral part of the JX_WaveGenerator.ino and must be// distributed together with the main file to allow it to function correctly.// The same license of the main file applies to this file.// Janux 01/04/2021 on Turin, Italy.#ifndef JXWG_Graphics#define JXWG_Graphics//----------------------------------------------------------------------------------------------// Plain b&w bitmaps PROGMEM icons data//----------------------------------------------------------------------------------------------const byte imgLog[] PROGMEM ={ 0xff, 0xff, 0xff, 0x80, 0x80, 0x00, 0x00, 0x80, 0x88, 0x00, 0x40, 0x80, 0x9c, 0x00, 0x40, 0x80, 0x88, 0x00, 0x80, 0x80, 0x88, 0x00, 0x80, 0x80, 0x88, 0x01, 0x00, 0x80, 0x88, 0x02, 0x00, 0x80, 0x88, 0x0c, 0x00, 0x80, 0x88, 0x30, 0x00, 0x80, 0x89, 0xc0, 0x00, 0x80, 0x8e, 0x00, 0x10, 0x80, 0x9f, 0xff, 0xf8, 0x80, 0x88, 0x00, 0x10, 0x80, 0x80, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0x80};const byte imgDigit[] PROGMEM ={ 0xff, 0xff, 0xff, 0x80, 0x80, 0x00, 0x00, 0x80, 0x80, 0x00, 0x00, 0x80, 0x80, 0x00, 0x00, 0x80, 0x9c, 0x47, 0x3e, 0x80, 0xa2, 0xc8, 0x82, 0x80, 0xa6, 0x40, 0x84, 0x80, 0xaa, 0x47, 0x0c, 0x80, 0xb2, 0x48, 0x02, 0x80, 0xa2, 0x48, 0x22, 0x80, 0x9c, 0xef, 0x9c, 0x80, 0x80, 0x00, 0x00, 0x80, 0x80, 0x00, 0x3e, 0x80, 0x80, 0x00, 0x00, 0x80, 0x80, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0x80};const byte imgSweep[] PROGMEM ={ 0xff, 0xff, 0xff, 0x80, 0x80, 0x00, 0x00, 0x80, 0x80, 0x00, 0x00, 0x80, 0x8f, 0xcf, 0x38, 0x80, 0x88, 0x49, 0x28, 0x80, 0x88, 0x49, 0x28, 0x80, 0x88, 0x49, 0x28, 0x80, 0x88, 0x49, 0x28, 0x80, 0x88, 0x49, 0x28, 0x80, 0x88, 0x49, 0x28, 0x80, 0x88, 0x49, 0x28, 0x80, 0x88, 0x49, 0x28, 0x80, 0x88, 0x49, 0x28, 0x80, 0xb8, 0x79, 0xee, 0x80, 0x80, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0x80};const byte imgSqr[] PROGMEM ={ 0xff, 0xff, 0xff, 0x80, 0x82, 0x08, 0x20, 0x80, 0x80, 0xff, 0x80, 0x80, 0x82, 0x88, 0xa0, 0x80, 0x80, 0x80, 0x80, 0x80, 0x82, 0x88, 0xa0, 0x80, 0x80, 0x80, 0x80, 0x80, 0xaa, 0xaa, 0xaa, 0x80, 0x80, 0x80, 0x80, 0x80, 0x82, 0x88, 0xa0, 0x80, 0x80, 0x80, 0x80, 0x80, 0x82, 0x88, 0xa0, 0x80, 0xff, 0x80, 0xff, 0x80, 0x82, 0x08, 0x20, 0x80, 0x80, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0x80};const byte imgSin[] PROGMEM ={ 0xff, 0xff, 0xff, 0x80, 0x82, 0x08, 0x20, 0x80, 0x80, 0x1c, 0x00, 0x80, 0x82, 0x2a, 0x20, 0x80, 0x80, 0x41, 0x00, 0x80, 0x82, 0x49, 0x20, 0x80, 0x80, 0x80, 0x80, 0x80, 0xaa, 0xaa, 0xaa, 0x80, 0x80, 0x80, 0x80, 0x80, 0xc3, 0x08, 0x61, 0x80, 0xc1, 0x00, 0x41, 0x80, 0xa2, 0x08, 0x22, 0x80, 0x9c, 0x00, 0x1c, 0x80, 0x82, 0x08, 0x20, 0x80, 0x80, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0x80};const byte imgTri[] PROGMEM ={ 0xff, 0xff, 0xff, 0x80, 0x82, 0x08, 0x20, 0x80, 0x82, 0x00, 0x20, 0x80, 0x87, 0x08, 0x70, 0x80, 0x85, 0x00, 0x50, 0x80, 0x8a, 0x88, 0xa8, 0x80, 0x88, 0x80, 0x88, 0x80, 0xba, 0xeb, 0xae, 0x80, 0x90, 0x41, 0x04, 0x80, 0xa2, 0x2a, 0x22, 0x80, 0xa0, 0x22, 0x02, 0x80, 0xc2, 0x1c, 0x21, 0x80, 0xc0, 0x14, 0x01, 0x80, 0x82, 0x08, 0x20, 0x80, 0x80, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0x80};const byte imgCoAc[] PROGMEM ={ 0xff, 0xff, 0xff, 0x80, 0x80, 0x00, 0x00, 0x80, 0x80, 0x00, 0x00, 0x80, 0x80, 0x00, 0x00, 0x80, 0x9c, 0x70, 0x00, 0x80, 0xa2, 0x88, 0x00, 0x80, 0xa2, 0x80, 0xc0, 0x80, 0xa2, 0x81, 0x24, 0x80, 0xbe, 0x81, 0x24, 0x80, 0xa2, 0x88, 0x18, 0x80, 0xa2, 0x70, 0x00, 0x80, 0x80, 0x00, 0x00, 0x80, 0x80, 0x00, 0x00, 0x80, 0x80, 0x00, 0x00, 0x80, 0x80, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0x80};const byte imgCoDc[] PROGMEM ={ 0xff, 0xff, 0xff, 0x80, 0x80, 0x00, 0x00, 0x80, 0x80, 0x00, 0x00, 0x80, 0x80, 0x00, 0x00, 0x80, 0xbc, 0x70, 0x00, 0x80, 0xa2, 0x88, 0x00, 0x80, 0xa2, 0x81, 0x54, 0x80, 0xa2, 0x80, 0x00, 0x80, 0xa2, 0x81, 0xfc, 0x80, 0xa2, 0x88, 0x00, 0x80, 0xbc, 0x70, 0x00, 0x80, 0x80, 0x00, 0x00, 0x80, 0x80, 0x00, 0x00, 0x80, 0x80, 0x00, 0x00, 0x80, 0x80, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0x80};const byte imgCoOff[] PROGMEM ={ 0xff, 0xff, 0xff, 0x80, 0x80, 0x00, 0x00, 0x80, 0x80, 0x00, 0x00, 0x80, 0x80, 0x00, 0x00, 0x80, 0x9c, 0xf7, 0x80, 0x80, 0xa2, 0x84, 0x22, 0x80, 0xa2, 0x84, 0x14, 0x80, 0xa2, 0xe7, 0x08, 0x80, 0xa2, 0x84, 0x14, 0x80, 0xa2, 0x84, 0x22, 0x80, 0x9c, 0x84, 0x00, 0x80, 0x80, 0x00, 0x00, 0x80, 0x80, 0x00, 0x00, 0x80, 0x80, 0x00, 0x00, 0x80, 0x80, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0x80};const byte imgSwMax[] PROGMEM ={ 0xff, 0xff, 0xff, 0x80, 0x80, 0x00, 0x00, 0x80, 0x80, 0x00, 0x00, 0x80, 0x80, 0x00, 0x00, 0x80, 0x81, 0x00, 0x00, 0x80, 0x82, 0x00, 0x00, 0x80, 0x87, 0x01, 0x00, 0x80, 0x82, 0x03, 0x80, 0x80, 0x82, 0x07, 0xc0, 0x80, 0x82, 0x0f, 0xe0, 0x80, 0x82, 0x1f, 0xf0, 0x80, 0x80, 0x00, 0x00, 0x80, 0x80, 0x00, 0x00, 0x80, 0x80, 0x00, 0x00, 0x80, 0x80, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0x80};const byte imgSwMin[] PROGMEM ={ 0xff, 0xff, 0xff, 0x80, 0x80, 0x00, 0x00, 0x80, 0x80, 0x00, 0x00, 0x80, 0x80, 0x00, 0x00, 0x80, 0x81, 0x00, 0x00, 0x80, 0x82, 0x00, 0x00, 0x80, 0x87, 0x1f, 0xf0, 0x80, 0x82, 0x0f, 0xe0, 0x80, 0x82, 0x07, 0xc0, 0x80, 0x82, 0x03, 0x80, 0x80, 0x82, 0x01, 0x00, 0x80, 0x80, 0x00, 0x00, 0x80, 0x80, 0x00, 0x00, 0x80, 0x80, 0x00, 0x00, 0x80, 0x80, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0x80};const byte imgSwOpt[] PROGMEM ={ 0xff, 0xff, 0xff, 0x80, 0x80, 0x00, 0x00, 0x80, 0x80, 0x00, 0x00, 0x80, 0x80, 0x00, 0x00, 0x80, 0x84, 0x08, 0x10, 0x80, 0x88, 0x1c, 0x38, 0x80, 0x9c, 0x3e, 0x10, 0x80, 0x88, 0x00, 0x00, 0x80, 0x88, 0x00, 0x00, 0x80, 0x88, 0x3e, 0x00, 0x80, 0x88, 0x1c, 0x38, 0x80, 0x88, 0x08, 0x00, 0x80, 0x80, 0x00, 0x00, 0x80, 0x80, 0x00, 0x00, 0x80, 0x80, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0x80};const byte imgSwStep[] PROGMEM ={ 0xff, 0xff, 0xff, 0x80, 0x80, 0x00, 0x00, 0x80, 0x80, 0x00, 0x00, 0x80, 0x80, 0x00, 0x00, 0x80, 0x84, 0x08, 0x04, 0x80, 0x88, 0x0c, 0x08, 0x80, 0x9c, 0x7e, 0x1c, 0x80, 0x88, 0x7f, 0x08, 0x80, 0x88, 0x7e, 0x08, 0x80, 0x88, 0x0c, 0x08, 0x80, 0x88, 0x08, 0x08, 0x80, 0x80, 0x00, 0x00, 0x80, 0x80, 0x00, 0x00, 0x80, 0x80, 0x00, 0x00, 0x80, 0x80, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0x80};const byte imgSwStart[] PROGMEM ={ 0xff, 0xff, 0xff, 0x80, 0x80, 0x00, 0x00, 0x80, 0x80, 0x00, 0x00, 0x80, 0x80, 0xc0, 0x00, 0x80, 0x80, 0xf0, 0x00, 0x80, 0x80, 0xfc, 0x00, 0x80, 0x80, 0xff, 0x00, 0x80, 0x80, 0xff, 0xc0, 0x80, 0x80, 0xff, 0xc0, 0x80, 0x80, 0xff, 0x00, 0x80, 0x80, 0xfc, 0x00, 0x80, 0x80, 0xf0, 0x00, 0x80, 0x80, 0xc0, 0x00, 0x80, 0x80, 0x00, 0x00, 0x80, 0x80, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0x80};const byte imgSwPause[] PROGMEM ={ 0xff, 0xff, 0xff, 0x80, 0x80, 0x00, 0x00, 0x80, 0x80, 0x00, 0x00, 0x80, 0x81, 0xe3, 0xc0, 0x80, 0x81, 0xe3, 0xc0, 0x80, 0x81, 0xe3, 0xc0, 0x80, 0x81, 0xe3, 0xc0, 0x80, 0x81, 0xe3, 0xc0, 0x80, 0x81, 0xe3, 0xc0, 0x80, 0x81, 0xe3, 0xc0, 0x80, 0x81, 0xe3, 0xc0, 0x80, 0x81, 0xe3, 0xc0, 0x80, 0x81, 0xe3, 0xc0, 0x80, 0x80, 0x00, 0x00, 0x80, 0x80, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0x80};const byte imgTurn[] PROGMEM ={ 0x0f, 0x80, 0x30, 0x60, 0x47, 0x10, 0x58, 0xd0, 0x90, 0x48, 0x80, 0xe8, 0x90, 0x48, 0xb8, 0x08, 0x90, 0x48, 0x58, 0xd0, 0x47, 0x10, 0x30, 0x60, 0x0f, 0x80};const byte imgSwRun[] PROGMEM ={ 0x00, 0x00, 0x00, 0xff, 0xff, 0xfe, 0x9b, 0xa2, 0x22, 0x6b, 0xae, 0xec, 0x7b, 0xae, 0xec, 0x9a, 0xa6, 0x62, 0xea, 0xae, 0xee, 0x6a, 0xae, 0xee, 0x9c, 0x62, 0x2e, 0xff, 0xff, 0xfe, 0x00, 0x00, 0x00};const byte imgSwPsd[] PROGMEM ={ 0x00, 0x00, 0x00, 0xff, 0xff, 0xfe, 0x1c, 0xdb, 0x30, 0x6b, 0x5a, 0xd6, 0x6b, 0x5a, 0xf6, 0x18, 0x5b, 0x32, 0x7b, 0x5b, 0xd6, 0x7b, 0x5a, 0xd6, 0x7b, 0x67, 0x30, 0xff, 0xff, 0xfe, 0x00, 0x00, 0x00};//Small icons ---------------------------------------------------------------------------------const byte imgSqrSmall[] PROGMEM ={ 0x00, 0x00, 0x3e, 0x00, 0x22, 0x00, 0x22, 0x00, 0x22, 0x00, 0x22, 0x00, 0xe3, 0x80, 0x00, 0x00};const byte imgSinSmall[] PROGMEM ={ 0x00, 0x00, 0x30, 0x00, 0x48, 0x00, 0x48, 0x00, 0x84, 0x80, 0x84, 0x80, 0x03, 0x00, 0x00, 0x00};const byte imgTriSmall[] PROGMEM ={ 0x00, 0x00, 0x20, 0x00, 0x50, 0x00, 0x88, 0x80, 0x05, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00};const byte imgAcSmall[] PROGMEM ={ 0x00, 0x00, 0x30, 0x00, 0x48, 0x00, 0x48, 0x00, 0x84, 0x80, 0x84, 0x80, 0x03, 0x00, 0x00, 0x00};const byte imgDcSmall[] PROGMEM ={ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xaa, 0x80, 0x00, 0x00, 0xff, 0x80, 0x00, 0x00, 0x00, 0x00};const byte imgOffSmall[] PROGMEM ={ 0x00, 0x00, 0x00, 0x00, 0x22, 0x00, 0x14, 0x00, 0x08, 0x00, 0x14, 0x00, 0x22, 0x00, 0x00, 0x00};//Total program memory space used by icons data:1148 byte#endif 
Display type updated 