JX Wave Generator

Code

• JX_Wave_Generator_8.7.7.ino
• JXWG_Defs.h
• JXWG_Graphics.h

JX_Wave_Generator_8.7.7.inoC/C++

/* Copyright (c) 2020 Janux Toestemming wordt hierbij gratis verleend aan eenieder die een kopie van deze software en bijbehorende documentatiebestanden (de "Software") verkrijgt, om in de Software zonder beperking, met inbegrip van maar niet beperkt tot de rechten om kopieën van de Software te gebruiken, kopiëren, wijzigen, samenvoegen, publiceren, distribueren, in sublicentie te geven en/of te verkopen, en om personen aan wie de Software wordt geleverd toe te staan ​​dit te doen, behoudens aan de volgende voorwaarden:De bovenstaande copyrightkennisgeving en deze toestemmingskennisgeving moeten worden opgenomen in alle kopieën of substantiële delen van de software. DE SOFTWARE WORDT GELEVERD "AS IS", ZONDER ENIGE GARANTIE, EXPLICIET OF IMPLICIET, INCLUSIEF MAAR NIET BEPERKT TOT DE GARANTIES VAN VERKOOPBAARHEID, GESCHIKTHEID VOOR EEN BEPAALD DOEL EN NIET-INBREUK. IN GEEN GEVAL ZULLEN DE AUTEURS OF AUTEURSRECHTHOUDERS AANSPRAKELIJK ZIJN VOOR ENIGE CLAIM, SCHADE OF ANDERE AANSPRAKELIJKHEID, HETZIJ IN EEN OVEREENKOMST, ONRECHTMATIGHEID OF ANDERSZINS, VOORTVLOEIEND UIT, UIT OF IN VERBAND MET DE SOFTWARE OF HET GEBRUIK IN OF DE ANDERE HANDELINGEN SOFTWARE. De configuratiebesparende laadcode is een ontwikkeling van een origineel idee van het artikel "Hoe configuraties op een Arduino te laden en op te slaan" door Ragnar Ranyen Homb op de Norwegian Creation-website.*/#include "JXWG_Defs.h"#include "JXWG_Graphics .h"void setup() { // als u een eenvoudige encoder en 3x10K pullup-weerstanden gebruikt, past u deze instellingen toe onder pinMode (PinA, INPUT); pinMode (PinB, INPUT); pinMode (PinS, INPUT); // als u een eenvoudige encoder gebruikt zonder 3x10K-weerstanden, gebruik dan de volgende boomrij //pinMode (PinA, INPUT_PULLUP); //pinMode (PinB, INPUT_PULLUP); //pinMode (PinS, INPUT_PULLUP); // DE MEESTE PCB GELASTEN ENCODERS HEBBEN REEDS PULLUP WEERSTANDEN OP PIN A EN B MAAR NIET OP DE SCHAKELAAR PIN // gebruik dan de onderstaande instellingen //pinMode (PinA, INPUT); //pinMode (PinB, INPUT); //pinMode (PinS, INPUT_PULLUP); digitalWrite (PinA, HOOG); digitalWrite (PinB, HOOG); digitalWrite (Pinnen, HOOG); pinMode (PinCoupling, UITGANG); // Koppelmodus Encoder.setDebounceDelay (5); display.begin(SH1106_SWITCHCAPVCC, 0x3C); // initialiseer met de I2C-addr 0x3C (voor de 128x64) display.clearDisplay(); //display.setRotation(2); // verwijder commentaar op deze regel als u het scherm ondersteboven wilt monteren Wire.begin(); // join i2c bus als master TWBR =5; // freq =615 kHz periode =1.625 uS // Wijst encoderschakelaar-push-gebeurtenis toe om 1 pin 3 van Arduino attachInterrupt (digitalPinToInterrupt (PinS), encoderSwitch, FALLING) te onderbreken; DDS_Init(); // Initialiseer de DDS-module; setConfig(); // Laad config en stel opstartwaarden in} //---> end setup()void loop() { JX_WaveGenerator_MAIN();}//------------------- -------------------------------------------------- -------------------------------------------------- ------------------// JX WaveGenerator HOOFDfunctie//------------------------ -------------------------------------------------- -------------------------------------------------- -------------void JX_WaveGenerator_MAIN() { byte encoderSpin =Encoder.rotate(); //Encoder rotatierichting 1=CW, 2=CCW byte encoderLongPush =Encoder.pushLong(1000); // encoder lange push-gebeurtenis lang lStep =0; // huidige frequentiestapwaarde lang wTime =600000; //10 min als (encoderPush) vertraging (250); if (encoderSpin) { cTime =millis(); } else { if (millis() - cTime> wTime) { ScreenSaver(); } } schakelaar (modus) { case LOGARITHMIC://0 //----------------------------------- -------------------------------------------------- ---------------------------------------------- // modus LOGARITMISCHE :Veranderingsfrequentie encoderrotatie in logaritmische stap 1,10,100,1000,10000,100000 Hz //------------------------------ -------------------------------------------------- -------------------------------------------------- - if (encoderSpin) {if (lFreq>=1) { lStep =AutoStep(lFreq, encoderSpin); // Bereken logaritmische stap} else if (_CouplingMode ==UIT) {// als de koppelingsmodus is ingesteld op UIT resetCouplingMode (); // stel de standaard koppelingsmodus in wanneer de frequentie niet 0 is encoderSpin =0; // sla eerste draai over } if (encoderSpin ==CW &&lFreq <=999999 - lStep) {// draai CW verhoog de frequentie lFreq +=lStep; } if (encoderSpin ==CCW &&lFreq>=lStep + 1) {//spin CCW verlaagt de frequentie lFreq -=lStep; } DDS_FrequencySet(lFreq, Wave[_WaveType]); // stuur de frequentiewaarde naar DDS-module displayFrequency (lFreq); // stuur geformatteerde freq om lLastFreq =lFreq weer te geven; // huidige freq opslaan } //------------------------------------------ -------------------------------------------------- --------------------------------------- // werkmodus LOGARITHMISCH:Encoder-drukschakelaar naar OPTIES-modus //------------------------------------------------ -------------------------------------------------- --------------------------------- if (encoderPush) { encoderPush =false; //Clear push flag drawSymbol (1); // teken pijlsymbool selectIcon (0, WIT); // teken een rand rond het eerste pictogram idx =0; idy =0; //reset pointers var mode =OPTIES; // ga naar modus OPTIES} pauze; //eindmodus LOGARITHMISCH geval ENKELVOUDIG://1 //------------------------------------- -------------------------------------------------- ---------------------- // submodus SINGLEDIGIT:Encoder rotatie cursor naar links en rechts verplaatsen //-------------- -------------------------------------------------- --------------------------------------------- if (encoderSpin) { if (encoderSpin ==CW &&idx  0) idx--; //aanwijzer tegen de klok in verlagen //------------------------------------------- -------------------------------------------------- --------------- // wanneer idx van 0 tot 5 is, selecteer frequentiecijfers //--------------------- -------------------------------------------------- ------------------------------------- if (idx>=0 &&idx =MAXDIGIT &&idx <=MAXDIGIT + 2) { // als de huidige positie buiten de cijfers ligt hideCursor (MAXDIGIT - 1); //cursor verbergen op laatste cijfer drawSymbol (1); // teken dn pijl selectIcon (idx - MAXDIGIT, WIT); //selecteer icoon } } //------------------------------------------ -------------------------------------------------- --------------------------------------- // submodus SINGLEDIGIT:Encoder push-gebeurtenis //- -------------------------------------------------- -------------------------------------------------- ------------------------------ if (encoderPush) { encoderPush =false; //------------------------------------------------ -------------------------------------------------- ----------- // als een cijfer van 0 tot 5 is geselecteerd ga naar de modus DIGITCHANGE //---------------------- -------------------------------------------------- ------------------------------------- if (idx <=MAXDIGIT - 1) { hideCursor(idx ); // flitscursor vertraging (250); // voor selectDigit (idx); //visuele bevestiging drawSymbol (2); //teken draai-pictogrammodus =DIGITCHANGE; //Wijzig modus } //------------------------------------------- -------------------------------------------------- ---------------- // anders is er een icoon geselecteerd ga dan naar OPTIES //-------------------- -------------------------------------------------- --------------------------------------- else { if (idx>=MAXDIGIT &&idx <=MAXDIGIT + 2) {idy =idx - MAXDIGIT; selecteerOption(idy); idy =opties[idy]; } } } pauze; //eindmodus SINGLEDIGIT case SWEEP://2 //------------------------------------- -------------------------------------------------- ------------------------- // werkmodus SWEEP:Encoder rotatie verplaats cursor naar links en rechts voor optie selectie //-------- -------------------------------------------------- -------------------------------------------------- ---- if (encoderSpin) { if (encoderSpin ==CW &&idy <2) idy++; if (encoderSpin ==CCW &&idy> 0) idy--; selectIcon(idy, WIT); } if (encoderPush) { //------------------------------------------ -------------------------------------------------- --------------------------------------- // werkmodus SWEEP:Encoder push ga naar OPTIES, SWEEP OPTIES of START/STOP sweep //----------------------------------------- -------------------------------------------------- ---------------------------------------- encoderPush =false; switch (idy) {geval 0:lFreq =atol(Freq); selecteerOption(idy); idy =opties[idy]; vertraging (100); if (_WorkMode !=2) displayFrequency(lLastFreq); SweepReset(); pauze; geval 1:lFreq =atol(Freq); tekensymbool (9); tekenSymbool(1); displaySweepIcons(); selectIcon(0, WIT); idy =0; displayFrequency(_Sweep(idy)); vertraging (100); SweepReset(); modus =OPTSWEEP; pauze; geval 2://** sweepStatus:STILL 0 (nooit gestart), 1 BREAK, 2 PAUSE ** if (sweepStatus ==STILL || sweepStatus ==PAUSE) { drawSymbol (3); // teken pauzepictogram selectIcon (2, WIT); // selecteer pictogram FrequencySweep (); //run sweep } else { //if gepauzeerd drawSymbol (4); //draw play-pictogram sweepStatus =PAUZE; } pauze; } } if (sweepStatus ==PAUZE) flashIcon(250); // knipperende pauze tekstonderbreking; // end mode SWEEP case OPTIES://3 if (encoderLongPush) reset(); //------------------------------------------------ -------------------------------------------------- --------------------------------- // modus OPTIES:Encoder spin select optie om te veranderen (werkmodus, golftype, koppelingsmodus ) //----------------------------------------------- -------------------------------------------------- ---------------------------------- if (encoderSpin) { if (encoderSpin ==CW &&idy <2) idy++; if (encoderSpin ==CCW &&idy> 0) idy--; selectIcon(idy, WIT); } //----------------------------------------------- -------------------------------------------------- ---------------------------------- // modus OPTIES:Encoder drukschakelaar naar relatieve modus //--- -------------------------------------------------- -------------------------------------------------- ---------------------------- if (encoderPush) { encoderPush =false; //selectIcon (idy, ZWART); selecteerOption(idy); verbergCursor(0); idy =opties[idy]; } pauze; // eindmodus OPTIES geval OPTMODE://4 //------------------------------------- -------------------------------------------------- -------------------------------------------- // modus OPTMODE:Encoder draai selectie modus iconen (logaritmisch, enkelcijferig, sweep) //------------------------------------- -------------------------------------------------- -------------------------------------------- if (encoderSpin) { if (encoderSpin ==CW &&idy <2) idy++; if (encoderSpin ==CCW &&idy> 0) idy--; selectIcon(idy, WIT); } //----------------------------------------------- -------------------------------------------------- ---------------------------------- // modus OPTMODE:Encoder druk op selecteer werkmodus om in te stellen (opgeslagen in optie [ 0]) //--------------------------------------------- -------------------------------------------------- ------------------------------------ if (encoderPush) { encoderPush =false; byte pMode =_WerkMode; switch (idy) { case 0:hideCursor(0); drawSymbol(0); lFreq =lLastFreq; displayFrequency(lFreq); _setWorkMode(LOGARITHMISCH); pauze; geval 1:drawSymbol (0); selecteer cijfer (0); lFreq =lLastFreq; displayFrequency(lFreq); _setWorkMode (ENKELVOUDIG); pauze; geval 2:lLastFreq =lFreq; displayFrequency(_SweepMin); // klaar om _setWorkMode (SWEEP) te starten; pauze; } modus =_Werkmodus; if (pMode!=_WorkMode) saveConfig(); if (_CouplingMode ==UIT) resetCouplingMode(); idx =0; drawAllIcons(); } pauze; //eindmodus OPTMODE geval OPTWAVE://5 //------------------------------------- -------------------------------------------------- ------------------------- // modus OPTWAVE:Encoder rotatie verplaats cursor naar links en rechts voor golfselectie (sqr, sin, tri) //- -------------------------------------------------- -------------------------------------------------- ----------- if (encoderSpin) { if (encoderSpin ==CW &&idy <2) idy++; if (encoderSpin ==CCW &&idy> 0) idy--; selectIcon(idy, WIT); } //----------------------------------------------- -------------------------------------------------- ------------------- // modus OPTWAVE:Encoder push set nieuw golftype //------------------ -------------------------------------------------- ------------------------------------------------ als ( encoderPush) { encoderPush =onwaar; if (_WaveType!=idy) { _setWaveType(idy); saveConfig(); } Updatefrequentie(); //updates wavetype drawAllIcons(); idx =0; modus =_Werkmodus; } pauze; // eindmodus OPTWAVE geval OPTCOUP://6 //------------------------------------- -------------------------------------------------- ------------------------- // modus OPTCOUP:Encoder rotatie verplaats cursor naar links en rechts voor selectie van koppelingsmodus //------- -------------------------------------------------- -------------------------------------------------- ----- if (encoderSpin) { if (encoderSpin ==CW &&idy <2) idy++; if (encoderSpin ==CCW &&idy> 0) idy--; selectIcon(idy, WIT); } //----------------------------------------------- -------------------------------------------------- ------------------- // modus OPTCOUP:Encoder push select huidige koppeling modus //------------------ -------------------------------------------------- ------------------------------------------------ als ( encoderPush) { encoderPush =onwaar; setCouplingMode(idy); drawAllIcons(); idx =0; modus =_Werkmodus; } pauze; //eindmodus OPTCOUP geval OPTSWEEP://7 //------------------------------------- -------------------------------------------------- ----------------------------- // modus OPTSWEEP:Encoder spin selecteer sweep-waarden om te bewerken //------- -------------------------------------------------- -------------------------------------------------- --------- if (encoderSpin) { if (encoderSpin ==CW &&idy <2) idy++; //wijzerwijzer verhogen als (encoderSpin ==CCW &&idy> 0) idy--; // tegen de klok in verlaag de aanwijzer selectIcon (idy, WIT); //selecteer eerste pictogram displayFrequency (_Sweep (idy)); // toon huidige sweep-waarde} if (encoderPush) { encoderPush =false; //------------------------------------------------ -------------------------------------------------- ------------------ // modus OPTSWEEP:Encoder push bevestigen sweep-waarden om te bewerken //------------------ -------------------------------------------------- ------------------------------------------------ drawSymbol( 0); selecteer cijfer (0); selectIcon(idy, WIT); idx =0; displayFrequency(_Sweep(idy)); modus =VEEGBEWERKEN; } pauze; //End mode OPTSWEEP case SWEEPEDIT://8 //------------------------------------- -------------------------------------------------- ----------------------- // modus SWEEPEDIT:Encoder draai selecteer cijfer om te veranderen //-------------- -------------------------------------------------- ---------------------------------------------- if (encoderSpin) { if (encoderSpin ==CW &&idx  0) idx--; // tegen de klok in verlaag de aanwijzer selectDigit (idx); } //----------------------------------------------- -------------------------------------------------- ------------- // modus SWEEPEDIT:Encoder longpush verlaten van bewerken en terugkeren naar SWEEP //--------------------- -------------------------------------------------- --------------------------------------- if (encoderLongPush ==LONGPUSH) { encoderPush =false; drawAllIcons(); displayFrequency(_SweepMin); verbergCursor(idx); _setWorkMode(VEGEN); SweepReset(); modus =_Werkmodus; vertraging (250); } if (encoderPush) { encoderPush =false; //------------------------------------------------ -------------------------------------------------- ----------- // modus SWEEPEDIT:Encoder push ga naar modus DIGITCHANGE //-------------------------- -------------------------------------------------- --------------------------------- hideCursor(idx); // flitscursor vertraging (250); // voor selectDigit (idx); //visuele bevestiging drawSymbol (2); //teken draai-pictogrammodus =DIGITCHANGE; //modus wijzigen} pauze;//eindmodus SWEEPEDIT case DIGITCHANGE://9 //------------------------------ -------------------------------------------------- ------------------------- // modus DIGITCHANGE:Encoder longpush verlaat DIGITCHANGE in SWEEP-modus //--------- -------------------------------------------------- ---------------------------------------------- if (encoderLongPush ==LONGPUSH &&_WorkMode ==SWEEP) { encoderPush =false; verbergCursor(idx); tekenSymbool(1); modus =OPTSWEEP; vertraging (250); } //----------------------------------------------- -------------------------------------------------- -------- // modus DIGITCHANGE:Encoder rotatie wijziging cijferwaarde (0 -> 9 ->0 enzovoort) //------------------ -------------------------------------------------- ------------------------------------- if (encoderSpin) {//encoder rotatie if (encoderSpin ==CW) {//wijzerzin Freq[idx]++; if (Freq[idx]> '9') Freq[idx] ='0'; } else { // tegen de klok in richting Freq[idx]--; if (Freq[idx] <'0') Freq[idx] ='9'; } updateDigit(idx, Freq[idx]); //cijfer op display bijwerken } //----------------------------------------- -------------------------------------------------- -------------- // modus DIGITCHANGE:Encoder druk terug naar modus SINGLEDIGIT of SWEEPEDIT //--------------------- -------------------------------------------------- ---------------------------------- if (encoderPush) {//encoder push flag ingesteld door interrupt encoderPush =false; // reset gebeurtenisvlag hideCursor (idx); // flitscursor vertraging (250); // voor selectDigit (idx); //visuele bevestiging drawSymbol (0); if (_WorkMode ==SWEEP) { lange ltemp =_Sweep (idy); // waarde opslaan _setSweep (idy, atol (Freq)); // converteer nieuwe waarde van array naar long if (_SweepMax> 0 &&_SweepMax> _SweepMin &&_SweepStep>
 0) { // controleer congruentie van de nieuwe sweep-waarde if (_Sweep(idy)!=ltemp) saveConfig(); // als de waarde is gewijzigd, schrijf dan een nieuwe waarde in EEPROM displayFrequency (_Sweep (idy)); modus =VEEGBEWERKEN; // verander modus } else { _displayErrMsg; //display foutmelding opgeslagen in flash mem delay (1000); _setSweep(idy, ltemp); // herstel opgeslagen waarde displayFrequency (_Sweep (idy)); //waarde opnieuw weergeven drawSymbol (2); // herteken draaipictogram}} else {//indien niet in sweep-modus if (_CouplingMode ==OFF) {//if koppelingsmodus if OFF lLastFreq =atol(Freq); //opslaan huidige frequentie resetCouplingMode(); //set standaard koppelingsmodus} UpdateFrequency (); // stuur frequentie naar DDS-modulemodus =SINGLEDIGIT; //Wijzig modus}} pauze; // eindmodus DIGITCHANGE standaard:pauze; }}//---------------------------------------------- -------------------------------------------------- -----------------------------------// Push-encodergebeurtenis - opgeroepen door interrupt//---- -------------------------------------------------- -------------------------------------------------- ---------------------------void encoderSwitch(void) { encoderPush =true;}//---------- -------------------------------------------------- -------------------------------------------------- ---------------------// Hulpfuncties//----------------------- -------------------------------------------------- -------------------------------------------------- --------// Grafische interface tekenen//----------------------------------- -------------------------------------------------- ---------------------------void drawInterface() { display.clearDisplay(); weergave.weergave(); vertraging (1000); display.drawRoundRect(0, 0, 128, 64, 3, WHITE); //draw external frame display.fillRect(1, 1, 126, 14, WHITE); //draw caption frame displayText(12, 4, strFromFlash(0), BLACK, WHITE, SMALL); //print caption title delay(1000); if (cTime ==1) { //only on power on displayText(XPOS - 6, YPOS + 10, strFromFlash(1), WHITE, BLACK, BIG); //show Welcom message delay(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); weergave.weergave(); 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); weergave.weergave(); 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); weergave.weergave(); 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); weergave.weergave(); 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); pauze; case 1:if (lLastFreq> 0) lFreq =lLastFreq; digitalWrite(PinCoupling, HIGH); _setCouplingMode(DC); pauze; case 2:lLastFreq =lFreq; lFreq =0; digitalWrite(PinCoupling, LOW); _setCouplingMode(OFF); pauze; } 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; pauze; case 1://waveType; displayWaveTypeIcons(); selectIcon(_WaveType, WHITE); mode =OPTWAVE; pauze; case 2://couplingMode; displayCouplingModeIcons(); selectIcon(_CouplingMode, WHITE); mode =OPTCOUP; pauze; }}//----------------------------------------------------------------------------------------------------------------// 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; pauze; } } 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; pauze; } } 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); weergave.weergave(); 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++

// 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++

// 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

Schema's

Display type updated