Skip to content
Permalink
Browse files

The ubitx production sktech, wireup and circuit

This is the snap of the circuit, wiring instructions for the ubitx pcb. the sketch may change slightly for factory alignment but the rest will remain the same.
  • Loading branch information...
afarhan committed Dec 7, 2017
1 parent 37aaaf4 commit e481ea2a2457fc4e7be7a6a4bc9a0fba12bf2cde

Large diffs are not rendered by default.

@@ -0,0 +1,231 @@
/**
* The CAT protocol is used by many radios to provide remote control to comptuers through
* the serial port.
*
* This is very much a work in progress. Parts of this code have been liberally
* borrowed from other GPLicensed works like hamlib.
*
* WARNING : This is an unstable version and it has worked with fldigi,
* it gives time out error with WSJTX 1.8.0
*/

// The next 4 functions are needed to implement the CAT protocol, which
// uses 4-bit BCD formatting.
//
byte setHighNibble(byte b,byte v) {
// Clear the high nibble
b &= 0x0f;
// Set the high nibble
return b | ((v & 0x0f) << 4);
}

byte setLowNibble(byte b,byte v) {
// Clear the low nibble
b &= 0xf0;
// Set the low nibble
return b | (v & 0x0f);
}

byte getHighNibble(byte b) {
return (b >> 4) & 0x0f;
}

byte getLowNibble(byte b) {
return b & 0x0f;
}

// Takes a number and produces the requested number of decimal digits, staring
// from the least significant digit.
//
void getDecimalDigits(unsigned long number,byte* result,int digits) {
for (int i = 0; i < digits; i++) {
// "Mask off" (in a decimal sense) the LSD and return it
result[i] = number % 10;
// "Shift right" (in a decimal sense)
number /= 10;
}
}

// Takes a frequency and writes it into the CAT command buffer in BCD form.
//
void writeFreq(unsigned long freq,byte* cmd) {
// Convert the frequency to a set of decimal digits. We are taking 9 digits
// so that we can get up to 999 MHz. But the protocol doesn't care about the
// LSD (1's place), so we ignore that digit.
byte digits[9];
getDecimalDigits(freq,digits,9);
// Start from the LSB and get each nibble
cmd[3] = setLowNibble(cmd[3],digits[1]);
cmd[3] = setHighNibble(cmd[3],digits[2]);
cmd[2] = setLowNibble(cmd[2],digits[3]);
cmd[2] = setHighNibble(cmd[2],digits[4]);
cmd[1] = setLowNibble(cmd[1],digits[5]);
cmd[1] = setHighNibble(cmd[1],digits[6]);
cmd[0] = setLowNibble(cmd[0],digits[7]);
cmd[0] = setHighNibble(cmd[0],digits[8]);
}

// This function takes a frquency that is encoded using 4 bytes of BCD
// representation and turns it into an long measured in Hz.
//
// [12][34][56][78] = 123.45678? Mhz
//
unsigned long readFreq(byte* cmd) {
// Pull off each of the digits
byte d7 = getHighNibble(cmd[0]);
byte d6 = getLowNibble(cmd[0]);
byte d5 = getHighNibble(cmd[1]);
byte d4 = getLowNibble(cmd[1]);
byte d3 = getHighNibble(cmd[2]);
byte d2 = getLowNibble(cmd[2]);
byte d1 = getHighNibble(cmd[3]);
byte d0 = getLowNibble(cmd[3]);
return
(unsigned long)d7 * 100000000L +
(unsigned long)d6 * 10000000L +
(unsigned long)d5 * 1000000L +
(unsigned long)d4 * 100000L +
(unsigned long)d3 * 10000L +
(unsigned long)d2 * 1000L +
(unsigned long)d1 * 100L +
(unsigned long)d0 * 10L;
}

/**
* Responds to all the cat commands, emulates FT-817
*/

