ubitx-v5d/ubitx_20/ubitx_menu.ino

1449 lines
33 KiB
Arduino
Raw Normal View History

/** Menus
* The Radio menus are accessed by tapping on the function button.
* - The main loop() constantly looks for a button press and calls doMenu() when it detects
* a function button press.
* - As the encoder is rotated, at every 10th pulse, the next or the previous menu
* item is displayed. Each menu item is controlled by it's own function.
* - Eache menu function may be called to display itself
* - Each of these menu routines is called with a button parameter.
* - The btn flag denotes if the menu itme was clicked on or not.
* - If the menu item is clicked on, then it is selected,
* - If the menu item is NOT clicked on, then the menu's prompt is to be displayed
*/
2018-03-09 08:02:10 -05:00
#include "ubitx.h"
2018-02-05 01:07:25 -05:00
//Current Frequency and mode to active VFO by KD8CEC
2018-02-03 02:35:27 -05:00
void FrequencyToVFO(byte isSaveFreq)
{
//Save Frequency & Mode Information
if (vfoActive == VFO_A)
{
vfoA = frequency;
vfoA_mode = modeToByte();
if (isSaveFreq)
storeFrequencyAndMode(1);
}
else
{
vfoB = frequency;
vfoB_mode = modeToByte();
if (isSaveFreq)
storeFrequencyAndMode(2);
}
}
2018-02-05 01:07:25 -05:00
//Commonly called functions when exiting menus by KD8CEC
2018-02-03 02:35:27 -05:00
void menuClearExit(int delayTime)
{
if (delayTime > 0)
delay_background(delayTime, 0);
printLine2ClearAndUpdate();
menuOn = 0;
}
2018-02-05 01:07:25 -05:00
//Ham band or general band movement by KD8CEC
2018-01-20 08:05:04 -05:00
void menuBand(int btn){
int knob = 0;
2018-01-11 19:54:38 -05:00
int stepChangeCount = 0;
2018-01-13 02:19:23 -05:00
byte btnPressCount = 0;
if (!btn){
2018-01-09 21:34:15 -05:00
printLineF2(F("Band Select?"));
return;
}
2018-03-04 22:51:14 -05:00
//printLineF2(F("Press to confirm"));
//wait for the button menu select button to be lifted)
2018-01-09 21:34:15 -05:00
while (btnDown()) {
2018-02-03 02:35:27 -05:00
delay_background(50, 0);
2018-01-13 02:19:23 -05:00
if (btnPressCount++ > 20) {
btnPressCount = 0;
if (tuneTXType > 0) { //Just toggle 0 <-> 2, if tuneTXType is 100, 100 -> 0 -> 2
tuneTXType = 0;
2018-03-09 08:02:10 -05:00
//printLineF2(F("General mode"));
printLineF2(F("General"));
2018-01-13 02:19:23 -05:00
}
else {
tuneTXType = 2;
2018-03-09 08:02:10 -05:00
//printLineF2(F("Ham band mode"));
printLineF2(F("Ham band"));
2018-01-13 02:19:23 -05:00
}
delay_background(1000, 0);
printLine2ClearAndUpdate();
}
2018-01-09 21:34:15 -05:00
}
2018-03-04 22:51:14 -05:00
printLineF2(F("Press to confirm"));
2018-01-09 21:34:15 -05:00
2018-01-13 05:42:39 -05:00
char currentBandIndex = -1;
2018-01-11 19:54:38 -05:00
//Save Band Information
if (tuneTXType == 2 || tuneTXType == 3 || tuneTXType == 102 || tuneTXType == 103) { //only ham band move
//Get Now Band Index
currentBandIndex = getIndexHambanBbyFreq(frequency);
if (currentBandIndex >= 0) {
//Save Frequency to Band Frequncy Record
saveBandFreqByIndex(frequency, modeToByte(), currentBandIndex);
}
}
2018-02-03 02:35:27 -05:00
//delay(50);
ritDisable();
while(!btnDown()){
knob = enc_read();
if (knob != 0){
2018-01-11 19:54:38 -05:00
if (tuneTXType == 2 || tuneTXType == 3 || tuneTXType == 102 || tuneTXType == 103) { //only ham band move
if (knob < 0) {
if (stepChangeCount-- < -3) {
setNextHamBandFreq(frequency, -1); //Prior Band
stepChangeCount = 0;
}
}
else if (knob > 0) {
if (stepChangeCount++ > 3) {
setNextHamBandFreq(frequency, 1); //Next Band
stepChangeCount = 0;
}
}
2018-02-03 02:35:27 -05:00
} //end of only ham band move
2018-01-11 19:54:38 -05:00
else { //original source
if (knob < 0 && frequency > 3000000l)
setFrequency(frequency - 200000l);
if (knob > 0 && frequency < 30000000l)
setFrequency(frequency + 200000l);
if (frequency > 10000000l)
isUSB = true;
else
isUSB = false;
}
updateDisplay();
}
2018-01-11 19:54:38 -05:00
2018-02-03 02:35:27 -05:00
delay_background(20, 0);
}
2018-02-03 02:35:27 -05:00
FrequencyToVFO(1);
menuClearExit(500);
}
2018-01-26 07:47:15 -05:00
//Convert Mode, Number by KD8CEC
2018-01-29 23:20:52 -05:00
//0: default, 1:not use, 2:LSB, 3:USB, 4:CWL, 5:CWU, 6:FM
2018-01-09 21:34:15 -05:00
byte modeToByte(){
2018-01-29 23:20:52 -05:00
if (cwMode == 0)
{
if (isUSB)
return 3;
else
return 2;
}
else if (cwMode == 1)
{
return 4;
}
2018-01-09 21:34:15 -05:00
else
2018-01-29 23:20:52 -05:00
{
return 5;
}
2018-01-09 21:34:15 -05:00
}
2018-01-26 07:47:15 -05:00
//Convert Number to Mode by KD8CEC
2018-02-03 02:35:27 -05:00
//autoSetModebyFreq : 0
//autoSetModebyFreq : 1, if (modValue is not set, set mode by frequency)
void byteToMode(byte modeValue, byte autoSetModebyFreq){
2018-01-29 23:20:52 -05:00
if (modeValue == 4)
cwMode = 1;
else if (modeValue == 5)
cwMode = 2;
2018-01-09 21:34:15 -05:00
else
2018-01-29 23:20:52 -05:00
{
cwMode = 0;
if (modeValue == 3)
isUSB = 1;
2018-02-03 02:35:27 -05:00
else if (autoSetModebyFreq == 1 && (modeValue == 0))
isUSB = (frequency > 10000000l) ? true : false;
2018-01-29 23:20:52 -05:00
else
isUSB = 0;
}
2018-01-09 21:34:15 -05:00
}
2018-01-26 07:47:15 -05:00
2018-02-05 01:07:25 -05:00
//IF Shift function, BFO Change like RIT, by KD8CEC
2018-02-03 02:35:27 -05:00
void menuIFSSetup(int btn){
2018-01-30 04:43:08 -05:00
int knob = 0;
char needApplyChangeValue = 1;
if (!btn){
if (isIFShift == 1)
printLineF2(F("IF Shift Change?"));
else
2018-03-09 08:02:10 -05:00
printLineF2(F("IF Shift On?"));
2018-01-30 04:43:08 -05:00
}
else {
2018-02-03 02:35:27 -05:00
isIFShift = 1;
2018-01-30 04:43:08 -05:00
delay_background(500, 0);
updateLine2Buffer(1);
setFrequency(frequency);
//Off or Change Value
2018-02-03 02:35:27 -05:00
while(!btnDown() ){
2018-01-30 04:43:08 -05:00
if (needApplyChangeValue ==1)
{
updateLine2Buffer(1);
setFrequency(frequency);
if (cwMode == 0)
si5351bx_setfreq(0, usbCarrier + (isIFShift ? ifShiftValue : 0)); //set back the carrier oscillator anyway, cw tx switches it off
else
si5351bx_setfreq(0, cwmCarrier + (isIFShift ? ifShiftValue : 0)); //set back the carrier oscillator anyway, cw tx switches it off
needApplyChangeValue = 0;
}
knob = enc_read();
if (knob != 0){
if (knob < 0)
2018-01-31 03:53:20 -05:00
ifShiftValue -= 50l;
2018-01-30 04:43:08 -05:00
else if (knob > 0)
2018-01-31 03:53:20 -05:00
ifShiftValue += 50;
2018-01-30 04:43:08 -05:00
needApplyChangeValue = 1;
}
}
delay_background(500, 0); //for check Long Press function key
2018-02-03 02:35:27 -05:00
if (btnDown() || ifShiftValue == 0)
2018-01-30 04:43:08 -05:00
{
isIFShift = 0;
2018-03-09 08:02:10 -05:00
//printLineF2(F("IF Shift is OFF"));
//printLineF2(F("OFF"));
//clearLine2();
2018-01-30 04:43:08 -05:00
setFrequency(frequency);
2018-03-09 08:02:10 -05:00
//delay_background(1500, 0);
2018-01-30 04:43:08 -05:00
}
2018-02-03 02:35:27 -05:00
//menuOn = 0;
//printLine2ClearAndUpdate();
menuClearExit(0);
2018-01-30 04:43:08 -05:00
}
}
2018-02-05 01:07:25 -05:00
//Functions for CWL and CWU by KD8CEC
2018-01-29 23:20:52 -05:00
void menuSelectMode(int btn){
int knob = 0;
int selectModeType = 0;
int beforeMode = 0;
int moveStep = 0;
if (!btn){
printLineF2(F("Select Mode?"));
}
else {
delay_background(500, 0);
//LSB, USB, CWL, CWU
if (cwMode == 0 && isUSB == 0)
selectModeType = 0;
else if (cwMode == 0 && isUSB == 1)
selectModeType = 1;
else if (cwMode == 1)
selectModeType = 2;
else
selectModeType = 3;
beforeMode = selectModeType;
2018-02-07 22:45:54 -05:00
while(!btnDown()){
2018-01-29 23:20:52 -05:00
//Display Mode Name
2018-02-07 22:45:54 -05:00
memset(c, 0, sizeof(c));
strcpy(c, " LSB USB CWL CWU");
c[selectModeType * 4] = '>';
printLine1(c);
2018-01-29 23:20:52 -05:00
knob = enc_read();
if (knob != 0)
{
moveStep += (knob > 0 ? 1 : -1);
if (moveStep < -3) {
if (selectModeType > 0)
selectModeType--;
moveStep = 0;
}
else if (moveStep > 3) {
if (selectModeType < 3)
selectModeType++;
moveStep = 0;
}
}
2018-02-07 22:45:54 -05:00
//Check_Cat(0); //To prevent disconnections
delay_background(50, 0);
2018-01-29 23:20:52 -05:00
}
if (beforeMode != selectModeType) {
2018-02-03 02:35:27 -05:00
//printLineF1(F("Changed Mode"));
2018-01-29 23:20:52 -05:00
if (selectModeType == 0) {
cwMode = 0; isUSB = 0;
}
else if (selectModeType == 1) {
cwMode = 0; isUSB = 1;
}
else if (selectModeType == 2) {
cwMode = 1;
}
else if (selectModeType == 3) {
cwMode = 2;
}
2018-02-03 02:35:27 -05:00
FrequencyToVFO(1);
2018-01-29 23:20:52 -05:00
}
if (cwMode == 0)
2018-01-30 04:43:08 -05:00
si5351bx_setfreq(0, usbCarrier + (isIFShift ? ifShiftValue : 0)); //set back the carrier oscillator anyway, cw tx switches it off
2018-01-29 23:20:52 -05:00
else
2018-01-30 04:43:08 -05:00
si5351bx_setfreq(0, cwmCarrier + (isIFShift ? ifShiftValue : 0)); //set back the carrier oscillator anyway, cw tx switches it off
2018-01-29 23:20:52 -05:00
setFrequency(frequency);
2018-02-03 02:35:27 -05:00
menuClearExit(500);
2018-01-25 09:15:24 -05:00
}
}
2018-01-29 04:38:48 -05:00
2018-02-05 01:07:25 -05:00
//Memory to VFO, VFO to Memory by KD8CEC
void menuCHMemory(int btn, byte isMemoryToVfo){
int knob = 0;
int selectChannel = 0;
byte isDisplayInfo = 1;
int moveStep = 0;
unsigned long resultFreq, tmpFreq = 0;
byte loadMode = 0;
if (!btn){
if (isMemoryToVfo == 1)
2018-02-07 22:45:54 -05:00
printLineF2(F("Channel To VFO?"));
2018-02-05 01:07:25 -05:00
else
2018-02-07 22:45:54 -05:00
printLineF2(F("VFO To Channel?"));
2018-02-05 01:07:25 -05:00
}
else {
delay_background(500, 0);
while(!btnDown()){
if (isDisplayInfo == 1) {
//Display Channel info *********************************
memset(c, 0, sizeof(c));
if (selectChannel >= 20 || selectChannel <=-1)
{
2018-03-09 08:02:10 -05:00
//strcpy(c, "Exit setup?");
strcpy(c, "Exit?");
2018-02-05 01:07:25 -05:00
}
else
{
//Read Frequency from eeprom
EEPROM.get(CHANNEL_FREQ + 4 * selectChannel, resultFreq);
loadMode = (byte)(resultFreq >> 29);
resultFreq = resultFreq & 0x1FFFFFFF;
//display channel description
2018-02-05 02:46:37 -05:00
if (selectChannel < 10 && EEPROM.read(CHANNEL_DESC + 6 * selectChannel) == 0x03) { //0x03 is display Chnnel Name
2018-02-05 01:07:25 -05:00
//display Channel Name
for (int i = 0; i < 5; i++)
c[i] = EEPROM.read(CHANNEL_DESC + 6 * selectChannel + i + 1);
2018-02-05 02:46:37 -05:00
c[5] = ':';
2018-02-05 01:07:25 -05:00
}
else {
//Display frequency
//1 LINE : Channel Information : CH00
strcpy(c, "CH");
if (selectChannel < 9)
c[2] = '0';
ltoa(selectChannel + 1, b, 10);
strcat(c, b); //append channel Number;
strcat(c, " :"); //append channel Number;
}
//display frequency
tmpFreq = resultFreq;
for (int i = 15; i >= 6; i--) {
if (tmpFreq > 0) {
if (i == 12 || i == 8) c[i] = '.';
else {
c[i] = tmpFreq % 10 + 0x30;
tmpFreq /= 10;
}
}
else
c[i] = ' ';
}
}
printLine2(c);
isDisplayInfo = 0;
}
knob = enc_read();
if (knob != 0)
{
moveStep += (knob > 0 ? 1 : -1);
if (moveStep < -3) {
if (selectChannel > -1)
selectChannel--;
isDisplayInfo = 1;
moveStep = 0;
}
else if (moveStep > 3) {
if (selectChannel < 20)
selectChannel++;
isDisplayInfo = 1;
moveStep = 0;
}
}
Check_Cat(0); //To prevent disconnections
} //end of while (knob)
if (selectChannel < 20 && selectChannel >= 0)
{
if (isMemoryToVfo == 1)
{
if (resultFreq > 3000 && resultFreq < 60000000)
setFrequency(resultFreq);
byteToMode(loadMode, 1);
}
else
{
//Save current Frequency to Channel (selectChannel)
2018-02-06 02:13:05 -05:00
EEPROM.put(CHANNEL_FREQ + 4 * selectChannel, (frequency & 0x1FFFFFFF) | (((unsigned long)modeToByte()) << 29) );
2018-02-05 01:07:25 -05:00
printLine2("Saved Frequency");
}
}
menuClearExit(500);
}
}
2018-01-29 04:38:48 -05:00
//Select CW Key Type by KD8CEC
void menuSetupKeyType(int btn){
int knob = 0;
int selectedKeyType = 0;
int moveStep = 0;
if (!btn){
2018-01-29 04:38:48 -05:00
printLineF2(F("Change Key Type?"));
}
else {
2018-02-07 22:45:54 -05:00
//printLineF2(F("Press to set Key")); //for reduce usable flash memory
2018-01-29 04:38:48 -05:00
delay_background(500, 0);
selectedKeyType = cwKeyType;
2018-01-30 20:44:23 -05:00
while(!btnDown()){
2018-01-29 04:38:48 -05:00
//Display Key Type
if (selectedKeyType == 0)
printLineF1(F("Straight"));
else if (selectedKeyType == 1)
printLineF1(F("IAMBICA"));
else if (selectedKeyType == 2)
printLineF1(F("IAMBICB"));
knob = enc_read();
if (knob != 0)
{
moveStep += (knob > 0 ? 1 : -1);
2018-01-29 23:20:52 -05:00
if (moveStep < -3) {
if (selectedKeyType > 0)
selectedKeyType--;
2018-01-29 04:38:48 -05:00
moveStep = 0;
}
2018-01-29 23:20:52 -05:00
else if (moveStep > 3) {
if (selectedKeyType < 2)
selectedKeyType++;
2018-01-29 04:38:48 -05:00
moveStep = 0;
}
}
Check_Cat(0); //To prevent disconnections
}
printLineF2(F("CW Key Type set!"));
cwKeyType = selectedKeyType;
EEPROM.put(CW_KEY_TYPE, cwKeyType);
2018-01-29 04:38:48 -05:00
if (cwKeyType == 0)
Iambic_Key = false;
else
{
Iambic_Key = true;
2018-01-30 20:44:23 -05:00
if (cwKeyType == 1)
keyerControl &= ~IAMBICB;
2018-01-29 04:38:48 -05:00
else
keyerControl |= IAMBICB;
2018-01-29 04:38:48 -05:00
}
2018-02-07 22:45:54 -05:00
2018-02-03 02:35:27 -05:00
menuClearExit(1000);
2018-01-29 04:38:48 -05:00
}
}
2018-01-25 09:15:24 -05:00
2018-01-26 07:47:15 -05:00
//Analog pin monitoring with CW Key and function keys connected.
//by KD8CEC
void menuADCMonitor(int btn){
int adcPinA0 = 0; //A0(BLACK, EncoderA)
int adcPinA1 = 0; //A1(BROWN, EncoderB)
int adcPinA2 = 0; //A2(RED, Function Key)
int adcPinA3 = 0; //A3(ORANGE, CW Key)
int adcPinA6 = 0; //A6(BLUE, Ptt)
int adcPinA7 = 0; //A7(VIOLET, Spare)
unsigned long pressKeyTime = 0;
if (!btn){
printLineF2(F("ADC Line Monitor"));
return;
}
printLineF2(F("Exit:Long PTT"));
delay_background(2000, 0);
printLineF1(F("A0 A1 A2"));
printLineF2(F("A3 A6 A7"));
delay_background(3000, 0);
while (true) {
adcPinA0 = analogRead(A0); //A0(BLACK, EncoderA)
adcPinA1 = analogRead(A1); //A1(BROWN, EncoderB)
adcPinA2 = analogRead(A2); //A2(RED, Function Key)
2018-02-07 22:45:54 -05:00
adcPinA3 = analogRead(A3); //A3(PTT)
adcPinA6 = analogRead(A6); //A6(KEYER)
2018-01-26 07:47:15 -05:00
adcPinA7 = analogRead(A7); //A7(VIOLET, Spare)
2018-02-07 22:45:54 -05:00
if (adcPinA3 < 50) {
2018-01-26 07:47:15 -05:00
if (pressKeyTime == 0)
pressKeyTime = millis();
else if (pressKeyTime < (millis() - 3000))
break;
}
else
pressKeyTime = 0;
ltoa(adcPinA0, c, 10);
//strcat(b, c);
strcpy(b, c);
strcat(b, ", ");
ltoa(adcPinA1, c, 10);
strcat(b, c);
strcat(b, ", ");
ltoa(adcPinA2, c, 10);
strcat(b, c);
printLine1(b);
//strcpy(b, " ");
ltoa(adcPinA3, c, 10);
strcpy(b, c);
strcat(b, ", ");
ltoa(adcPinA6, c, 10);
strcat(b, c);
strcat(b, ", ");
ltoa(adcPinA7, c, 10);
strcat(b, c);
printLine2(b);
delay_background(200, 0);
} //end of while
2018-02-03 02:35:27 -05:00
menuClearExit(0);
}
//VFO Toggle and save VFO Information, modified by KD8CEC
2018-02-06 02:13:05 -05:00
void menuVfoToggle(int btn)
2018-02-03 02:35:27 -05:00
{
if (!btn){
if (vfoActive == VFO_A)
printLineF2(F("Select VFO B?"));
else
printLineF2(F("Select VFO A?"));
}
else {
FrequencyToVFO(1);
if (vfoActive == VFO_B){
vfoActive = VFO_A;
frequency = vfoA;
saveCheckFreq = frequency;
byteToMode(vfoA_mode, 0);
}
else {
vfoActive = VFO_B;
frequency = vfoB;
saveCheckFreq = frequency;
byteToMode(vfoB_mode, 0);
}
ritDisable();
setFrequency(frequency);
menuClearExit(0);
}
}
2018-02-07 22:45:54 -05:00
//modified for reduce used flash memory by KD8CEC
2018-02-03 02:35:27 -05:00
void menuRitToggle(int btn){
if (!btn){
if (ritOn == 1)
2018-03-09 08:02:10 -05:00
printLineF2(F("RIT Off?"));
2018-02-03 02:35:27 -05:00
else
2018-03-09 08:02:10 -05:00
printLineF2(F("RIT On?"));
2018-02-03 02:35:27 -05:00
}
else {
if (ritOn == 0){
2018-03-04 22:51:14 -05:00
//printLineF2(F("RIT is ON"));
2018-02-03 02:35:27 -05:00
//enable RIT so the current frequency is used at transmit
ritEnable(frequency);
}
else{
2018-03-04 22:51:14 -05:00
//printLineF2(F("RIT is OFF"));
2018-02-03 02:35:27 -05:00
ritDisable();
}
2018-02-07 22:45:54 -05:00
2018-02-03 02:35:27 -05:00
menuClearExit(500);
}
}
2018-02-05 01:07:25 -05:00
//Split communication using VFOA and VFOB by KD8CEC
2018-02-03 02:35:27 -05:00
void menuSplitOnOff(int btn){
if (!btn){
if (splitOn == 0)
printLineF2(F("Split On?"));
else
printLineF2(F("Split Off?"));
}
else {
if (splitOn == 1){
splitOn = 0;
2018-03-09 08:02:10 -05:00
//printLineF2(F("Split Off!"));
printLineF2(F("[OFF]"));
2018-02-03 02:35:27 -05:00
}
else {
splitOn = 1;
if (ritOn == 1)
ritOn = 0;
2018-03-09 08:02:10 -05:00
//printLineF2(F("Split On!"));
printLineF2(F("[ON]"));
2018-02-03 02:35:27 -05:00
}
menuClearExit(500);
}
2018-01-26 07:47:15 -05:00
}
2018-01-25 09:15:24 -05:00
2018-01-26 07:47:15 -05:00
//Function to disbled transmission
//by KD8CEC
2018-01-13 02:19:23 -05:00
void menuTxOnOff(int btn, byte optionType){
2018-01-09 21:34:15 -05:00
if (!btn){
2018-01-13 02:19:23 -05:00
if ((isTxType & optionType) == 0)
2018-01-09 21:34:15 -05:00
printLineF2(F("TX OFF?"));
else
printLineF2(F("TX ON?"));
}
else {
2018-01-13 02:19:23 -05:00
if ((isTxType & optionType) == 0){
isTxType |= optionType;
2018-01-09 21:34:15 -05:00
printLineF2(F("TX OFF!"));
}
else {
2018-01-13 02:19:23 -05:00
isTxType &= ~(optionType);
2018-01-09 21:34:15 -05:00
printLineF2(F("TX ON!"));
}
2018-02-03 02:35:27 -05:00
menuClearExit(500);
}
}
/**
* The calibration routines are not normally shown in the menu as they are rarely used
* They can be enabled by choosing this menu option
*/
void menuSetup(int btn){
if (!btn){
if (!modeCalibrate)
2018-01-09 21:34:15 -05:00
printLineF2(F("Setup On?"));
else
2018-01-09 21:34:15 -05:00
printLineF2(F("Setup Off?"));
}else {
2018-02-07 22:45:54 -05:00
modeCalibrate = ! modeCalibrate;
/*
if (!modeCalibrate){
modeCalibrate = true;
2018-02-07 22:45:54 -05:00
//printLineF2(F("Setup:On"));
}
else {
modeCalibrate = false;
2018-02-07 22:45:54 -05:00
//printLineF2(F("Setup:Off"));
}
2018-02-07 22:45:54 -05:00
*/
2018-02-03 02:35:27 -05:00
menuClearExit(1000);
}
}
void menuExit(int btn){
if (!btn){
2018-01-09 21:34:15 -05:00
printLineF2(F("Exit Menu?"));
}
2018-02-03 02:35:27 -05:00
else
menuClearExit(0);
}
2018-01-20 08:05:04 -05:00
void menuCWSpeed(int btn){
int knob = 0;
int wpm;
wpm = 1200/cwSpeed;
if (!btn){
strcpy(b, "CW:");
itoa(wpm,c, 10);
strcat(b, c);
strcat(b, "WPM Change?");
printLine2(b);
return;
}
2018-02-07 22:45:54 -05:00
printLineF1(F("Press to set WPM"));
strcpy(b, "WPM:");
itoa(wpm,c, 10);
strcat(b, c);
printLine2(b);
2018-01-09 21:34:15 -05:00
delay_background(300, 0);
2018-02-07 22:45:54 -05:00
while(!btnDown()){
knob = enc_read();
if (knob != 0){
if (wpm > 3 && knob < 0)
wpm--;
if (wpm < 50 && knob > 0)
wpm++;
strcpy(b, "WPM:");
itoa(wpm,c, 10);
strcat(b, c);
printLine2(b);
}
//abort if this button is down
2018-03-04 22:51:14 -05:00
//if (btnDown())
//re-enable the clock1 and clock 2
// break;
2018-01-09 21:34:15 -05:00
Check_Cat(0); //To prevent disconnections
}
2018-03-04 22:51:14 -05:00
//save the setting
//printLineF2(F("CW Speed set!"));
cwSpeed = 1200 / wpm;
EEPROM.put(CW_SPEED, cwSpeed);
menuClearExit(1000);
2018-01-09 21:34:15 -05:00
}
2018-03-09 08:02:10 -05:00
void displayEmptyData(void){
printLineF2(F("Empty data"));
delay_background(2000, 0);
}
2018-01-26 07:47:15 -05:00
//Builtin CW Keyer Logic by KD8CEC
2018-01-20 08:05:04 -05:00
void menuCWAutoKey(int btn){
2018-01-09 21:34:15 -05:00
if (!btn){
2018-03-09 08:02:10 -05:00
printLineF2(F("Memory Keyer"));
return;
2018-01-09 21:34:15 -05:00
}
//Check CW_AUTO_MAGIC_KEY and CW Text Count
EEPROM.get(CW_AUTO_COUNT, cwAutoTextCount);
if (EEPROM.read(CW_AUTO_MAGIC_KEY) != 0x73 || cwAutoTextCount < 1)
{
2018-03-09 08:02:10 -05:00
displayEmptyData();
2018-01-09 21:34:15 -05:00
return;
}
2018-03-09 08:02:10 -05:00
//printLineF1(F("Press PTT to Send"));
printLineF1(F("PTT to Send"));
2018-01-09 21:34:15 -05:00
delay_background(500, 0);
updateDisplay();
beforeCWTextIndex = 255; //255 value is for start check
isCWAutoMode = 1;
menuOn = 0;
}
2018-03-09 08:02:10 -05:00
//Standalone WSPR Beacone
void menuWSPRSend(int btn){
if (!btn){
printLineF2(F("WSPR Beacon"));
return;
}
WsprMSGCount = EEPROM.read(WSPR_COUNT);
if (WsprMSGCount < 1)
{
displayEmptyData();
return;
}
SendWSPRManage();
menuClearExit(1000);
}
2018-01-26 07:47:15 -05:00
//Modified by KD8CEC
2018-01-20 08:05:04 -05:00
void menuSetupCwDelay(int btn){
2018-01-09 21:34:15 -05:00
int knob = 0;
int tmpCWDelay = cwDelayTime * 10;
if (!btn){
2018-02-07 22:45:54 -05:00
printLineF2(F("CW TX->RX Delay"));
2018-01-09 21:34:15 -05:00
return;
}
printLineF1(F("Press, set Delay"));
2018-01-09 21:34:15 -05:00
strcpy(b, "DELAY:");
itoa(tmpCWDelay,c, 10);
strcat(b, c);
printLine2(b);
delay_background(300, 0);
2018-02-07 22:45:54 -05:00
while(!btnDown()){
2018-01-09 21:34:15 -05:00
knob = enc_read();
if (knob != 0){
if (tmpCWDelay > 3 && knob < 0)
tmpCWDelay -= 10;
if (tmpCWDelay < 2500 && knob > 0)
tmpCWDelay += 10;
strcpy(b, "DELAY:");
itoa(tmpCWDelay,c, 10);
strcat(b, c);
printLine2(b);
}
//abort if this button is down
if (btnDown())
break;
Check_Cat(0); //To prevent disconnections
}
//save the setting
2018-03-04 22:51:14 -05:00
//printLineF2(F("CW Delay set!"));
cwDelayTime = tmpCWDelay / 10;
EEPROM.put(CW_DELAY, cwDelayTime);
2018-02-03 02:35:27 -05:00
menuClearExit(1000);
}
2018-01-26 07:47:15 -05:00
//CW Time delay by KD8CEC
2018-01-20 08:05:04 -05:00
void menuSetupTXCWInterval(int btn){
2018-02-07 22:45:54 -05:00
char needDisplayInformation = 1;
2018-01-09 21:34:15 -05:00
int knob = 0;
int tmpTXCWInterval = delayBeforeCWStartTime * 2;
if (!btn){
2018-02-07 22:45:54 -05:00
printLineF2(F("CW Start Delay"));
2018-01-09 21:34:15 -05:00
return;
}
printLineF1(F("Press, set Delay"));
2018-01-09 21:34:15 -05:00
delay_background(300, 0);
2018-02-07 22:45:54 -05:00
while(!btnDown()){
if (needDisplayInformation == 1) {
strcpy(b, "Start Delay:");
itoa(tmpTXCWInterval,c, 10);
strcat(b, c);
printLine2(b);
needDisplayInformation = 0;
}
2018-01-09 21:34:15 -05:00
knob = enc_read();
if (knob != 0){
if (tmpTXCWInterval > 0 && knob < 0)
tmpTXCWInterval -= 2;
if (tmpTXCWInterval < 500 && knob > 0)
tmpTXCWInterval += 2;
2018-02-07 22:45:54 -05:00
/*
2018-01-09 21:34:15 -05:00
strcpy(b, "Start Delay:");
itoa(tmpTXCWInterval,c, 10);
strcat(b, c);
printLine2(b);
2018-02-07 22:45:54 -05:00
*/
needDisplayInformation = 1;
2018-01-09 21:34:15 -05:00
}
//abort if this button is down
2018-03-04 22:51:14 -05:00
//if (btnDown())
// break;
2018-01-09 21:34:15 -05:00
Check_Cat(0); //To prevent disconnections
}
//save the setting
2018-03-04 22:51:14 -05:00
//printLineF2(F("CW Start set!"));
delayBeforeCWStartTime = tmpTXCWInterval / 2;
EEPROM.put(CW_START, delayBeforeCWStartTime);
2018-02-03 02:35:27 -05:00
menuClearExit(1000);
2018-01-09 21:34:15 -05:00
}
/**
* Take a deep breath, math(ematics) ahead
* The 25 mhz oscillator is multiplied by 35 to run the vco at 875 mhz
* This is divided by a number to generate different frequencies.
* If we divide it by 875, we will get 1 mhz signal
* So, if the vco is shifted up by 875 hz, the generated frequency of 1 mhz is shifted by 1 hz (875/875)
* At 12 Mhz, the carrier will needed to be shifted down by 12 hz for every 875 hz of shift up of the vco
*
*/
//this is used by the si5351 routines in the ubitx_5351 file
extern int32_t calibration;
extern uint32_t si5351bx_vcoa;
2018-01-20 08:05:04 -05:00
void factoryCalibration(int btn){
int knob = 0;
//keep clear of any previous button press
while (btnDown())
delay(100);
delay(100);
if (!btn){
2018-01-09 21:34:15 -05:00
printLineF2(F("Set Calibration?"));
2018-01-20 08:05:04 -05:00
return;
}
calibration = 0;
2018-01-29 23:20:52 -05:00
cwMode = 0;
isUSB = true;
//turn off the second local oscillator and the bfo
si5351_set_calibration(calibration);
2018-01-09 21:34:15 -05:00
startTx(TX_CW, 1);
si5351bx_setfreq(2, 10000000l);
strcpy(b, "#1 10 MHz cal:");
ltoa(calibration/8750, c, 10);
strcat(b, c);
printLine2(b);
while (!btnDown())
{
if (digitalRead(PTT) == LOW && !keyDown)
cwKeydown();
if (digitalRead(PTT) == HIGH && keyDown)
cwKeyUp();
knob = enc_read();
if (knob > 0)
calibration += 875;
else if (knob < 0)
calibration -= 875;
else
continue; //don't update the frequency or the display
si5351_set_calibration(calibration);
si5351bx_setfreq(2, 10000000l);
strcpy(b, "#1 10 MHz cal:");
ltoa(calibration/8750, c, 10);
strcat(b, c);
printLine2(b);
}
cwTimeout = 0;
keyDown = 0;
stopTx();
2018-01-09 21:34:15 -05:00
printLineF2(F("Calibration set!"));
EEPROM.put(MASTER_CAL, calibration);
initOscillators();
2018-01-09 21:34:15 -05:00
setFrequency(frequency);
updateDisplay();
while(btnDown())
delay(50);
2018-02-03 02:35:27 -05:00
menuClearExit(100);
}
2018-01-20 08:05:04 -05:00
void menuSetupCalibration(int btn){
int knob = 0;
int32_t prev_calibration;
if (!btn){
2018-01-09 21:34:15 -05:00
printLineF2(F("Set Calibration?"));
2018-01-20 08:05:04 -05:00
return;
}
2018-01-09 21:34:15 -05:00
printLineF1(F("Set to Zero-beat,"));
printLineF2(F("press PTT to save"));
delay_background(1000, 0);
prev_calibration = calibration;
calibration = 0;
si5351_set_calibration(calibration);
setFrequency(frequency);
strcpy(b, "cal:");
ltoa(calibration/8750, c, 10);
strcat(b, c);
printLine2(b);
while (digitalRead(PTT) == HIGH && !btnDown())
{
knob = enc_read();
if (knob > 0){
calibration += 8750;
usbCarrier += 120;
}
else if (knob < 0){
calibration -= 8750;
usbCarrier -= 120;
}
else
continue; //don't update the frequency or the display
si5351_set_calibration(calibration);
si5351bx_setfreq(0, usbCarrier);
setFrequency(frequency);
strcpy(b, "cal:");
ltoa(calibration/8750, c, 10);
strcat(b, c);
printLine2(b);
}
//save the setting
if (digitalRead(PTT) == LOW){
2018-01-09 21:34:15 -05:00
printLineF1(F("Calibration set!"));
printLineF2(F("Set Carrier now"));
EEPROM.put(MASTER_CAL, calibration);
2018-01-09 21:34:15 -05:00
delay_background(2000, 0);
}
else
calibration = prev_calibration;
initOscillators();
//si5351_set_calibration(calibration);
setFrequency(frequency);
2018-02-03 02:35:27 -05:00
//printLine2ClearAndUpdate();
//menuOn = 0;
menuClearExit(0);
}
void printCarrierFreq(unsigned long freq){
memset(c, 0, sizeof(c));
memset(b, 0, sizeof(b));
ultoa(freq, b, DEC);
strncat(c, b, 2);
strcat(c, ".");
strncat(c, &b[2], 3);
strcat(c, ".");
2018-01-29 23:20:52 -05:00
strncat(c, &b[5], 3);
printLine2(c);
}
2018-01-26 07:47:15 -05:00
//modified by KD8CEC (just 1 line remarked //usbCarrier = ...
void menuSetupCarrier(int btn){
int knob = 0;
unsigned long prevCarrier;
if (!btn){
2018-01-09 21:34:15 -05:00
printLineF2(F("Set the BFO"));
return;
}
prevCarrier = usbCarrier;
2018-01-09 21:34:15 -05:00
printLineF1(F("Tune to best Signal"));
printLineF1(F("PTT to confirm. "));
delay_background(1000, 0);
2018-01-22 05:46:50 -05:00
//usbCarrier = 11995000l; //Remarked by KD8CEC, Suggest from many user, if entry routine factoryrest
si5351bx_setfreq(0, usbCarrier);
printCarrierFreq(usbCarrier);
//disable all clock 1 and clock 2
while (digitalRead(PTT) == HIGH && !btnDown())
{
knob = enc_read();
if (knob > 0)
usbCarrier -= 5;
else if (knob < 0)
usbCarrier += 5;
else
continue; //don't update the frequency or the display
si5351bx_setfreq(0, usbCarrier);
printCarrierFreq(usbCarrier);
2018-01-09 21:34:15 -05:00
Check_Cat(0); //To prevent disconnections
delay(100);
}
//save the setting
if (digitalRead(PTT) == LOW){
2018-01-09 21:34:15 -05:00
printLineF2(F("Carrier set!"));
EEPROM.put(USB_CAL, usbCarrier);
2018-01-09 21:34:15 -05:00
delay_background(1000, 0);
}
else
usbCarrier = prevCarrier;
2018-01-29 23:20:52 -05:00
//si5351bx_setfreq(0, usbCarrier);
if (cwMode == 0)
si5351bx_setfreq(0, usbCarrier); //set back the carrier oscillator anyway, cw tx switches it off
else
si5351bx_setfreq(0, cwmCarrier); //set back the carrier oscillator anyway, cw tx switches it off
setFrequency(frequency);
2018-02-03 02:35:27 -05:00
//printLine2ClearAndUpdate();
//menuOn = 0;
menuClearExit(0);
}
2018-01-29 23:20:52 -05:00
//Append by KD8CEC
void menuSetupCWCarrier(int btn){
int knob = 0;
unsigned long prevCarrier;
if (!btn){
printLineF2(F("Set CW RX BFO"));
return;
}
prevCarrier = cwmCarrier;
printLineF1(F("PTT to confirm. "));
delay_background(1000, 0);
si5351bx_setfreq(0, cwmCarrier);
printCarrierFreq(cwmCarrier);
//disable all clock 1 and clock 2
while (digitalRead(PTT) == HIGH && !btnDown())
{
knob = enc_read();
if (knob > 0)
cwmCarrier -= 5;
else if (knob < 0)
cwmCarrier += 5;
else
continue; //don't update the frequency or the display
si5351bx_setfreq(0, cwmCarrier);
printCarrierFreq(cwmCarrier);
2018-02-03 02:35:27 -05:00
delay_background(100, 0);
2018-01-29 23:20:52 -05:00
}
//save the setting
if (digitalRead(PTT) == LOW){
printLineF2(F("Carrier set!"));
EEPROM.put(CW_CAL, cwmCarrier);
delay_background(1000, 0);
}
else
cwmCarrier = prevCarrier;
if (cwMode == 0)
si5351bx_setfreq(0, usbCarrier); //set back the carrier oscillator anyway, cw tx switches it off
else
si5351bx_setfreq(0, cwmCarrier); //set back the carrier oscillator anyway, cw tx switches it off
2018-02-03 02:35:27 -05:00
setFrequency(frequency);
menuClearExit(0);
2018-01-29 23:20:52 -05:00
}
2018-02-03 02:35:27 -05:00
2018-01-26 07:47:15 -05:00
//Modified by KD8CEC
void menuSetupCwTone(int btn){
int knob = 0;
int prev_sideTone;
if (!btn){
2018-01-09 21:34:15 -05:00
printLineF2(F("Change CW Tone"));
return;
}
prev_sideTone = sideTone;
2018-01-09 21:34:15 -05:00
printLineF1(F("Tune CW tone"));
printLineF2(F("PTT to confirm."));
delay_background(1000, 0);
tone(CW_TONE, sideTone);
//disable all clock 1 and clock 2
2018-01-09 21:34:15 -05:00
while (digitalRead(PTT) == HIGH && !btnDown())
{
knob = enc_read();
if (knob > 0 && sideTone < 2000)
sideTone += 10;
else if (knob < 0 && sideTone > 100 )
sideTone -= 10;
else
continue; //don't update the frequency or the display
tone(CW_TONE, sideTone);
itoa(sideTone, b, 10);
printLine2(b);
2018-02-03 02:35:27 -05:00
delay_background(100, 0);
}
noTone(CW_TONE);
//save the setting
if (digitalRead(PTT) == LOW){
2018-01-09 21:34:15 -05:00
printLineF2(F("Sidetone set!"));
2018-02-02 06:49:00 -05:00
EEPROM.put(CW_SIDETONE, sideTone);
2018-01-09 21:34:15 -05:00
delay_background(2000, 0);
}
else
sideTone = prev_sideTone;
2018-02-03 02:35:27 -05:00
menuClearExit(0);
}
2018-01-26 07:47:15 -05:00
//Lock Dial move by KD8CEC
2018-01-09 21:34:15 -05:00
void setDialLock(byte tmpLock, byte fromMode) {
2018-01-11 19:54:38 -05:00
if (tmpLock == 1)
isDialLock |= (vfoActive == VFO_A ? 0x01 : 0x02);
else
isDialLock &= ~(vfoActive == VFO_A ? 0x01 : 0x02);
2018-01-09 21:34:15 -05:00
if (fromMode == 2 || fromMode == 3) return;
2018-02-07 22:45:54 -05:00
2018-03-04 22:51:14 -05:00
//delay_background(1000, 0);
2018-01-09 21:34:15 -05:00
printLine2ClearAndUpdate();
}
2018-02-07 22:45:54 -05:00
byte btnDownTimeCount;
2018-01-22 05:46:50 -05:00
2018-02-07 22:45:54 -05:00
#define PRESS_ADJUST_TUNE 20 //1000msec 20 * 50 = 1000milisec
#define PRESS_LOCK_CONTROL 40 //2000msec 40 * 50 = 2000milisec
2018-01-09 21:34:15 -05:00
2018-01-26 07:47:15 -05:00
//Modified by KD8CEC
void doMenu(){
int select=0, i,btnState;
2018-01-22 05:46:50 -05:00
char isNeedDisplay = 0;
2018-01-09 21:34:15 -05:00
//for DialLock On/Off function
btnDownTimeCount = 0;
//wait for the button to be raised up
2018-01-22 05:46:50 -05:00
//Appened Lines by KD8CEC for Adjust Tune step and Set Dial lock
2018-01-09 21:34:15 -05:00
while(btnDown()){
2018-02-03 02:35:27 -05:00
delay_background(50, 0);
2018-01-09 21:34:15 -05:00
2018-02-07 22:45:54 -05:00
if (btnDownTimeCount++ == (PRESS_ADJUST_TUNE)) { //Set Tune Step
2018-01-22 05:46:50 -05:00
printLineF2(F("Set Tune Step?"));
}
2018-02-07 22:45:54 -05:00
else if (btnDownTimeCount > (PRESS_LOCK_CONTROL)) { //check long time Down Button -> 2.5 Second => Lock
2018-01-11 19:54:38 -05:00
if (vfoActive == VFO_A)
setDialLock((isDialLock & 0x01) == 0x01 ? 0 : 1, 0); //Reverse Dial lock
else
setDialLock((isDialLock & 0x02) == 0x02 ? 0 : 1, 0); //Reverse Dial lock
2018-01-09 21:34:15 -05:00
return;
}
}
delay(50); //debounce
2018-01-09 21:34:15 -05:00
2018-01-22 05:46:50 -05:00
//ADJUST TUNE STEP
2018-02-07 22:45:54 -05:00
if (btnDownTimeCount > PRESS_ADJUST_TUNE)
2018-01-22 05:46:50 -05:00
{
printLineF1(F("Press to set"));
2018-01-22 05:46:50 -05:00
isNeedDisplay = 1; //check to need display for display current value
2018-02-07 22:45:54 -05:00
while (!btnDown())
2018-01-22 05:46:50 -05:00
{
2018-02-03 02:35:27 -05:00
delay_background(50, 0);
2018-01-22 05:46:50 -05:00
if (isNeedDisplay) {
strcpy(b, "Tune Step:");
2018-01-22 07:16:29 -05:00
itoa(arTuneStep[tuneStepIndex -1], c, 10);
2018-01-22 05:46:50 -05:00
strcat(b, c);
printLine2(b);
isNeedDisplay = 0;
}
i = enc_read();
if (i != 0) {
select += (i > 0 ? 1 : -1);
if (select * select >= 25) { //Threshold 5 * 5 = 25
2018-01-22 07:16:29 -05:00
if (select < 0) {
if (tuneStepIndex > 1)
2018-01-22 05:46:50 -05:00
tuneStepIndex--;
}
2018-01-22 07:16:29 -05:00
else {
if (tuneStepIndex < 5)
2018-01-22 05:46:50 -05:00
tuneStepIndex++;
}
select = 0;
isNeedDisplay = 1;
}
}
} //end of while
EEPROM.put(TUNING_STEP, tuneStepIndex);
delay_background(500, 0);
printLine2ClearAndUpdate();
return;
} //set tune step
//Below codes are origial code with modified by KD8CEC
menuOn = 2;
while (menuOn){
i = enc_read();
btnState = btnDown();
if (i > 0){
2018-03-09 08:02:10 -05:00
if (modeCalibrate && select + i < 240)
select += i;
2018-03-09 08:02:10 -05:00
if (!modeCalibrate && select + i < 130)
select += i;
}
2018-03-09 08:02:10 -05:00
2018-01-22 07:16:29 -05:00
if (i < 0 && select - i >= -10)
select += i; //caught ya, i is already -ve here, so you add it
2018-03-09 08:02:10 -05:00
//if -> switch reduce program memory 200byte
switch (select / 10)
{
case 0 :
menuBand(btnState);
break;
case 1 :
menuVfoToggle(btnState);
break;
case 2 :
menuSelectMode(btnState);
break;
case 3 :
menuRitToggle(btnState);
break;
case 4 :
menuIFSSetup(btnState);
break;
case 5 :
menuCWSpeed(btnState);
break;
case 6 :
menuSplitOnOff(btnState); //SplitOn / off
break;
case 7 :
menuCHMemory(btnState, 0); //VFO to Memroy
break;
case 8 :
menuCHMemory(btnState, 1); //Memory to VFO
break;
case 9 :
menuCWAutoKey(btnState);
break;
case 10 :
menuWSPRSend(btnState);
break;
case 11 :
menuSetup(btnState);
break;
case 12 :
menuExit(btnState);
break;
case 13 :
menuSetupCalibration(btnState); //crystal
break;
case 14 :
menuSetupCarrier(btnState); //lsb
break;
case 15 :
menuSetupCWCarrier(btnState); //lsb
break;
case 16 :
menuSetupCwTone(btnState);
break;
case 17 :
menuSetupCwDelay(btnState);
break;
case 18 :
menuSetupTXCWInterval(btnState);
break;
case 19 :
menuSetupKeyType(btnState);
break;
case 20 :
menuADCMonitor(btnState);
break;
case 21 :
menuTxOnOff(btnState, 0x01); //TX OFF / ON
break;
default :
menuExit(btnState); break;
}
2018-03-04 22:51:14 -05:00
/*
2018-02-05 01:07:25 -05:00
else if (select < 130 && modeCalibrate)
menuSetupCalibration(btnState); //crystal
2018-02-05 01:07:25 -05:00
else if (select < 140 && modeCalibrate)
menuSetupCarrier(btnState); //lsb
2018-02-05 01:07:25 -05:00
else if (select < 150 && modeCalibrate)
menuSetupCWCarrier(btnState); //lsb
2018-02-05 01:07:25 -05:00
else if (select < 160 && modeCalibrate)
menuSetupCwTone(btnState);
2018-02-05 01:07:25 -05:00
else if (select < 170 && modeCalibrate)
menuSetupCwDelay(btnState);
2018-02-05 01:07:25 -05:00
else if (select < 180 && modeCalibrate)
menuSetupTXCWInterval(btnState);
2018-02-05 01:07:25 -05:00
else if (select < 190 && modeCalibrate)
menuSetupKeyType(btnState);
2018-02-05 01:07:25 -05:00
else if (select < 200 && modeCalibrate)
menuADCMonitor(btnState);
2018-02-05 01:07:25 -05:00
else if (select < 210 && modeCalibrate)
menuTxOnOff(btnState, 0x01); //TX OFF / ON
2018-02-05 01:07:25 -05:00
else if (select < 220 && modeCalibrate)
2018-01-09 21:34:15 -05:00
menuExit(btnState);
2018-03-04 22:51:14 -05:00
*/
2018-01-09 21:34:15 -05:00
Check_Cat(0); //To prevent disconnections
}
2018-03-04 22:51:14 -05:00
/*
//debounce the button
2018-01-09 21:34:15 -05:00
while(btnDown()){
2018-02-03 02:35:27 -05:00
delay_background(50, 0); //To prevent disconnections
2018-01-09 21:34:15 -05:00
}
2018-03-04 22:51:14 -05:00
*/
}