mirror of
https://codeberg.org/mclemens/ubitxv6.git
synced 2024-08-23 15:34:21 -04:00
186 lines
5.8 KiB
C++
186 lines
5.8 KiB
C++
/**
|
|
* This source file is under General Public License version 3.
|
|
*
|
|
* This verision uses a built-in Si5351 library
|
|
* Most source code are meant to be understood by the compilers and the computers.
|
|
* Code that has to be hackable needs to be well understood and properly documented.
|
|
* Donald Knuth coined the term Literate Programming to indicate code that is written be
|
|
* easily read and understood.
|
|
*
|
|
* The Raduino is a small board that includes the Arduin Nano, a TFT display and
|
|
* an Si5351a frequency synthesizer. This board is manufactured by HF Signals Electronics Pvt Ltd
|
|
*
|
|
* To learn more about Arduino you may visit www.arduino.cc.
|
|
*
|
|
* The Arduino works by starts executing the code in a function called setup() and then it
|
|
* repeatedly keeps calling loop() forever. All the initialization code is kept in setup()
|
|
* and code to continuously sense the tuning knob, the function button, transmit/receive,
|
|
* etc is all in the loop() function. If you wish to study the code top down, then scroll
|
|
* to the bottom of this file and read your way up.
|
|
*
|
|
* Below are the libraries to be included for building the Raduino
|
|
* The EEPROM library is used to store settings like the frequency memory, caliberation data, etc.
|
|
*
|
|
* The main chip which generates upto three oscillators of various frequencies in the
|
|
* Raduino is the Si5351a. To learn more about Si5351a you can download the datasheet
|
|
* from www.silabs.com although, strictly speaking it is not a requirment to understand this code.
|
|
* Instead, you can look up the Si5351 library written by xxx, yyy. You can download and
|
|
* install it from www.url.com to complile this file.
|
|
* The Wire.h library is used to talk to the Si5351 and we also declare an instance of
|
|
* Si5351 object to control the clocks.
|
|
*/
|
|
#include <Wire.h>
|
|
#include "encoder.h"
|
|
#include "menu.h"
|
|
#include "menu_main.h"
|
|
#include "morse.h"
|
|
#include "pin_definitions.h"
|
|
#include "push_button.h"
|
|
#include "nano_gui.h"
|
|
#include "settings.h"
|
|
#include "setup.h"
|
|
#include "si5351.h"
|
|
#include "touch.h"
|
|
#include "tuner.h"
|
|
#include "ui_touch.h"
|
|
|
|
/**
|
|
* The Arduino, unlike C/C++ on a regular computer with gigabytes of RAM, has very little memory.
|
|
* We have to be very careful with variables that are declared inside the functions as they are
|
|
* created in a memory region called the stack. The stack has just a few bytes of space on the Arduino
|
|
* if you declare large strings inside functions, they can easily exceed the capacity of the stack
|
|
* and mess up your programs.
|
|
* We circumvent this by declaring a few global buffers as kitchen counters where we can
|
|
* slice and dice our strings. These strings are mostly used to control the display or handle
|
|
* the input and output from the USB port. We must keep a count of the bytes used while reading
|
|
* the serial port as we can easily run out of buffer space. This is done in the serial_in_count variable.
|
|
*/
|
|
char b[128];
|
|
char c[30];
|
|
|
|
//during CAT commands, we will freeeze the display until CAT is disengaged
|
|
unsigned char doingCAT = 0;
|
|
|
|
/**
|
|
* Basic User Interface Routines. These check the front panel for any activity
|
|
*/
|
|
|
|
/**
|
|
* The PTT is checked only if we are not already in a cw transmit session
|
|
* If the PTT is pressed, we shift to the ritbase if the rit was on
|
|
* flip the T/R line to T and update the display to denote transmission
|
|
*/
|
|
|
|
void checkPTT(){
|
|
//we don't check for ptt when transmitting cw
|
|
if (globalSettings.cwExpirationTimeMs > 0){
|
|
return;
|
|
}
|
|
|
|
if(digitalRead(PIN_PTT) == 0 && !globalSettings.txActive){
|
|
startTx(TuningMode_e::TUNE_SSB);
|
|
delay(50); //debounce the PTT
|
|
}
|
|
|
|
if (digitalRead(PIN_PTT) == 1 && globalSettings.txActive)
|
|
stopTx();
|
|
}
|
|
|
|
/**
|
|
* The settings are read from EEPROM. The first time around, the values may not be
|
|
* present or out of range, in this case, some intelligent defaults are copied into the
|
|
* variables.
|
|
*/
|
|
void initSettings(){
|
|
LoadDefaultSettings();
|
|
LoadSettingsFromEeprom();
|
|
}
|
|
|
|
void initPorts(){
|
|
|
|
analogReference(DEFAULT);
|
|
|
|
//??
|
|
pinMode(PIN_ENC_A, INPUT_PULLUP);
|
|
pinMode(PIN_ENC_B, INPUT_PULLUP);
|
|
pinMode(PIN_ENC_PUSH_BUTTON, INPUT_PULLUP);
|
|
enc_setup();
|
|
|
|
//configure the function button to use the external pull-up
|
|
// pinMode(PIN_ENC_PUSH_BUTTON, INPUT);
|
|
// digitalWrite(PIN_ENC_PUSH_BUTTON, HIGH);
|
|
|
|
pinMode(PIN_PTT, INPUT_PULLUP);
|
|
// pinMode(PIN_ANALOG_KEYER, INPUT_PULLUP);
|
|
|
|
pinMode(PIN_CW_TONE, OUTPUT);
|
|
digitalWrite(PIN_CW_TONE, 0);
|
|
|
|
pinMode(PIN_TX_RXn,OUTPUT);
|
|
digitalWrite(PIN_TX_RXn, 0);
|
|
|
|
pinMode(PIN_TX_LPF_A, OUTPUT);
|
|
pinMode(PIN_TX_LPF_B, OUTPUT);
|
|
pinMode(PIN_TX_LPF_C, OUTPUT);
|
|
digitalWrite(PIN_TX_LPF_A, 0);
|
|
digitalWrite(PIN_TX_LPF_B, 0);
|
|
digitalWrite(PIN_TX_LPF_C, 0);
|
|
|
|
pinMode(PIN_CW_KEY, OUTPUT);
|
|
digitalWrite(PIN_CW_KEY, 0);
|
|
}
|
|
|
|
void setup()
|
|
{
|
|
Serial.begin(38400);
|
|
Serial.flush();
|
|
|
|
initSettings();
|
|
displayInit();
|
|
initTouch();
|
|
initPorts();
|
|
initOscillators();
|
|
setFrequency(globalSettings.vfoA.frequency);
|
|
|
|
//Run initial calibration routine if button is pressed during power up
|
|
if(ButtonPress_e::NotPressed != CheckTunerButton()){
|
|
LoadDefaultSettings();
|
|
setupTouch();
|
|
SetActiveVfoMode(VfoMode_e::VFO_MODE_USB);
|
|
setFrequency(10000000L);
|
|
runLocalOscSetting();
|
|
SetActiveVfoMode(VfoMode_e::VFO_MODE_LSB);
|
|
setFrequency(7100000L);
|
|
runBfoSetting();
|
|
}
|
|
|
|
rootMenu->initMenu();
|
|
}
|
|
|
|
|
|
/**
|
|
* The loop checks for keydown, ptt, function button and tuning.
|
|
*/
|
|
|
|
void loop(){
|
|
if(TuningMode_e::TUNE_CW == globalSettings.tuningMode){
|
|
cwKeyer();
|
|
}
|
|
else if(!globalSettings.txCatActive){
|
|
checkPTT();
|
|
}
|
|
|
|
checkCAT();
|
|
|
|
if(globalSettings.txActive){
|
|
//Don't run menus when transmitting
|
|
return;
|
|
}
|
|
|
|
ButtonPress_e tuner_button = CheckTunerButton();
|
|
Point touch_point;
|
|
ButtonPress_e touch_button = checkTouch(&touch_point);
|
|
int16_t knob = enc_read();
|
|
runActiveMenu(tuner_button,touch_button,touch_point,knob);
|
|
}
|