Compare commits
3 Commits
| Author | SHA1 | Date |
|---|---|---|
 Rob French
|
ed99cbe7d8 | |
|
Rob French
|
449cd17a7e | |
|
Rob French
|
9a026faf4e |
|
|
@ -312,7 +312,7 @@ void controlAutoCW(){
|
|||
autoCWSendReservCount = 0; //Init Reserve Count
|
||||
isAutoCWHold = 0;
|
||||
if (!inTx){ //if not TX Status, change RX -> TX
|
||||
keyDown = 0;
|
||||
keyDown = false;
|
||||
startTx(TX_CW, 0); //disable updateDisplay Command for reduce latency time
|
||||
updateDisplay();
|
||||
|
||||
|
|
@ -344,7 +344,7 @@ void controlAutoCW(){
|
|||
if (isAutoCWHold == 0 && (millis() - autoCWbeforeTime > cwSpeed * 3))
|
||||
{
|
||||
if (!inTx){ //if not TX Status, change RX -> TX
|
||||
keyDown = 0;
|
||||
keyDown = false;
|
||||
startTx(TX_CW, 0); //disable updateDisplay Command for reduce latency time
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -20,10 +20,10 @@
|
|||
#include <Arduino.h> //for Linux, On Linux it is case sensitive.
|
||||
|
||||
//==============================================================================
|
||||
// Compile Option
|
||||
// Compile-Time Options
|
||||
//==============================================================================
|
||||
//Ubitx Board Version
|
||||
#define UBITX_BOARD_VERSION 2 //v1 ~ v4 : 4, v5: 5
|
||||
// uBITX Board Version - KC4UPR: updated to v5
|
||||
#define UBITX_BOARD_VERSION 5 //v1 ~ v4 : 4, v5: 5
|
||||
|
||||
//Depending on the type of LCD mounted on the uBITX, uncomment one of the options below.
|
||||
//You must select only one.
|
||||
|
|
@ -214,7 +214,10 @@ extern byte I2C_LCD_SECOND_ADDRESS; //only using Dual LCD Mode
|
|||
#define ENC_A (A0)
|
||||
#define ENC_B (A1)
|
||||
#define FBUTTON (A2)
|
||||
#define PTT (A3)
|
||||
#define PTT (A3) // 8?
|
||||
#define DIGITAL_KEY (A3) // 8?
|
||||
#define DIGITAL_DOT (12)
|
||||
#define DIGITAL_DASH (11)
|
||||
#define ANALOG_KEYER (A6)
|
||||
#define ANALOG_SPARE (A7)
|
||||
#define ANALOG_SMETER (A7) //by KD8CEC
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
//Firmware Version
|
||||
//Firmware Version
|
||||
//+ : This symbol identifies the firmware.
|
||||
// It was originally called 'CEC V1.072' but it is too long to waste the LCD window.
|
||||
// I do not want to make this Firmware users's uBITX messy with my callsign.
|
||||
|
|
@ -53,6 +53,8 @@
|
|||
#include "ubitx.h"
|
||||
#include "ubitx_eemap.h"
|
||||
|
||||
extern void Connect_Interrupts(void);
|
||||
|
||||
/**
|
||||
* The uBITX is an upconnversion transceiver. The first IF is at 45 MHz.
|
||||
* The first IF frequency is not exactly at 45 Mhz but about 5 khz lower,
|
||||
|
|
@ -124,7 +126,7 @@ unsigned long vfoA=7150000L, vfoB=14200000L, sideTone=800, usbCarrier, cwmCarrie
|
|||
unsigned long vfoA_eeprom, vfoB_eeprom; //for protect eeprom life
|
||||
unsigned long frequency, ritRxFrequency, ritTxFrequency; //frequency is the current frequency on the dial
|
||||
|
||||
unsigned int cwSpeed = 100; //this is actuall the dot period in milliseconds
|
||||
int cwSpeed = 100; //this is actuall the dot period in milliseconds
|
||||
extern int32_t calibration;
|
||||
|
||||
//for store the mode in eeprom
|
||||
|
|
@ -166,7 +168,11 @@ int cwAdcBothTo = 0;
|
|||
byte cwKeyType = 0; //0: straight, 1 : iambica, 2: iambicb
|
||||
bool Iambic_Key = true;
|
||||
#define IAMBICB 0x10 // 0 for Iambic A, 1 for Iambic B
|
||||
unsigned char keyerControl = IAMBICB;
|
||||
|
||||
volatile unsigned char keyerControl = 0; // IAMBICB;
|
||||
volatile unsigned char keyerState = 0;
|
||||
volatile unsigned char IAMBIC = 0x10; // 0 for Iambic A, 1 for Iambic B
|
||||
volatile unsigned char PDLSWAP = 0x00; // 0x00 for normal, 0x08 for swap
|
||||
|
||||
byte isShiftDisplayCWFreq = 1; //Display Frequency
|
||||
int shiftDisplayAdjustVal = 0; //
|
||||
|
|
@ -187,10 +193,10 @@ byte userCallsignLength = 0; //7 : display callsign at system startup, 6~0 :
|
|||
/**
|
||||
* Raduino needs to keep track of current state of the transceiver. These are a few variables that do it
|
||||
*/
|
||||
boolean txCAT = false; //turned on if the transmitting due to a CAT command
|
||||
char inTx = 0; //it is set to 1 if in transmit mode (whatever the reason : cw, ptt or cat)
|
||||
bool txCAT = false; // 'True' if transmitting due to CAT command.
|
||||
volatile bool inTx = false; // 'True' if transmitting (regardless of source: CW, PTT, or CAT)
|
||||
char splitOn = 0; //working split, uses VFO B as the transmit frequency
|
||||
char keyDown = 0; //in cw mode, denotes the carrier is being transmitted
|
||||
//char keyDown = 0; //in cw mode, denotes the carrier is being transmitted
|
||||
char isUSB = 0; //upper sideband was selected, this is reset to the default for the
|
||||
|
||||
char cwMode = 0; //compatible original source, and extend mode //if cwMode == 0, mode check : isUSB, cwMode > 0, mode Check : cwMode
|
||||
|
|
@ -444,7 +450,7 @@ void setFrequency(unsigned long f){
|
|||
f = (f / arTuneStep[tuneStepIndex -1]) * arTuneStep[tuneStepIndex -1];
|
||||
setTXFilters(f);
|
||||
|
||||
unsigned long appliedCarrier = ((cwMode == 0 ? usbCarrier : cwmCarrier) + (isIFShift && (inTx == 0) ? ifShiftValue : 0));
|
||||
unsigned long appliedCarrier = ((cwMode == 0 ? usbCarrier : cwmCarrier) + (isIFShift && !inTx) ? ifShiftValue : 0));
|
||||
int appliedTuneValue = 0;
|
||||
|
||||
//applied if tune
|
||||
|
|
@ -454,7 +460,7 @@ void setFrequency(unsigned long f){
|
|||
appliedTuneValue = if1TuneValue;
|
||||
|
||||
//In the LSB state, the optimum reception value was found. To apply to USB, 3Khz decrease is required.
|
||||
if (sdrModeOn && (inTx == 0))
|
||||
if (sdrModeOn && !inTx)
|
||||
appliedTuneValue -= 15; //decrease 1.55Khz
|
||||
|
||||
//if (isUSB)
|
||||
|
|
@ -464,13 +470,13 @@ void setFrequency(unsigned long f){
|
|||
|
||||
//if1Tune RX, TX Enabled, ATT : only RX Mode
|
||||
//The IF Tune shall be measured at the LSB. Then, move the 3Khz down for USB.
|
||||
long if1AdjustValue = ((inTx == 0) ? (attLevel * 100) : 0) + (appliedTuneValue * 100); //if1Tune RX, TX Enabled, ATT : only RX Mode //5600
|
||||
long if1AdjustValue = (!inTx ? (attLevel * 100) : 0) + (appliedTuneValue * 100); //if1Tune RX, TX Enabled, ATT : only RX Mode //5600
|
||||
|
||||
//for DIY uBITX (custom filter)
|
||||
if ((advancedFreqOption1 & 0x80) != 0x00) //Reverse IF Tune (- Value for DIY uBITX)
|
||||
if1AdjustValue *= -1;
|
||||
|
||||
if (sdrModeOn && (inTx == 0)) //IF SDR MODE
|
||||
if (sdrModeOn && !inTx) //IF SDR MODE
|
||||
{
|
||||
//Fixed Frequency SDR (Default Frequency : 32Mhz, available change sdr Frequency by uBITX Manager)
|
||||
//Dynamic Frequency is for SWL without cat
|
||||
|
|
@ -555,7 +561,7 @@ void startTx(byte txMode, byte isDisplayUpdate){
|
|||
if ((isTxType & 0x01) != 0x01)
|
||||
digitalWrite(TX_RX, 1);
|
||||
|
||||
inTx = 1;
|
||||
inTx = true;
|
||||
|
||||
if (ritOn){
|
||||
//save the current as the rx frequency
|
||||
|
|
@ -618,7 +624,7 @@ void startTx(byte txMode, byte isDisplayUpdate){
|
|||
}
|
||||
|
||||
void stopTx(void){
|
||||
inTx = 0;
|
||||
inTx = false;
|
||||
|
||||
digitalWrite(TX_RX, 0); //turn off the tx
|
||||
SetCarrierFreq();
|
||||
|
|
@ -682,12 +688,12 @@ void checkPTT(){
|
|||
if (cwTimeout > 0)
|
||||
return;
|
||||
|
||||
if (digitalRead(PTT) == 0 && inTx == 0){
|
||||
if (digitalRead(PTT) == 0 && !inTx){
|
||||
startTx(TX_SSB, 1);
|
||||
delay(50); //debounce the PTT
|
||||
}
|
||||
|
||||
if (digitalRead(PTT) == 1 && inTx == 1)
|
||||
if (digitalRead(PTT) == 1 && inTx)
|
||||
stopTx();
|
||||
}
|
||||
#ifdef EXTEND_KEY_GROUP1
|
||||
|
|
@ -1432,6 +1438,7 @@ void setup()
|
|||
factory_alignment();
|
||||
#endif
|
||||
|
||||
Connect_Interrupts();
|
||||
}
|
||||
|
||||
//Auto save Frequency and Mode with Protected eeprom life by KD8CEC
|
||||
|
|
@ -1487,7 +1494,7 @@ void loop(){
|
|||
} //end of check TX Status
|
||||
|
||||
//we check CAT after the encoder as it might put the radio into TX
|
||||
Check_Cat(inTx? 1 : 0);
|
||||
Check_Cat(inTx ? 1 : 0);
|
||||
|
||||
//for SEND SW Serial
|
||||
#ifdef USE_SW_SERIAL
|
||||
|
|
|
|||
|
|
@ -0,0 +1,356 @@
|
|||
/**
|
||||
* File name ubitx_keyer.cpp
|
||||
* CW Keyer
|
||||
*
|
||||
* The CW keyer handles either a straight key or an iambic / paddle key.
|
||||
* D12 for DOT Paddle and D11 for DASH Paddle and D* for PTT/Handkey
|
||||
*
|
||||
* Generating CW
|
||||
* The CW is cleanly generated by unbalancing the front-end mixer
|
||||
* and putting the local oscillator directly at the CW transmit frequency.
|
||||
* The sidetone, generated by the Arduino is injected into the volume control
|
||||
*/
|
||||
#include <Arduino.h>
|
||||
#include "ubitx.h"
|
||||
|
||||
extern void stopTx(void);
|
||||
extern void startTx(byte txMode, byte isDisplayUpdate);
|
||||
|
||||
extern unsigned long sideTone;
|
||||
extern int cwSpeed;
|
||||
extern volatile bool inTx;
|
||||
//extern volatile int ubitx_mode;
|
||||
extern char isUSB;
|
||||
extern char cwMode;
|
||||
|
||||
extern volatile unsigned char keyerControl;
|
||||
extern volatile unsigned char keyerState;
|
||||
extern unsigned volatile char IAMBIC;
|
||||
extern unsigned volatile char PDLSWAP;
|
||||
|
||||
volatile bool keyDown = false; //in cw mode, denotes the carrier is being transmitted
|
||||
volatile uint8_t Last_Bits = 0xFF;;
|
||||
|
||||
volatile bool Dot_in_Progress = false;
|
||||
volatile unsigned long Dot_Timer_Count = 0;
|
||||
volatile bool Dash_in_Progress = false;
|
||||
volatile unsigned long Dash_Timer_Count = 0;
|
||||
volatile bool Inter_Bit_in_Progress = false;
|
||||
volatile unsigned long Inter_Bit_Timer_Count = 0;
|
||||
volatile bool Turn_Off_Carrier_in_Progress = false;
|
||||
volatile unsigned long Turn_Off_Carrier_Timer_Count = 0;
|
||||
volatile bool PTT_HANDKEY_ACTIVE = false;
|
||||
volatile long last_interrupt_time = 20;
|
||||
|
||||
extern bool txCAT;
|
||||
|
||||
// KC4UPR: These are some temporary (maybe?) translation macros to translate
|
||||
// between the mode selection code in W0EB's software, versus the mode
|
||||
// selection code in the basic (and CEC) software. I may replace this is the
|
||||
// future, either by reworking the whole codebase to use the (superior) W0EB
|
||||
// method, or else by modifying the keyer code to use the stock mode selection
|
||||
// code.
|
||||
#define MODE_USB 0
|
||||
#define MODE_LSB 1
|
||||
#define MODE_CW 2
|
||||
#define MODE_CWR 3
|
||||
#define ubitx_mode (cwMode == 0 ? (isUSB == 0) : ((cwMode == 1) + 2))
|
||||
|
||||
/* KC4UPR: Temporary holding ground for definitions etc that may need to get moved to other files. */
|
||||
//#define DIGITAL_PTT (A3)
|
||||
//#define DIGITAL_DOT (D11)
|
||||
//#define DIGITAL_DASH (D12)
|
||||
|
||||
/*
|
||||
Arduino Pin MC Pin Interrupt Mask
|
||||
A3/D17 PC3 PCINT[11] PCMSK1/bit 3
|
||||
D11 PB3 PCINT[3] PCMSK0/bit 3
|
||||
D12 PB4 PCINT[4] PCMSK0/bit 4
|
||||
*/
|
||||
|
||||
/**
|
||||
* Starts transmitting the carrier with the sidetone
|
||||
* It assumes that we have called cwTxStart and not called cwTxStop
|
||||
* each time it is called, the cwTimeOut is pushed further into the future
|
||||
*/
|
||||
void cwKeyDown(void) {
|
||||
keyDown = true; //tracks the CW_KEY
|
||||
tone(CW_TONE, (int)sideTone);
|
||||
digitalWrite(CW_KEY, 1);
|
||||
#ifdef XMIT_LED
|
||||
digitalWrite(ON_AIR, 0); // extinguish the LED on NANO's pin 13
|
||||
#endif
|
||||
|
||||
}
|
||||
/**
|
||||
* Stops the CW carrier transmission along with the sidetone
|
||||
* Pushes the cwTimeout further into the future
|
||||
*/
|
||||
void cwKeyUp(void) {
|
||||
keyDown = false; //tracks the CW_KEY
|
||||
noTone(CW_TONE);
|
||||
digitalWrite(CW_KEY, 0);
|
||||
#ifdef XMIT_LED
|
||||
digitalWrite(ON_AIR, 1); // extinguish the LED on NANO's pin 13
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
|
||||
void update_PaddleLatch() {
|
||||
if (digitalRead(DIGITAL_DOT) == LOW) {
|
||||
if (keyerControl & PDLSWAP)
|
||||
keyerControl |= DAH_L;
|
||||
else
|
||||
keyerControl |= DIT_L;
|
||||
}
|
||||
if (digitalRead(DIGITAL_DASH) == LOW) {
|
||||
if (keyerControl & PDLSWAP)
|
||||
keyerControl |= DIT_L;
|
||||
else
|
||||
keyerControl |= DAH_L;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////////////////
|
||||
// interupt handlers
|
||||
|
||||
//// timers
|
||||
ISR(TIMER1_OVF_vect) {
|
||||
bool continue_loop = true;
|
||||
|
||||
// process if CW modes
|
||||
if ((ubitx_mode == MODE_CW) || (ubitx_mode == MODE_CWR)) {
|
||||
|
||||
// process DOT and DASH timing
|
||||
if (Dot_in_Progress && (Dot_Timer_Count > 0)) {
|
||||
if (!inTx) {
|
||||
keyDown = false;
|
||||
startTx(TX_CW, 0);
|
||||
}
|
||||
if (!keyDown)
|
||||
cwKeyDown();
|
||||
Dot_Timer_Count = Dot_Timer_Count - 1;
|
||||
if (Dot_Timer_Count <= 0) {
|
||||
Dot_Timer_Count = 0;
|
||||
Dot_in_Progress = false;
|
||||
cwKeyUp();
|
||||
}
|
||||
}
|
||||
|
||||
// process Inter Bit Timing
|
||||
if (Inter_Bit_in_Progress && (Inter_Bit_Timer_Count > 0)) {
|
||||
Inter_Bit_Timer_Count = Inter_Bit_Timer_Count - 1;
|
||||
if (Inter_Bit_Timer_Count <= 0) {
|
||||
Inter_Bit_Timer_Count = 0;
|
||||
Inter_Bit_in_Progress = false;
|
||||
}
|
||||
}
|
||||
|
||||
// process turning off carrier
|
||||
if (Turn_Off_Carrier_in_Progress && (Turn_Off_Carrier_Timer_Count > 0)) {
|
||||
Turn_Off_Carrier_Timer_Count = Turn_Off_Carrier_Timer_Count - 1;
|
||||
if (Turn_Off_Carrier_Timer_Count <= 0) {
|
||||
Turn_Off_Carrier_in_Progress = false;
|
||||
Turn_Off_Carrier_Timer_Count = 0;
|
||||
stopTx();
|
||||
}
|
||||
}
|
||||
|
||||
// process hand key
|
||||
if (digitalRead(DIGITAL_KEY) == LOW) {
|
||||
// If interrupts come faster than 5ms, assume it's a bounce and ignore
|
||||
last_interrupt_time = last_interrupt_time - 1;
|
||||
if (last_interrupt_time <= 0) {
|
||||
last_interrupt_time = 0;
|
||||
if (!inTx) {
|
||||
keyDown = false;
|
||||
startTx(TX_CW, 0);
|
||||
}
|
||||
if (!keyDown)
|
||||
cwKeyDown();
|
||||
PTT_HANDKEY_ACTIVE = true;
|
||||
Turn_Off_Carrier_Timer_Count = CW_TIMEOUT;
|
||||
}
|
||||
} else if (keyDown && PTT_HANDKEY_ACTIVE) {
|
||||
cwKeyUp();
|
||||
Turn_Off_Carrier_Timer_Count = CW_TIMEOUT;
|
||||
Turn_Off_Carrier_in_Progress = true;
|
||||
last_interrupt_time = PTT_HNDKEY_DEBOUNCE_CT;
|
||||
PTT_HANDKEY_ACTIVE = false;
|
||||
} else {
|
||||
last_interrupt_time = PTT_HNDKEY_DEBOUNCE_CT;
|
||||
}
|
||||
|
||||
if (!PTT_HANDKEY_ACTIVE) {
|
||||
while (continue_loop) {
|
||||
switch (keyerState) {
|
||||
case IDLE:
|
||||
if ((digitalRead(DIGITAL_DOT) == LOW) ||
|
||||
(digitalRead(DIGITAL_DASH) == LOW) ||
|
||||
(keyerControl & 0x03)) {
|
||||
|
||||
update_PaddleLatch();
|
||||
keyerState = CHK_DIT;
|
||||
Dot_in_Progress = false;
|
||||
Dot_Timer_Count = 0;
|
||||
Turn_Off_Carrier_Timer_Count = 0;
|
||||
Turn_Off_Carrier_in_Progress = false;
|
||||
} else {
|
||||
continue_loop = false;
|
||||
}
|
||||
break;
|
||||
|
||||
case CHK_DIT:
|
||||
if (keyerControl & DIT_L) {
|
||||
keyerControl |= DIT_PROC;
|
||||
keyerState = KEYED_PREP;
|
||||
Dot_Timer_Count = cwSpeed;
|
||||
} else {
|
||||
keyerState = CHK_DAH;
|
||||
}
|
||||
break;
|
||||
|
||||
case CHK_DAH:
|
||||
if (keyerControl & DAH_L) {
|
||||
keyerState = KEYED_PREP;
|
||||
Dot_Timer_Count = cwSpeed*3;
|
||||
} else {
|
||||
continue_loop = false;
|
||||
keyerState = IDLE;
|
||||
}
|
||||
break;
|
||||
|
||||
case KEYED_PREP:
|
||||
keyerControl &= ~(DIT_L + DAH_L); // clear both paddle latch bits
|
||||
keyerState = KEYED; // next state
|
||||
Turn_Off_Carrier_Timer_Count = 0;
|
||||
Turn_Off_Carrier_in_Progress = false;
|
||||
Dot_in_Progress = true;
|
||||
break;
|
||||
|
||||
case KEYED:
|
||||
if (!Dot_in_Progress) { // are we at end of key down ?
|
||||
Inter_Bit_in_Progress = true;
|
||||
Inter_Bit_Timer_Count = cwSpeed;
|
||||
keyerState = INTER_ELEMENT; // next state
|
||||
} else if (keyerControl & IAMBIC) {
|
||||
update_PaddleLatch(); // early paddle latch in Iambic B mode
|
||||
continue_loop = false;
|
||||
} else continue_loop = false;
|
||||
break;
|
||||
|
||||
case INTER_ELEMENT:
|
||||
// Insert time between dits/dahs
|
||||
update_PaddleLatch(); // latch paddle state
|
||||
if (!Inter_Bit_in_Progress) { // are we at end of inter-space ?
|
||||
Turn_Off_Carrier_Timer_Count = CW_TIMEOUT;
|
||||
Turn_Off_Carrier_in_Progress = true;
|
||||
if (keyerControl & DIT_PROC) { // was it a dit or dah ?
|
||||
keyerControl &= ~(DIT_L + DIT_PROC); // clear two bits
|
||||
keyerState = CHK_DAH; // dit done, check for dah
|
||||
} else {
|
||||
keyerControl &= ~(DAH_L); // clear dah latch
|
||||
keyerState = IDLE; // go idle
|
||||
}
|
||||
} else continue_loop = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// process PTT
|
||||
if ((ubitx_mode == MODE_USB) || (ubitx_mode == MODE_LSB)) {
|
||||
if (digitalRead(PTT) == LOW) {
|
||||
// If interrupts come faster than 5ms, assume it's a bounce and ignore
|
||||
last_interrupt_time = last_interrupt_time - 1;
|
||||
if (last_interrupt_time <= 0) {
|
||||
last_interrupt_time = 0;
|
||||
if (!inTx) {
|
||||
startTx(TX_SSB, 0);
|
||||
}
|
||||
}
|
||||
} else if (inTx && !txCAT) {
|
||||
last_interrupt_time = PTT_HNDKEY_DEBOUNCE_CT;
|
||||
stopTx();
|
||||
} else {
|
||||
last_interrupt_time = PTT_HNDKEY_DEBOUNCE_CT;
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
void Connect_Interrupts(void) {
|
||||
keyerControl = 0;
|
||||
cli();
|
||||
|
||||
PCMSK0 |- 0b00011000; // turn on dot/dash pins PB3/PB4, physical D11/D12
|
||||
PCMSK1 |= 0b00001000; // turn on PTT and Handkey pin PC3, physical A3
|
||||
PCICR |= 0b00000011; // turn on ports B and C
|
||||
|
||||
TIMSK1 |= (1<<TOIE1);
|
||||
|
||||
sei();
|
||||
}
|
||||
|
||||
|
||||
#define N_MORSE (sizeof(morsetab)/sizeof(morsetab[0]))
|
||||
// Morse table
|
||||
struct t_mtab {
|
||||
char c, pat;
|
||||
} ;
|
||||
struct t_mtab morsetab[] = {
|
||||
{'.', 106}, {',', 115}, {'?', 76}, {'/', 41}, {'A', 6}, {'B', 17}, {'C', 21}, {'D', 9},
|
||||
{'E', 2}, {'F', 20}, {'G', 11}, {'H', 16}, {'I', 4}, {'J', 30}, {'K', 13}, {'L', 18},
|
||||
{'M', 7}, {'N', 5}, {'O', 15}, {'P', 22}, {'Q', 27}, {'R', 10}, {'S', 8}, {'T', 3},
|
||||
{'U', 12}, {'V', 24}, {'W', 14}, {'X', 25}, {'Y', 29}, {'Z', 19}, {'1', 62}, {'2', 60},
|
||||
{'3', 56}, {'4', 48}, {'5', 32}, {'6', 33}, {'7', 35}, {'8', 39}, {'9', 47}, {'0', 63}
|
||||
};
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
// CW generation routines for CQ message
|
||||
void key(int LENGTH) {
|
||||
|
||||
if( !inTx ) startTx(TX_CW, 0);
|
||||
cwKeyDown();
|
||||
delay(LENGTH*2);
|
||||
cwKeyUp();
|
||||
delay(cwSpeed*2);
|
||||
|
||||
}
|
||||
|
||||
|
||||
void send(char c) {
|
||||
int i ;
|
||||
|
||||
|
||||
if (c == ' ') {
|
||||
delay(7*cwSpeed) ;
|
||||
return ;
|
||||
}
|
||||
for (i=0; i<N_MORSE; i++) {
|
||||
if (morsetab[i].c == c) {
|
||||
unsigned char p = morsetab[i].pat ;
|
||||
while (p != 1) {
|
||||
if (p & 1) Dot_Timer_Count = cwSpeed*3;
|
||||
else Dot_Timer_Count = cwSpeed;
|
||||
key(Dot_Timer_Count);
|
||||
p = p / 2 ;
|
||||
}
|
||||
delay(cwSpeed*5) ;
|
||||
return ;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
void sendmsg(char *str) {
|
||||
|
||||
while (*str) send(*str++);
|
||||
delay(650);
|
||||
stopTx();
|
||||
}
|
||||
|
|
@ -1,369 +0,0 @@
|
|||
/**
|
||||
CW Keyer
|
||||
CW Key logic change with ron's code (ubitx_keyer.cpp)
|
||||
Ron's logic has been modified to work with the original uBITX by KD8CEC
|
||||
|
||||
Original Comment ----------------------------------------------------------------------------
|
||||
* The CW keyer handles either a straight key or an iambic / paddle key.
|
||||
* They all use just one analog input line. This is how it works.
|
||||
* The analog line has the internal pull-up resistor enabled.
|
||||
* When a straight key is connected, it shorts the pull-up resistor, analog input is 0 volts
|
||||
* When a paddle is connected, the dot and the dash are connected to the analog pin through
|
||||
* a 10K and a 2.2K resistors. These produce a 4v and a 2v input to the analog pins.
|
||||
* So, the readings are as follows :
|
||||
* 0v - straight key
|
||||
* 1-2.5 v - paddle dot
|
||||
* 2.5 to 4.5 v - paddle dash
|
||||
* 2.0 to 0.5 v - dot and dash pressed
|
||||
*
|
||||
* The keyer is written to transparently handle all these cases
|
||||
*
|
||||
* Generating CW
|
||||
* The CW is cleanly generated by unbalancing the front-end mixer
|
||||
* and putting the local oscillator directly at the CW transmit frequency.
|
||||
* The sidetone, generated by the Arduino is injected into the volume control
|
||||
*/
|
||||
|
||||
|
||||
// in milliseconds, this is the parameter that determines how long the tx will hold between cw key downs
|
||||
//#define CW_TIMEOUT (600l) //Change to CW Delaytime for value save to eeprom
|
||||
#define PADDLE_DOT 1
|
||||
#define PADDLE_DASH 2
|
||||
#define PADDLE_BOTH 3
|
||||
#define PADDLE_STRAIGHT 4
|
||||
|
||||
//we store the last padde's character
|
||||
//to alternatively send dots and dashes
|
||||
//when both are simultaneously pressed
|
||||
char lastPaddle = 0;
|
||||
|
||||
//reads the analog keyer pin and reports the paddle
|
||||
byte getPaddle(){
|
||||
int paddle = analogRead(ANALOG_KEYER);
|
||||
|
||||
if (paddle > 800) // above 4v is up
|
||||
return 0;
|
||||
|
||||
if (paddle > 600) // 4-3v is dot
|
||||
return PADDLE_DASH;
|
||||
else if (paddle > 300) //1-2v is dash
|
||||
return PADDLE_DOT;
|
||||
else if (paddle > 50)
|
||||
return PADDLE_BOTH; //both are between 1 and 2v
|
||||
else
|
||||
return PADDLE_STRAIGHT; //less than 1v is the straight key
|
||||
}
|
||||
|
||||
/**
|
||||
* Starts transmitting the carrier with the sidetone
|
||||
* It assumes that we have called cwTxStart and not called cwTxStop
|
||||
* each time it is called, the cwTimeOut is pushed further into the future
|
||||
*/
|
||||
void cwKeydown(){
|
||||
keyDown = 1; //tracks the CW_KEY
|
||||
tone(CW_TONE, (int)sideTone);
|
||||
digitalWrite(CW_KEY, 1);
|
||||
|
||||
//Modified by KD8CEC, for CW Delay Time save to eeprom
|
||||
//cwTimeout = millis() + CW_TIMEOUT;
|
||||
cwTimeout = millis() + cwDelayTime * 10;
|
||||
}
|
||||
|
||||
/**
|
||||
* Stops the cw carrier transmission along with the sidetone
|
||||
* Pushes the cwTimeout further into the future
|
||||
*/
|
||||
void cwKeyUp(){
|
||||
keyDown = 0; //tracks the CW_KEY
|
||||
noTone(CW_TONE);
|
||||
digitalWrite(CW_KEY, 0);
|
||||
|
||||
//Modified by KD8CEC, for CW Delay Time save to eeprom
|
||||
//cwTimeout = millis() + CW_TIMEOUT;
|
||||
cwTimeout = millis() + cwDelayTime * 10;
|
||||
}
|
||||
|
||||
//Variables for Ron's new logic
|
||||
#define DIT_L 0x01 // DIT latch
|
||||
#define DAH_L 0x02 // DAH latch
|
||||
#define DIT_PROC 0x04 // DIT is being processed
|
||||
#define PDLSWAP 0x08 // 0 for normal, 1 for swap
|
||||
#define IAMBICB 0x10 // 0 for Iambic A, 1 for Iambic B
|
||||
enum KSTYPE {IDLE, CHK_DIT, CHK_DAH, KEYED_PREP, KEYED, INTER_ELEMENT };
|
||||
static unsigned long ktimer;
|
||||
unsigned char keyerState = IDLE;
|
||||
|
||||
//Below is a test to reduce the keying error. do not delete lines
|
||||
//create by KD8CEC for compatible with new CW Logic
|
||||
char update_PaddleLatch(byte isUpdateKeyState) {
|
||||
unsigned char tmpKeyerControl = 0;
|
||||
int paddle = analogRead(ANALOG_KEYER);
|
||||
|
||||
if (paddle >= cwAdcDashFrom && paddle <= cwAdcDashTo)
|
||||
tmpKeyerControl |= DAH_L;
|
||||
else if (paddle >= cwAdcDotFrom && paddle <= cwAdcDotTo)
|
||||
tmpKeyerControl |= DIT_L;
|
||||
else if (paddle >= cwAdcBothFrom && paddle <= cwAdcBothTo)
|
||||
tmpKeyerControl |= (DAH_L | DIT_L) ;
|
||||
else
|
||||
{
|
||||
if (Iambic_Key)
|
||||
tmpKeyerControl = 0 ;
|
||||
else if (paddle >= cwAdcSTFrom && paddle <= cwAdcSTTo)
|
||||
tmpKeyerControl = DIT_L ;
|
||||
else
|
||||
tmpKeyerControl = 0 ;
|
||||
}
|
||||
|
||||
if (isUpdateKeyState == 1)
|
||||
keyerControl |= tmpKeyerControl;
|
||||
|
||||
return tmpKeyerControl;
|
||||
}
|
||||
|
||||
/*****************************************************************************
|
||||
// New logic, by RON
|
||||
// modified by KD8CEC
|
||||
******************************************************************************/
|
||||
void cwKeyer(void){
|
||||
lastPaddle = 0;
|
||||
bool continue_loop = true;
|
||||
unsigned tmpKeyControl = 0;
|
||||
|
||||
if( Iambic_Key ) {
|
||||
while(continue_loop) {
|
||||
switch (keyerState) {
|
||||
case IDLE:
|
||||
tmpKeyControl = update_PaddleLatch(0);
|
||||
if ( tmpKeyControl == DAH_L || tmpKeyControl == DIT_L ||
|
||||
tmpKeyControl == (DAH_L | DIT_L) || (keyerControl & 0x03)) {
|
||||
update_PaddleLatch(1);
|
||||
keyerState = CHK_DIT;
|
||||
}else{
|
||||
if (0 < cwTimeout && cwTimeout < millis()){
|
||||
cwTimeout = 0;
|
||||
stopTx();
|
||||
}
|
||||
continue_loop = false;
|
||||
}
|
||||
break;
|
||||
|
||||
case CHK_DIT:
|
||||
if (keyerControl & DIT_L) {
|
||||
keyerControl |= DIT_PROC;
|
||||
ktimer = cwSpeed;
|
||||
keyerState = KEYED_PREP;
|
||||
}else{
|
||||
keyerState = CHK_DAH;
|
||||
}
|
||||
break;
|
||||
|
||||
case CHK_DAH:
|
||||
if (keyerControl & DAH_L) {
|
||||
ktimer = cwSpeed*3;
|
||||
keyerState = KEYED_PREP;
|
||||
}else{
|
||||
keyerState = IDLE;
|
||||
}
|
||||
break;
|
||||
|
||||
case KEYED_PREP:
|
||||
//modified KD8CEC
|
||||
/*
|
||||
ktimer += millis(); // set ktimer to interval end time
|
||||
keyerControl &= ~(DIT_L + DAH_L); // clear both paddle latch bits
|
||||
keyerState = KEYED; // next state
|
||||
if (!inTx){
|
||||
//DelayTime Option
|
||||
delay_background(delayBeforeCWStartTime * 2, 2);
|
||||
|
||||
keyDown = 0;
|
||||
cwTimeout = millis() + cwDelayTime * 10; //+ CW_TIMEOUT;
|
||||
startTx(TX_CW, 1);
|
||||
}
|
||||
*/
|
||||
if (!inTx){
|
||||
//DelayTime Option
|
||||
delay_background(delayBeforeCWStartTime * 2, 2);
|
||||
|
||||
keyDown = 0;
|
||||
cwTimeout = millis() + cwDelayTime * 10; //+ CW_TIMEOUT;
|
||||
startTx(TX_CW, 1);
|
||||
}
|
||||
ktimer += millis(); // set ktimer to interval end time
|
||||
keyerControl &= ~(DIT_L + DAH_L); // clear both paddle latch bits
|
||||
keyerState = KEYED; // next state
|
||||
|
||||
cwKeydown();
|
||||
break;
|
||||
|
||||
case KEYED:
|
||||
if (millis() > ktimer) { // are we at end of key down ?
|
||||
cwKeyUp();
|
||||
ktimer = millis() + cwSpeed; // inter-element time
|
||||
keyerState = INTER_ELEMENT; // next state
|
||||
}else if (keyerControl & IAMBICB) {
|
||||
update_PaddleLatch(1); // early paddle latch in Iambic B mode
|
||||
}
|
||||
break;
|
||||
|
||||
case INTER_ELEMENT:
|
||||
// Insert time between dits/dahs
|
||||
update_PaddleLatch(1); // latch paddle state
|
||||
if (millis() > ktimer) { // are we at end of inter-space ?
|
||||
if (keyerControl & DIT_PROC) { // was it a dit or dah ?
|
||||
keyerControl &= ~(DIT_L + DIT_PROC); // clear two bits
|
||||
keyerState = CHK_DAH; // dit done, check for dah
|
||||
}else{
|
||||
keyerControl &= ~(DAH_L); // clear dah latch
|
||||
keyerState = IDLE; // go idle
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
Check_Cat(2);
|
||||
} //end of while
|
||||
}
|
||||
else{
|
||||
while(1){
|
||||
if (update_PaddleLatch(0) == DIT_L) {
|
||||
// if we are here, it is only because the key is pressed
|
||||
if (!inTx){
|
||||
//DelayTime Option
|
||||
delay_background(delayBeforeCWStartTime * 2, 2);
|
||||
|
||||
keyDown = 0;
|
||||
cwTimeout = millis() + cwDelayTime * 10; //+ CW_TIMEOUT;
|
||||
startTx(TX_CW, 1);
|
||||
}
|
||||
cwKeydown();
|
||||
|
||||
while ( update_PaddleLatch(0) == DIT_L )
|
||||
delay_background(1, 3);
|
||||
|
||||
cwKeyUp();
|
||||
}
|
||||
else{
|
||||
if (0 < cwTimeout && cwTimeout < millis()){
|
||||
cwTimeout = 0;
|
||||
keyDown = 0;
|
||||
stopTx();
|
||||
}
|
||||
//if (!cwTimeout) //removed by KD8CEC
|
||||
// return;
|
||||
// got back to the beginning of the loop, if no further activity happens on straight key
|
||||
// we will time out, and return out of this routine
|
||||
//delay(5);
|
||||
//delay_background(5, 3); //removed by KD8CEC
|
||||
//continue; //removed by KD8CEC
|
||||
return; //Tx stop control by Main Loop
|
||||
}
|
||||
|
||||
Check_Cat(2);
|
||||
} //end of while
|
||||
} //end of elese
|
||||
}
|
||||
|
||||
|
||||
//=======================================================================================
|
||||
//Before logic
|
||||
//by Farhan and modified by KD8CEC
|
||||
//======================================================================================
|
||||
|
||||
/**
|
||||
* The keyer handles the straight key as well as the iambic key
|
||||
* This module keeps looping until the user stops sending cw
|
||||
* if the cwTimeout is set to 0, then it means, we have to exit the keyer loop
|
||||
* Each time the key is hit the cwTimeout is pushed to a time in the future by cwKeyDown()
|
||||
*/
|
||||
/*
|
||||
void cwKeyer(){
|
||||
byte paddle;
|
||||
lastPaddle = 0;
|
||||
|
||||
while(1){
|
||||
paddle = getPaddle();
|
||||
|
||||
// do nothing if the paddle has not been touched, unless
|
||||
// we are in the cw mode and we have timed out
|
||||
if (!paddle){
|
||||
//modifed by KD8CEC for auto CW Send
|
||||
if (isCWAutoMode > 1) //if while auto cw sending, dont stop tx by paddle position
|
||||
return;
|
||||
|
||||
if (0 < cwTimeout && cwTimeout < millis()){
|
||||
cwTimeout = 0;
|
||||
keyDown = 0;
|
||||
stopTx();
|
||||
}
|
||||
|
||||
if (!cwTimeout)
|
||||
return;
|
||||
|
||||
Check_Cat(2); //for uBITX on Raspberry pi, when straight keying, disconnect / test complete
|
||||
continue;
|
||||
}
|
||||
|
||||
//if while auto cw send, stop auto cw
|
||||
//but isAutoCWHold for Manual Keying with cwAutoSend
|
||||
if (isCWAutoMode > 1 && isAutoCWHold == 0)
|
||||
isCWAutoMode = 1; //read status
|
||||
|
||||
//Remoark Debug code / Serial Use by CAT Protocol
|
||||
//Serial.print("paddle:");Serial.println(paddle);
|
||||
// if we are here, it is only because the key or the paddle is pressed
|
||||
if (!inTx){
|
||||
keyDown = 0;
|
||||
//Modified by KD8CEC, for CW Delay Time save to eeprom
|
||||
//cwTimeout = millis() + CW_TIMEOUT;
|
||||
cwTimeout = millis() + cwDelayTime * 10;
|
||||
|
||||
startTx(TX_CW, 0); //disable updateDisplay Command for reduce latency time
|
||||
updateDisplay();
|
||||
|
||||
//DelayTime Option
|
||||
delay_background(delayBeforeCWStartTime * 2, 2);
|
||||
}
|
||||
|
||||
// star the transmission)
|
||||
// we store the transmitted character in the lastPaddle
|
||||
cwKeydown();
|
||||
if (paddle == PADDLE_DOT){
|
||||
//delay(cwSpeed);
|
||||
delay_background(cwSpeed, 3);
|
||||
lastPaddle = PADDLE_DOT;
|
||||
}
|
||||
else if (paddle == PADDLE_DASH){
|
||||
//delay(cwSpeed * 3);
|
||||
delay_background(cwSpeed * 3, 3);
|
||||
lastPaddle = PADDLE_DASH;
|
||||
}
|
||||
else if (paddle == PADDLE_BOTH){ //both paddles down
|
||||
//depending upon what was sent last, send the other
|
||||
if (lastPaddle == PADDLE_DOT) {
|
||||
//delay(cwSpeed * 3);
|
||||
delay_background(cwSpeed * 3, 3);
|
||||
lastPaddle = PADDLE_DASH;
|
||||
}else{
|
||||
//delay(cwSpeed);
|
||||
delay_background(cwSpeed, 3);
|
||||
lastPaddle = PADDLE_DOT;
|
||||
}
|
||||
}
|
||||
else if (paddle == PADDLE_STRAIGHT){
|
||||
while (getPaddle() == PADDLE_STRAIGHT) {
|
||||
delay(1);
|
||||
Check_Cat(2);
|
||||
}
|
||||
lastPaddle = PADDLE_STRAIGHT;
|
||||
}
|
||||
cwKeyUp();
|
||||
//introduce a dot long gap between characters if the keyer was used
|
||||
if (lastPaddle != PADDLE_STRAIGHT)
|
||||
delay(cwSpeed);
|
||||
}
|
||||
}
|
||||
*/
|
||||
|
||||
|
||||
|
|
@ -1,790 +0,0 @@
|
|||
/*************************************************************************
|
||||
KD8CEC's uBITX Display Routine for LCD1602 Parrel
|
||||
1.This is the display code for the default LCD mounted in uBITX.
|
||||
2.Some functions moved from uBITX_Ui.
|
||||
-----------------------------------------------------------------------------
|
||||
This program is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
**************************************************************************/
|
||||
#include "ubitx.h"
|
||||
#include "ubitx_lcd.h"
|
||||
|
||||
//========================================================================
|
||||
//Begin of TinyLCD Library by KD8CEC
|
||||
//========================================================================
|
||||
|
||||
#ifdef UBITX_DISPLAY_LCD1602P
|
||||
/*************************************************************************
|
||||
LCD1602_TINY Library for 16 x 2 LCD
|
||||
Referecnce Source : LiquidCrystal.cpp
|
||||
KD8CEC
|
||||
|
||||
This source code is modified version for small program memory
|
||||
from Arduino LiquidCrystal Library
|
||||
|
||||
I wrote this code myself, so there is no license restriction.
|
||||
So this code allows anyone to write with confidence.
|
||||
But keep it as long as the original author of the code.
|
||||
DE Ian KD8CEC
|
||||
**************************************************************************/
|
||||
|
||||
#define LCD_Command(x) (LCD_Send(x, LOW))
|
||||
#define LCD_Write(x) (LCD_Send(x, HIGH))
|
||||
|
||||
#define UBITX_DISPLAY_LCD1602_BASE
|
||||
|
||||
//Define connected PIN
|
||||
#define LCD_PIN_RS 8
|
||||
#define LCD_PIN_EN 9
|
||||
uint8_t LCD_PIN_DAT[4] = {10, 11, 12, 13};
|
||||
|
||||
void write4bits(uint8_t value)
|
||||
{
|
||||
for (int i = 0; i < 4; i++)
|
||||
digitalWrite(LCD_PIN_DAT[i], (value >> i) & 0x01);
|
||||
|
||||
digitalWrite(LCD_PIN_EN, LOW);
|
||||
delayMicroseconds(1);
|
||||
digitalWrite(LCD_PIN_EN, HIGH);
|
||||
delayMicroseconds(1); // enable pulse must be >450ns
|
||||
digitalWrite(LCD_PIN_EN, LOW);
|
||||
delayMicroseconds(100); // commands need > 37us to settle
|
||||
}
|
||||
|
||||
void LCD_Send(uint8_t value, uint8_t mode)
|
||||
{
|
||||
digitalWrite(LCD_PIN_RS, mode);
|
||||
write4bits(value>>4);
|
||||
write4bits(value);
|
||||
}
|
||||
|
||||
void LCD1602_Init()
|
||||
{
|
||||
pinMode(LCD_PIN_RS, OUTPUT);
|
||||
pinMode(LCD_PIN_EN, OUTPUT);
|
||||
for (int i = 0; i < 4; i++)
|
||||
pinMode(LCD_PIN_DAT[i], OUTPUT);
|
||||
|
||||
delayMicroseconds(50);
|
||||
|
||||
// Now we pull both RS and R/W low to begin commands
|
||||
digitalWrite(LCD_PIN_RS, LOW);
|
||||
digitalWrite(LCD_PIN_EN, LOW);
|
||||
|
||||
// we start in 8bit mode, try to set 4 bit mode
|
||||
write4bits(0x03);
|
||||
delayMicroseconds(4500); // wait min 4.1ms
|
||||
|
||||
// second try
|
||||
write4bits(0x03);
|
||||
delayMicroseconds(4500); // wait min 4.1ms
|
||||
|
||||
// third go!
|
||||
write4bits(0x03);
|
||||
delayMicroseconds(150);
|
||||
|
||||
// finally, set to 4-bit interface
|
||||
write4bits(0x02);
|
||||
|
||||
// finally, set # lines, font size, etc.
|
||||
LCD_Command(LCD_FUNCTIONSET | LCD_4BITMODE | LCD_1LINE | LCD_5x8DOTS | LCD_2LINE);
|
||||
|
||||
// turn the display on with no cursor or blinking default
|
||||
LCD_Command(LCD_DISPLAYCONTROL | LCD_DISPLAYON | LCD_CURSOROFF | LCD_BLINKOFF);
|
||||
|
||||
// clear it off
|
||||
LCD_Command(LCD_CLEARDISPLAY); // clear display, set cursor position to zero
|
||||
delayMicroseconds(2000); // this command takes a long time!
|
||||
|
||||
LCD_Command(LCD_ENTRYMODESET | LCD_ENTRYLEFT | LCD_ENTRYSHIFTDECREMENT);
|
||||
}
|
||||
|
||||
#endif
|
||||
//========================================================================
|
||||
//End of TinyLCD Library by KD8CEC
|
||||
//========================================================================
|
||||
|
||||
|
||||
//========================================================================
|
||||
//Begin of I2CTinyLCD Library by KD8CEC
|
||||
//========================================================================
|
||||
#ifdef UBITX_DISPLAY_LCD1602I
|
||||
#include <Wire.h>
|
||||
/*************************************************************************
|
||||
I2C Tiny LCD Library
|
||||
Referecnce Source : LiquidCrystal_I2C.cpp // Based on the work by DFRobot
|
||||
KD8CEC
|
||||
|
||||
This source code is modified version for small program memory
|
||||
from Arduino LiquidCrystal_I2C Library
|
||||
|
||||
I wrote this code myself, so there is no license restriction.
|
||||
So this code allows anyone to write with confidence.
|
||||
But keep it as long as the original author of the code.
|
||||
Ian KD8CEC
|
||||
**************************************************************************/
|
||||
#define UBITX_DISPLAY_LCD1602_BASE
|
||||
|
||||
#define En B00000100 // Enable bit
|
||||
#define Rw B00000010 // Read/Write bit
|
||||
#define Rs B00000001 // Register select bit
|
||||
|
||||
#define LCD_Command(x) (LCD_Send(x, 0))
|
||||
#define LCD_Write(x) (LCD_Send(x, Rs))
|
||||
|
||||
uint8_t _Addr;
|
||||
uint8_t _displayfunction;
|
||||
uint8_t _displaycontrol;
|
||||
uint8_t _displaymode;
|
||||
uint8_t _numlines;
|
||||
uint8_t _cols;
|
||||
uint8_t _rows;
|
||||
uint8_t _backlightval;
|
||||
|
||||
#define printIIC(args) Wire.write(args)
|
||||
|
||||
void expanderWrite(uint8_t _data)
|
||||
{
|
||||
Wire.beginTransmission(_Addr);
|
||||
printIIC((int)(_data) | _backlightval);
|
||||
Wire.endTransmission();
|
||||
}
|
||||
|
||||
void pulseEnable(uint8_t _data){
|
||||
expanderWrite(_data | En); // En high
|
||||
delayMicroseconds(1); // enable pulse must be >450ns
|
||||
|
||||
expanderWrite(_data & ~En); // En low
|
||||
delayMicroseconds(50); // commands need > 37us to settle
|
||||
}
|
||||
|
||||
void write4bits(uint8_t value)
|
||||
{
|
||||
expanderWrite(value);
|
||||
pulseEnable(value);
|
||||
}
|
||||
|
||||
void LCD_Send(uint8_t value, uint8_t mode)
|
||||
{
|
||||
uint8_t highnib=value&0xf0;
|
||||
uint8_t lownib=(value<<4)&0xf0;
|
||||
write4bits((highnib)|mode);
|
||||
write4bits((lownib)|mode);
|
||||
}
|
||||
|
||||
|
||||
// Turn the (optional) backlight off/on
|
||||
void noBacklight(void) {
|
||||
_backlightval=LCD_NOBACKLIGHT;
|
||||
expanderWrite(0);
|
||||
}
|
||||
|
||||
void backlight(void) {
|
||||
_backlightval=LCD_BACKLIGHT;
|
||||
expanderWrite(0);
|
||||
}
|
||||
|
||||
void LCD1602_Init()
|
||||
{
|
||||
//I2C Init
|
||||
_Addr = I2C_LCD_MASTER_ADDRESS;
|
||||
_cols = 16;
|
||||
_rows = 2;
|
||||
_backlightval = LCD_NOBACKLIGHT;
|
||||
Wire.begin();
|
||||
|
||||
delay(50);
|
||||
|
||||
// Now we pull both RS and R/W low to begin commands
|
||||
expanderWrite(_backlightval); // reset expanderand turn backlight off (Bit 8 =1)
|
||||
delay(1000);
|
||||
//put the LCD into 4 bit mode
|
||||
// this is according to the hitachi HD44780 datasheet
|
||||
// figure 24, pg 46
|
||||
|
||||
// we start in 8bit mode, try to set 4 bit mode
|
||||
write4bits(0x03 << 4);
|
||||
delayMicroseconds(4500); // wait min 4.1ms
|
||||
|
||||
// second try
|
||||
write4bits(0x03 << 4);
|
||||
delayMicroseconds(4500); // wait min 4.1ms
|
||||
|
||||
// third go!
|
||||
write4bits(0x03 << 4);
|
||||
delayMicroseconds(150);
|
||||
|
||||
// finally, set to 4-bit interface
|
||||
write4bits(0x02 << 4);
|
||||
|
||||
// finally, set # lines, font size, etc.
|
||||
LCD_Command(LCD_FUNCTIONSET | LCD_4BITMODE | LCD_1LINE | LCD_5x8DOTS | LCD_2LINE);
|
||||
|
||||
// turn the display on with no cursor or blinking default
|
||||
LCD_Command(LCD_DISPLAYCONTROL | LCD_DISPLAYON | LCD_CURSOROFF | LCD_BLINKOFF);
|
||||
|
||||
// clear it off
|
||||
LCD_Command(LCD_CLEARDISPLAY); // clear display, set cursor position to zero
|
||||
//delayMicroseconds(2000); // this command takes a long time!
|
||||
delayMicroseconds(1000); // this command takes a long time!
|
||||
|
||||
LCD_Command(LCD_ENTRYMODESET | LCD_ENTRYLEFT | LCD_ENTRYSHIFTDECREMENT);
|
||||
|
||||
backlight();
|
||||
}
|
||||
|
||||
/*
|
||||
void LCD_Print(const char *c)
|
||||
{
|
||||
for (uint8_t i = 0; i < strlen(c); i++)
|
||||
{
|
||||
if (*(c + i) == 0x00) return;
|
||||
LCD_Write(*(c + i));
|
||||
}
|
||||
}
|
||||
|
||||
void LCD_SetCursor(uint8_t col, uint8_t row)
|
||||
{
|
||||
LCD_Command(LCD_SETDDRAMADDR | (col + row * 0x40)); //0 : 0x00, 1 : 0x40, only for 16 x 2 lcd
|
||||
}
|
||||
|
||||
void LCD_CreateChar(uint8_t location, uint8_t charmap[])
|
||||
{
|
||||
location &= 0x7; // we only have 8 locations 0-7
|
||||
LCD_Command(LCD_SETCGRAMADDR | (location << 3));
|
||||
for (int i=0; i<8; i++)
|
||||
LCD_Write(charmap[i]);
|
||||
}
|
||||
*/
|
||||
#endif
|
||||
//========================================================================
|
||||
//End of I2CTinyLCD Library by KD8CEC
|
||||
//========================================================================
|
||||
|
||||
|
||||
//========================================================================
|
||||
// 16 X 02 LCD Routines
|
||||
//Begin of Display Base Routines (Init, printLine..)
|
||||
//========================================================================
|
||||
#ifdef UBITX_DISPLAY_LCD1602_BASE
|
||||
|
||||
//SWR GRAPH, DrawMeter and drawingMeter Logic function by VK2ETA
|
||||
#define OPTION_SKINNYBARS
|
||||
|
||||
char c[30], b[30];
|
||||
char printBuff[2][17]; //mirrors what is showing on the two lines of the display
|
||||
|
||||
|
||||
void LCD_Print(const char *c)
|
||||
{
|
||||
for (uint8_t i = 0; i < strlen(c); i++)
|
||||
{
|
||||
if (*(c + i) == 0x00) return;
|
||||
LCD_Write(*(c + i));
|
||||
}
|
||||
}
|
||||
|
||||
void LCD_SetCursor(uint8_t col, uint8_t row)
|
||||
{
|
||||
LCD_Command(LCD_SETDDRAMADDR | (col + row * 0x40)); //0 : 0x00, 1 : 0x40, only for 16 x 2 lcd
|
||||
}
|
||||
|
||||
void LCD_CreateChar(uint8_t location, uint8_t charmap[])
|
||||
{
|
||||
location &= 0x7; // we only have 8 locations 0-7
|
||||
LCD_Command(LCD_SETCGRAMADDR | (location << 3));
|
||||
for (int i=0; i<8; i++)
|
||||
LCD_Write(charmap[i]);
|
||||
}
|
||||
|
||||
void LCD_Init(void)
|
||||
{
|
||||
LCD1602_Init();
|
||||
initMeter(); //for Meter Display
|
||||
}
|
||||
|
||||
// The generic routine to display one line on the LCD
|
||||
void printLine(unsigned char linenmbr, const char *c) {
|
||||
if ((displayOption1 & 0x01) == 0x01)
|
||||
linenmbr = (linenmbr == 0 ? 1 : 0); //Line Toggle
|
||||
if (strcmp(c, printBuff[linenmbr])) { // only refresh the display when there was a change
|
||||
LCD_SetCursor(0, linenmbr); // place the cursor at the beginning of the selected line
|
||||
LCD_Print(c);
|
||||
strcpy(printBuff[linenmbr], c);
|
||||
|
||||
for (byte i = strlen(c); i < 16; i++) { // add white spaces until the end of the 16 characters line is reached
|
||||
LCD_Write(' ');
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void printLineF(char linenmbr, const __FlashStringHelper *c)
|
||||
{
|
||||
int i;
|
||||
char tmpBuff[17];
|
||||
PGM_P p = reinterpret_cast<PGM_P>(c);
|
||||
|
||||
for (i = 0; i < 17; i++){
|
||||
unsigned char fChar = pgm_read_byte(p++);
|
||||
tmpBuff[i] = fChar;
|
||||
if (fChar == 0)
|
||||
break;
|
||||
}
|
||||
|
||||
printLine(linenmbr, tmpBuff);
|
||||
}
|
||||
|
||||
#define LCD_MAX_COLUMN 16
|
||||
void printLineFromEEPRom(char linenmbr, char lcdColumn, byte eepromStartIndex, byte eepromEndIndex, char offsetTtype) {
|
||||
if ((displayOption1 & 0x01) == 0x01)
|
||||
linenmbr = (linenmbr == 0 ? 1 : 0); //Line Toggle
|
||||
|
||||
LCD_SetCursor(lcdColumn, linenmbr);
|
||||
|
||||
for (byte i = eepromStartIndex; i <= eepromEndIndex; i++)
|
||||
{
|
||||
if (++lcdColumn <= LCD_MAX_COLUMN)
|
||||
LCD_Write(EEPROM.read((offsetTtype == 0 ? USER_CALLSIGN_DAT : WSPR_MESSAGE1) + i));
|
||||
else
|
||||
break;
|
||||
}
|
||||
|
||||
for (byte i = lcdColumn; i < 16; i++) //Right Padding by Space
|
||||
LCD_Write(' ');
|
||||
}
|
||||
|
||||
// short cut to print to the first line
|
||||
void printLine1(const char *c)
|
||||
{
|
||||
printLine(1,c);
|
||||
}
|
||||
// short cut to print to the first line
|
||||
void printLine2(const char *c)
|
||||
{
|
||||
printLine(0,c);
|
||||
}
|
||||
|
||||
void clearLine2()
|
||||
{
|
||||
printLine2("");
|
||||
line2DisplayStatus = 0;
|
||||
}
|
||||
|
||||
// short cut to print to the first line
|
||||
void printLine1Clear(){
|
||||
printLine(1,"");
|
||||
}
|
||||
// short cut to print to the first line
|
||||
void printLine2Clear(){
|
||||
printLine(0, "");
|
||||
}
|
||||
|
||||
void printLine2ClearAndUpdate(){
|
||||
printLine(0, "");
|
||||
line2DisplayStatus = 0;
|
||||
updateDisplay();
|
||||
}
|
||||
|
||||
//==================================================================================
|
||||
//End of Display Base Routines
|
||||
//==================================================================================
|
||||
|
||||
|
||||
//==================================================================================
|
||||
//Begin of User Interface Routines
|
||||
//==================================================================================
|
||||
|
||||
//Main Display
|
||||
// this builds up the top line of the display with frequency and mode
|
||||
void updateDisplay() {
|
||||
// tks Jack Purdum W8TEE
|
||||
// replaced fsprint commmands by str commands for code size reduction
|
||||
// replace code for Frequency numbering error (alignment, point...) by KD8CEC
|
||||
int i;
|
||||
unsigned long tmpFreq = frequency; //
|
||||
|
||||
memset(c, 0, sizeof(c));
|
||||
|
||||
if (inTx){
|
||||
if (isCWAutoMode == 2) {
|
||||
for (i = 0; i < 4; i++)
|
||||
c[3-i] = (i < autoCWSendReservCount ? byteToChar(autoCWSendReserv[i]) : ' ');
|
||||
|
||||
//display Sending Index
|
||||
c[4] = byteToChar(sendingCWTextIndex);
|
||||
c[5] = '=';
|
||||
}
|
||||
else {
|
||||
if (cwTimeout > 0)
|
||||
strcpy(c, " CW:");
|
||||
else
|
||||
strcpy(c, " TX:");
|
||||
}
|
||||
}
|
||||
else {
|
||||
if (ritOn)
|
||||
strcpy(c, "RIT ");
|
||||
else {
|
||||
if (cwMode == 0)
|
||||
{
|
||||
if (isUSB)
|
||||
strcpy(c, "USB ");
|
||||
else
|
||||
strcpy(c, "LSB ");
|
||||
}
|
||||
else if (cwMode == 1)
|
||||
{
|
||||
strcpy(c, "CWL ");
|
||||
}
|
||||
else
|
||||
{
|
||||
strcpy(c, "CWU ");
|
||||
}
|
||||
}
|
||||
if (vfoActive == VFO_A) // VFO A is active
|
||||
strcat(c, "A:");
|
||||
else
|
||||
strcat(c, "B:");
|
||||
}
|
||||
|
||||
//Fixed by Mitani Massaru (JE4SMQ)
|
||||
if (isShiftDisplayCWFreq == 1)
|
||||
{
|
||||
if (cwMode == 1) //CWL
|
||||
tmpFreq = tmpFreq - sideTone + shiftDisplayAdjustVal;
|
||||
else if (cwMode == 2) //CWU
|
||||
tmpFreq = tmpFreq + sideTone + shiftDisplayAdjustVal;
|
||||
}
|
||||
|
||||
//display frequency
|
||||
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] = ' ';
|
||||
}
|
||||
|
||||
//remarked by KD8CEC
|
||||
//already RX/TX status display, and over index (16 x 2 LCD)
|
||||
//if (inTx)
|
||||
// strcat(c, " TX");
|
||||
printLine(1, c);
|
||||
|
||||
byte diplayVFOLine = 1;
|
||||
if ((displayOption1 & 0x01) == 0x01)
|
||||
diplayVFOLine = 0;
|
||||
|
||||
if ((vfoActive == VFO_A && ((isDialLock & 0x01) == 0x01)) ||
|
||||
(vfoActive == VFO_B && ((isDialLock & 0x02) == 0x02))) {
|
||||
LCD_SetCursor(5,diplayVFOLine);
|
||||
LCD_Write((uint8_t)0);
|
||||
}
|
||||
else if (isCWAutoMode == 2){
|
||||
LCD_SetCursor(5,diplayVFOLine);
|
||||
LCD_Write(0x7E);
|
||||
}
|
||||
else
|
||||
{
|
||||
LCD_SetCursor(5,diplayVFOLine);
|
||||
LCD_Write(':');
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
char line2Buffer[17];
|
||||
//KD8CEC 200Hz ST
|
||||
//L14.150 200Hz ST
|
||||
//U14.150 +150khz
|
||||
int freqScrollPosition = 0;
|
||||
|
||||
//Example Line2 Optinal Display
|
||||
//immediate execution, not call by scheulder
|
||||
//warning : unused parameter 'displayType' <-- ignore, this is reserve
|
||||
void updateLine2Buffer(char displayType)
|
||||
{
|
||||
unsigned long tmpFreq = 0;
|
||||
if (ritOn)
|
||||
{
|
||||
strcpy(line2Buffer, "RitTX:");
|
||||
|
||||
//display frequency
|
||||
tmpFreq = ritTxFrequency;
|
||||
|
||||
//Fixed by Mitani Massaru (JE4SMQ)
|
||||
if (isShiftDisplayCWFreq == 1)
|
||||
{
|
||||
if (cwMode == 1) //CWL
|
||||
tmpFreq = tmpFreq - sideTone + shiftDisplayAdjustVal;
|
||||
else if (cwMode == 2) //CWU
|
||||
tmpFreq = tmpFreq + sideTone + shiftDisplayAdjustVal;
|
||||
}
|
||||
|
||||
for (int i = 15; i >= 6; i--) {
|
||||
if (tmpFreq > 0) {
|
||||
if (i == 12 || i == 8) line2Buffer[i] = '.';
|
||||
else {
|
||||
line2Buffer[i] = tmpFreq % 10 + 0x30;
|
||||