Generador de ondas JX

Código

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

JX_Wave_Generator_8.7.7.ino C / C ++

 / * Copyright (c) 2020 Janux Por la presente se otorga permiso, sin cargo, a cualquier persona que obtenga una copia de este software y los archivos de documentación asociados (el "Software"), para en el Software sin restricciones, incluidos, entre otros, los derechos para usar, copiar, modificar, fusionar, publicar, distribuir, sublicenciar y / o vender copias del Software, y permitir que las personas a las que se les proporcione el Software lo hagan, sujeto a las siguientes condiciones:El aviso de copyright anterior y este aviso de permiso se incluirán en todas las copias o partes sustanciales del Software. EL SOFTWARE SE PROPORCIONA "TAL CUAL", SIN GARANTÍA DE NINGÚN TIPO, EXPRESA O IMPLÍCITA, INCLUYENDO, PERO NO LIMITADO A, LAS GARANTÍAS DE COMERCIABILIDAD, APTITUD PARA UN PROPÓSITO PARTICULAR Y NO INFRACCIÓN. EN NINGÚN CASO LOS AUTORES O TITULARES DE LOS DERECHOS DE AUTOR SERÁN RESPONSABLES DE CUALQUIER RECLAMO, DAÑOS U OTRA RESPONSABILIDAD, YA SEA EN UNA ACCIÓN DE CONTRATO, AGRAVIO O DE OTRO MODO, QUE SURJA DE, FUERA DE O EN RELACIÓN CON EL SOFTWARE O EL USO U OTRAS NEGOCIACIONES EN EL SOFTWARE. El código para guardar y cargar la configuración es un desarrollo de una idea original del artículo "Cómo cargar y guardar configuraciones en un Arduino" de Ragnar Ranyen Homb en el sitio web de Norwegian Creation. * / # Include "JXWG_Defs.h" #include "JXWG_Graphics .h "void setup () {// si está utilizando un codificador simple y resistencias pullup de 3x10K, aplique esta configuración debajo de pinMode (PinA, INPUT); pinMode (PinB, ENTRADA); pinMode (Pines, ENTRADA); // si está usando un codificador simple sin resistencias de 3x10K use la siguiente fila del árbol // pinMode (PinA, INPUT_PULLUP); // pinMode (PinB, INPUT_PULLUP); // pinMode (PinS, INPUT_PULLUP); // LA MAYORÍA DE LOS CODIFICADORES SOLDADOS A PCB YA TIENEN RESISTENCIAS DE PULLUP EN LOS PIN AYB PERO NO EN EL PIN DEL INTERRUPTOR // luego use las configuraciones siguientes // pinMode (PinA, INPUT); // pinMode (PinB, ENTRADA); // pinMode (PinS, INPUT_PULLUP); escritura digital (PinA, ALTA); escritura digital (PinB, ALTA); escritura digital (pines, ALTA); pinMode (PinCoupling, SALIDA); // Codificador de modo de acoplamiento.setDebounceDelay (5); display.begin (SH1106_SWITCHCAPVCC, 0x3C); // inicializar con I2C addr 0x3C (para 128x64) display.clearDisplay (); //display.setRotation(2); // Quita el comentario de esta línea si quieres montar la pantalla al revés Wire.begin (); // unirse al bus i2c como maestro TWBR =5; // freq =615kHz period =1.625uS // Asigna el evento de empuje del interruptor del codificador para interrumpir 1 Pin 3 de Arduino attachInterrupt (digitalPinToInterrupt (PinS), encoderSwitch, FALLING); DDS_Init (); // Inicializar el módulo DDS; setConfig (); // Cargar la configuración y establecer los valores de inicio} // ---> finalizar setup () void loop () {JX_WaveGenerator_MAIN ();} // ------------------- -------------------------------------------------- -------------------------------------------------- ------------------ // Función principal JX WaveGenerator // ------------------------ -------------------------------------------------- -------------------------------------------------- ------------- void JX_WaveGenerator_MAIN () {byte encoderSpin =Encoder.rotate (); // Sentido de rotación del codificador 1 =CW, 2 =byte CCW encoderLongPush =Encoder.pushLong (1000); // evento de empuje largo del codificador largo lStep =0; // valor del paso de frecuencia actual long wTime =600000; // 10 min if (encoderPush) delay (250); if (encoderSpin) {cTime =millis (); } else {if (millis () - cTime> wTime) {ScreenSaver (); }} switch (modo) {case LOGARITHMIC:// 0 // ----------------------------------- -------------------------------------------------- ---------------------------------------------- // modo LOGARITHMIC :Frecuencia de cambio de rotación del codificador en paso logarítmico 1,10,100,1000,10000,100000 Hz // ------------------------------ -------------------------------------------------- -------------------------------------------------- - if (encoderSpin) {if (lFreq> =1) {lStep =AutoStep (lFreq, encoderSpin); // Calcular el paso logarítmico} else if (_CouplingMode ==OFF) {// si el modo de acoplamiento se establece en OFF resetCouplingMode (); // establece el modo de acoplamiento predeterminado cuando la frecuencia no es 0 encoderSpin =0; // salta el primer giro} if (encoderSpin ==CW &&lFreq <=999999 - lStep) {// giro CW incrementa la frecuencia lFreq + =lStep; } if (encoderSpin ==CCW &&lFreq> =lStep + 1) {// girar CCW disminuye la frecuencia lFreq - =lStep; } DDS_FrequencySet (lFreq, Wave [_WaveType]); // envía el valor de frecuencia al módulo DDS displayFrequency (lFreq); // envía frecuencia formateada para mostrar lLastFreq =lFreq; // guardar la frecuencia actual} // ------------------------------------------ -------------------------------------------------- --------------------------------------- // modo de trabajo LOGARITMICO:Encoder empuja el interruptor al modo OPCIONES // ------------------------------------------------ -------------------------------------------------- --------------------------------- if (encoderPush) {encoderPush =false; // Limpiar la bandera de empujar drawSymbol (1); // dibuja el símbolo de flecha selectIcon (0, BLANCO); // dibuja un borde alrededor del primer icono idx =0; idy =0; // restablecer punteros var mode =OPTIONS; // ir al modo OPCIONES} break; // fin del modo LOGARITHMIC caso SINGLEDIGIT:// 1 // ------------------------------------- -------------------------------------------------- ---------------------- // submodo SINGLEDIGIT:La rotación del codificador mueve el cursor hacia la izquierda y hacia la derecha // -------------- -------------------------------------------------- --------------------------------------------- if (encoderSpin) { if (encoderSpin ==CW &&idx  0) idx--; // puntero de disminución en sentido antihorario // ------------------------------------------- -------------------------------------------------- --------------- // cuando idx es de 0 a 5 seleccionar dígitos de frecuencia // --------------------- -------------------------------------------------- ------------------------------------- if (idx> =0 &&idx  =MAXDIGIT &&idx <=MAXDIGIT + 2) {// si la posición actual está más allá de los dígitos hideCursor (MAXDIGIT - 1); // oculta el cursor en el último dígito drawSymbol (1); // dibuja la flecha dn selectIcon (idx - MAXDIGIT, WHITE); // seleccionar icono}} // ------------------------------------------ -------------------------------------------------- --------------------------------------- // submodo SINGLEDIGIT:evento de inserción del codificador // - -------------------------------------------------- -------------------------------------------------- ------------------------------ if (encoderPush) {encoderPush =false; // ------------------------------------------------ -------------------------------------------------- ----------- // si se selecciona un dígito del 0 al 5 pasar al modo DIGITCHANGE // ---------------------- -------------------------------------------------- ------------------------------------- if (idx <=MAXDIGIT - 1) {hideCursor (idx ); // retardo del cursor parpadeante (250); // para selectDigit (idx); // confirmación visual drawSymbol (2); // dibujar icono de turno mode =DIGITCHANGE; //modo de cambio } //------------------------------------------- -------------------------------------------------- ---------------- // de lo contrario, hay un icono seleccionado, luego vaya a OPCIONES // -------------------- -------------------------------------------------- --------------------------------------- else {if (idx> =MAXDIGIT &&idx <=MAXDIGIT + 2) {idy =idx - MAXDIGIT; selectOption (idy); idy =opciones [idy]; } } } descanso; // fin del modo SINGLEDIGIT case SWEEP:// 2 // ------------------------------------- -------------------------------------------------- ------------------------- // modo de trabajo BARRIDO:la rotación del codificador mueve el cursor hacia la izquierda y hacia la derecha para seleccionar la opción // -------- -------------------------------------------------- -------------------------------------------------- ---- if (encoderSpin) {if (encoderSpin ==CW &&idy <2) idy ++; if (encoderSpin ==CCW &&idy> 0) idy--; selectIcon (idy, BLANCO); } if (encoderPush) {// ------------------------------------------ -------------------------------------------------- --------------------------------------- // modo de trabajo BARRIDO:Encoder presione ir a OPCIONES, OPCIONES DE BARRIDO o BARRIDO INICIAR / DETENER // ----------------------------------------- -------------------------------------------------- ---------------------------------------- encoderPush =falso; switch (idy) {caso 0:lFreq =atol (Freq); selectOption (idy); idy =opciones [idy]; retraso (100); if (_WorkMode! =2) displayFrequency (lLastFreq); SweepReset (); descanso; caso 1:lFreq =atol (Freq); drawSymbol (9); drawSymbol (1); displaySweepIcons (); selectIcon (0, BLANCO); idy =0; displayFrequency (_Sweep (idy)); retraso (100); SweepReset (); modo =OPTSWEEP; descanso; caso 2:// ** sweepStatus:STILL 0 (nunca iniciado), 1 BREAK, 2 PAUSE ** if (sweepStatus ==STILL || sweepStatus ==PAUSE) {drawSymbol (3); // dibujar icono de pausa selectIcon (2, BLANCO); // seleccione el icono FrequencySweep (); // ejecutar barrido} else {// si está en pausa drawSymbol (4); // dibujar icono de reproducción sweepStatus =PAUSE; } descanso; }} if (sweepStatus ==PAUSE) flashIcon (250); // Parpadeo de pausa de texto; // finaliza el modo SWEEP case OPTIONS:// 3 if (encoderLongPush) reset (); // ------------------------------------------------ -------------------------------------------------- --------------------------------- // OPCIONES de modo:Opción de selección de giro del codificador para cambiar (modo de trabajo, tipo de onda, modo de acoplamiento ) // ----------------------------------------------- -------------------------------------------------- ---------------------------------- if (encoderSpin) {if (encoderSpin ==CW &&idy <2) idy ++; if (encoderSpin ==CCW &&idy> 0) idy--; selectIcon (idy, BLANCO); } // ----------------------------------------------- -------------------------------------------------- ---------------------------------- // OPCIONES de modo:Encoder presione el interruptor a modo relativo // --- -------------------------------------------------- -------------------------------------------------- ---------------------------- if (encoderPush) {encoderPush =false; // selectIcon (idy, BLACK); selectOption (idy); hideCursor (0); idy =opciones [idy]; } descanso; // fin de modo OPCIONES caso OPTMODE:// 4 // ------------------------------------- -------------------------------------------------- -------------------------------------------- // modo OPTMODE:Codificador iconos de modo de selección de giro (logarítmico, dígito único, barrido) // ------------------------------------- -------------------------------------------------- -------------------------------------------- if (encoderSpin) {si (encoderSpin ==CW &&idy <2) idy ++; if (encoderSpin ==CCW &&idy> 0) idy--; selectIcon (idy, BLANCO); } // ----------------------------------------------- -------------------------------------------------- ---------------------------------- // modo OPTMODE:Encoder presione seleccionar modo de trabajo para configurar (almacenado en la opción [ 0]) // --------------------------------------------- -------------------------------------------------- ------------------------------------ if (encoderPush) {encoderPush =false; byte pMode =_WorkMode; switch (idy) {caso 0:hideCursor (0); drawSymbol (0); lFreq =lLastFreq; displayFrequency (lFreq); _setWorkMode (LOGARITHMIC); descanso; caso 1:drawSymbol (0); selectDigit (0); lFreq =lLastFreq; displayFrequency (lFreq); _setWorkMode (SINGLEDIGIT); descanso; caso 2:lLastFreq =lFreq; displayFrequency (_SweepMin); // listo para iniciar _setWorkMode (SWEEP); descanso; } modo =_WorkMode; if (pMode! =_WorkMode) saveConfig (); if (_CouplingMode ==OFF) resetCouplingMode (); idx =0; drawAllIcons (); } descanso; // fin del modo OPTMODE caso OPTWAVE:// 5 // ------------------------------------- -------------------------------------------------- ------------------------- // modo OPTWAVE:la rotación del codificador mueve el cursor hacia la izquierda y hacia la derecha para la selección de onda (sqr, sin, tri) // - -------------------------------------------------- -------------------------------------------------- ----------- if (encoderSpin) {if (encoderSpin ==CW &&idy <2) idy ++; if (encoderSpin ==CCW &&idy> 0) idy--; selectIcon (idy, BLANCO); } // ----------------------------------------------- -------------------------------------------------- ------------------- // modo OPTWAVE:Encoder push set new wave type // ------------------ -------------------------------------------------- ------------------------------------------------ Si ( encoderPush) {encoderPush =falso; if (_WaveType! =idy) {_setWaveType (idy); saveConfig (); } Frecuencia de actualización(); // actualiza el tipo de onda drawAllIcons (); idx =0; mode =_WorkMode; } descanso; // fin del modo OPTWAVE caso OPTCOUP:// 6 // ------------------------------------- -------------------------------------------------- ------------------------- // modo OPTCOUP:La rotación del codificador mueve el cursor hacia la izquierda y hacia la derecha para seleccionar el modo de acoplamiento // ------- -------------------------------------------------- -------------------------------------------------- ----- if (encoderSpin) {if (encoderSpin ==CW &&idy <2) idy ++; if (encoderSpin ==CCW &&idy> 0) idy--; selectIcon (idy, BLANCO); } // ----------------------------------------------- -------------------------------------------------- ------------------- // modo OPTCOUP:Encoder push seleccionar modo de acoplamiento actual // ------------------ -------------------------------------------------- ------------------------------------------------ Si ( encoderPush) {encoderPush =falso; setCouplingMode (idy); drawAllIcons (); idx =0; mode =_WorkMode; } descanso; // fin del modo OPTCOUP caso OPTSWEEP:// 7 // ------------------------------------- -------------------------------------------------- ----------------------------- // modo OPTSWEEP:encoder girar seleccionar valores de barrido para editar // ------- -------------------------------------------------- -------------------------------------------------- --------- if (encoderSpin) {if (encoderSpin ==CW &&idy <2) idy ++; // aumentar el puntero en el sentido de las agujas del reloj if (encoderSpin ==CCW &&idy> 0) idy--; // puntero de disminución en sentido antihorario selectIcon (idy, WHITE); // seleccionar el primer icono displayFrequency (_Sweep (idy)); // muestra el valor de barrido actual} if (encoderPush) {encoderPush =false; // ------------------------------------------------ -------------------------------------------------- ------------------ // modo OPTSWEEP:codificador presionar confirmar valores de barrido para editar // ------------------ -------------------------------------------------- ------------------------------------------------ drawSymbol ( 0); selectDigit (0); selectIcon (idy, BLANCO); idx =0; displayFrequency (_Sweep (idy)); mode =SWEEPEDIT; } descanso; // fin del modo OPTSWEEP case SWEEPEDIT:// 8 // ------------------------------------- -------------------------------------------------- ----------------------- // modo SWEEPEDIT:codificador girar el dígito de selección para cambiar // -------------- -------------------------------------------------- ---------------------------------------------- si (encoderSpin) {if (encoderSpin ==CW &&idx  0) idx--; // puntero de disminución en sentido antihorario selectDigit (idx); } // ----------------------------------------------- -------------------------------------------------- ------------- // modo SWEEPEDIT:codificador longpush salir de editar y volver a SWEEP // --------------------- -------------------------------------------------- --------------------------------------- if (encoderLongPush ==LONGPUSH) {encoderPush =false; drawAllIcons (); displayFrequency (_SweepMin); hideCursor (idx); _setWorkMode (BARRIDO); SweepReset (); mode =_WorkMode; retraso (250); } if (encoderPush) {encoderPush =false; // ------------------------------------------------ -------------------------------------------------- ----------- // modo SWEEPEDIT:Pulsación del codificador para ir al modo DIGITCHANGE // -------------------------- -------------------------------------------------- --------------------------------- hideCursor (idx); // retardo del cursor parpadeante (250); // para selectDigit (idx); // confirmación visual drawSymbol (2); // dibujar icono de turno mode =DIGITCHANGE; // cambiar modo} break; // finalizar modo SWEEPEDIT case DIGITCHANGE:// 9 // ------------------------------ -------------------------------------------------- ------------------------- // modo DIGITCHANGE:Encoder longpush sale de DIGITCHANGE cuando está en modo SWEEP // --------- -------------------------------------------------- ---------------------------------------------- si (encoderLongPush ==LONGPUSH &&_WorkMode ==SWEEP) {encoderPush =false; hideCursor (idx); drawSymbol (1); modo =OPTSWEEP; retraso (250); } // ----------------------------------------------- -------------------------------------------------- -------- // modo DIGITCHANGE:valor de dígito de cambio de rotación del codificador (0 -> 9 -> 0 y así sucesivamente) // ------------------ -------------------------------------------------- ------------------------------------- if (encoderSpin) {// rotación del codificador if (encoderSpin ==CW) {// sentido horario Freq [idx] ++; if (Freq [idx]> '9') Freq [idx] ='0'; } else {// sentido antihorario Freq [idx] -; if (Freq [idx] <'0') Freq [idx] ='9'; } updateDigit (idx, Freq [idx]); // actualizar el dígito en la pantalla} // ----------------------------------------- -------------------------------------------------- -------------- // modo DIGITCHANGE:codificador pulsa para volver al modo SINGLEDIGIT o SWEEPEDIT // --------------------- -------------------------------------------------- ---------------------------------- if (encoderPush) {// indicador de inserción del codificador establecido por interrupción encoderPush =false; // restablecer el indicador de evento hideCursor (idx); // retardo del cursor parpadeante (250); // para selectDigit (idx); // confirmación visual drawSymbol (0); if (_WorkMode ==SWEEP) {long ltemp =_Sweep (idy); // guardar valor _setSweep (idy, atol (Freq)); // convierte el nuevo valor de la matriz a largo if (_SweepMax> 0 &&_SweepMax> _SweepMin &&_SweepStep>
 0) {// verifica la congruencia del nuevo valor de barrido if (_Sweep (idy)! =ltemp) saveConfig (); // si el valor ha cambiado, escriba un nuevo valor en EEPROM displayFrequency (_Sweep (idy)); mode =SWEEPEDIT; // cambia de modo} else {_displayErrMsg; // muestra el mensaje de error almacenado en la memoria flash delay (1000); _setSweep (idy, ltemp); // restaura el valor guardado displayFrequency (_Sweep (idy)); // volver a mostrar el valor drawSymbol (2); // volver a dibujar el icono de giro}} else {// si no está en modo de barrido if (_CouplingMode ==OFF) {// si está en modo de acoplamiento si está APAGADO lLastFreq =atol (Freq); // guardar la frecuencia actual resetCouplingMode (); // establece el modo de acoplamiento predeterminado} UpdateFrequency (); // enviar frecuencia al modo Módulo DDS =SINGLEDIGIT; // cambia el modo}} break; // fin del modo DIGITCHANGE default:break; }} // ---------------------------------------------- -------------------------------------------------- ----------------------------------- // Evento de codificador push - Llamado por interrupción // ---- -------------------------------------------------- -------------------------------------------------- --------------------------- void encoderSwitch (void) {encoderPush =true;} // ---------- -------------------------------------------------- -------------------------------------------------- ---------------------// Funciones de utilidad//----------------------- -------------------------------------------------- -------------------------------------------------- -------- // Dibujar interfaz gráfica // ----------------------------------- -------------------------------------------------- --------------------------- vacío drawInterface () {display.clearDisplay (); display.display (); retraso (1000); display.drawRoundRect (0, 0, 128, 64, 3, BLANCO); // dibuja el marco externo 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); 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); descanso; case 1:if (lLastFreq> 0) lFreq =lLastFreq; digitalWrite(PinCoupling, HIGH); _setCouplingMode(DC); descanso; case 2:lLastFreq =lFreq; lFreq =0; digitalWrite(PinCoupling, LOW); _setCouplingMode(OFF); descanso; } 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; descanso; case 1://waveType; displayWaveTypeIcons(); selectIcon(_WaveType, WHITE); mode =OPTWAVE; descanso; case 2://couplingMode; displayCouplingModeIcons(); selectIcon(_CouplingMode, WHITE); mode =OPTCOUP; descanso; }}//----------------------------------------------------------------------------------------------------------------// 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; descanso; } } 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; descanso; } } 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++

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

Esquemas

Display type updated