void processCATCommand(byte* cmd) {
byte response[5];

// Debugging code, enable it to fix the cat implementation

count++;
if (cmd[4] == 0x00){
response[0]=0;
Serial.write(response, 1);
}
else if (cmd[4] == 0x01) {
unsigned long f = readFreq(cmd);
setFrequency(f);
updateDisplay();
//sprintf(b, "set:%ld", f);
//printLine2(b);

}
// Get frequency
else if (cmd[4] == 0x03){
writeFreq(frequency,response); // Put the frequency into the buffer
if (isUSB)
response[4] = 0x01; //USB
else
response[4] = 0x00; //LSB
Serial.write(response,5);
printLine2("cat:getfreq");
}
else if (cmd[4] == 0x07){ // set mode
if (cmd[0] == 0x00 || cmd[0] == 0x03)
isUSB = 0;
else
isUSB = 1;
response[0] = 0x00;
Serial.write(response, 1);
setFrequency(frequency);
//printLine2("cat: mode changed");
//updateDisplay();
}
else if (cmd[4] == 0x88){
if (inTx){
stopTx();
txCAT = false;
}
else
response[0] = 0xf0;
printLine2("tx > rx");
Serial.write(response,1);
}
else if (cmd[4] == 0x08) { // PTT On
if (!inTx) {
response[0] = 0;
txCAT = true;
startTx(TX_SSB);
updateDisplay();
} else {
response[0] = 0xf0;
}
Serial.write(response,1);
printLine2("rx > tx");
}
// Read TX keyed state
else if (cmd[4] == 0x10) {
if (!inTx) {
response[0] = 0;
} else {
response[0] = 0xf0;
}
Serial.write(response,1);
printLine2("cat;0x10");
}
// PTT Off
else if (cmd[4] == 0x88) {
byte resBuf[0];
if (inTx) {
response[0] = 0;
} else {
response[0] = 0xf0;
}
Serial.write(response,1);
printLine2("cat;0x88");
//keyed = false;
//digitalWrite(13,LOW);
}
// Read receiver status
else if (cmd[4] == 0xe7) {
response[0] = 0x09;
Serial.write(response,1);
printLine2("cat;0xe7");
}
else if (cmd[4] == 0xf5){

}
// Read receiver status
else if (cmd[4] == 0xf7) {
response[0] = 0x00;
if (inTx) {
response[0] = response[0] | 0xf0;
}
Serial.write(response,1);
printLine2("cat;0xf7");
}
else {
//somehow, get this to print the four bytes
ultoa(*((unsigned long *)cmd), c, 16);
itoa(cmd[4], b, 16);
strcat(b, ":");
strcat(b, c);
printLine2(b);
response[0] = 0x00;
Serial.write(response[0]);
}

}



void checkCAT(){
static byte cat[5];
byte i;

if (Serial.available() < 5)
return;

cat[4] = cat[3];
cat[3] = cat[2];
cat[2] = cat[0];
for (i = 0; i < 5; i++)
cat[i] = Serial.read();

processCATCommand(cat);
}


@@ -0,0 +1,87 @@

/**
* This procedure is only for those who have a signal generator/transceiver tuned to exactly 7.150 and a dummy load
*/

void btnWaitForClick(){
while(!btnDown())
delay(50);
while(btnDown())
delay(50);
delay(50);
}

void factory_alignment(){

factoryCalibration(1);

if (calibration == 0){
printLine2("Setup Aborted");
return;
}

//move it away to 7.160 for an LSB signal
setFrequency(7160000l);
updateDisplay();
printLine2("#2 BFO");
delay(1000);

usbCarrier = 11994999l;
menuSetupCarrier(1);

if (usbCarrier == 11994999l){
printLine2("Setup Aborted");
return;
}


printLine2("#3:Test 3.5MHz");
isUSB = false;
setFrequency(3500000l);
updateDisplay();

while (!btnDown()){
checkPTT();
delay(100);
}

btnWaitForClick();
printLine2("#4:Test 7MHz");

setFrequency(7150000l);
updateDisplay();
while (!btnDown()){
checkPTT();
delay(100);
}

btnWaitForClick();
printLine2("#5:Test 14MHz");

isUSB = true;
setFrequency(14000000l);
updateDisplay();
while (!btnDown()){
checkPTT();
delay(100);
}

btnWaitForClick();
printLine2("#6:Test 28MHz");

setFrequency(28000000l);
updateDisplay();
while (!btnDown()){
checkPTT();
delay(100);
}

printLine2("Alignment done");
delay(1000);

isUSB = false;
setFrequency(7150000l);
updateDisplay();

}

0 comments on commit e481ea2

Please sign in to comment.
You can’t perform that action at this time.