set_af_gain(0,value);
break;
case AF_GAIN_RX2:
- value=KnobOrWheel(a, receiver[1]->volume, 0.0, 1.0, 0.01);
- set_af_gain(1,value);
+ if (receivers == 2) {
+ value=KnobOrWheel(a, receiver[1]->volume, 0.0, 1.0, 0.01);
+ set_af_gain(1,value);
+ }
break;
case AGC:
if(a->mode==PRESSED) {
set_agc_gain(0,value);
break;
case AGC_GAIN_RX2:
- value=KnobOrWheel(a, receiver[1]->agc_gain, -20.0, 120.0, 1.0);
- set_agc_gain(1,value);
+ if (receivers == 2) {
+ value=KnobOrWheel(a, receiver[1]->agc_gain, -20.0, 120.0, 1.0);
+ set_agc_gain(1,value);
+ }
break;
case ANF:
if(a->mode==PRESSED) {
set_rf_gain(0,value);
break;
case RF_GAIN_RX2:
- value=KnobOrWheel(a, adc[receiver[1]->adc].gain, adc[receiver[1]->adc].min_gain, adc[receiver[1]->adc].max_gain, 1.0);
- set_rf_gain(1,value);
+ if (receivers == 2) {
+ value=KnobOrWheel(a, adc[receiver[1]->adc].gain, adc[receiver[1]->adc].min_gain, adc[receiver[1]->adc].max_gain, 1.0);
+ set_rf_gain(1,value);
+ }
break;
case RIT:
vfo_rit(active_receiver->id,a->val);
}
break;
case RIT_RX1:
- vfo_rit(receiver[0]->id,a->val);
+ vfo_rit(0, a->val);
break;
case RIT_RX2:
- vfo_rit(receiver[1]->id,a->val);
+ vfo_rit(1, a->val);
break;
case RIT_STEP:
switch(a->mode) {
set_squelch(receiver[0]);
break;
case SQUELCH_RX2:
- value=KnobOrWheel(a, receiver[1]->squelch, 0.0, 100.0, 1.0);
- receiver[1]->squelch=value;
- set_squelch(receiver[1]);
+ if (receivers == 2) {
+ value=KnobOrWheel(a, receiver[1]->squelch, 0.0, 100.0, 1.0);
+ receiver[1]->squelch=value;
+ set_squelch(receiver[1]);
+ }
break;
case SWAP_RX:
if(a->mode==PRESSED) {
break;
case TUNE_DRIVE:
if(can_transmit) {
- value=KnobOrWheel(a, (double) transmitter->tune_percent, 0.0, 100.0, 1.0);
- transmitter->tune_percent=(int) value;
+ value=KnobOrWheel(a, (double) transmitter->tune_drive, 0.0, 100.0, 1.0);
+ transmitter->tune_drive=(int) value;
}
break;
case TUNE_FULL:
#endif
#include "ext.h"
#include "audio.h"
+#include "zoompan.h"
+#include "noise_menu.h"
+#include "radio_menu.h"
+#include "sliders.h"
#define DISCOVERY_PORT 4992
#define LISTEN_PORT 50000
static int audio_buffer_index=0;
AUDIO_DATA audio_data;
+static int remote_command(void * data);
GMutex accumulated_mutex;
static int accumulated_steps=0;
// dialog box?
return NULL;
}
- g_idle_add(ext_remote_command,freq_command);
+ g_idle_add(remote_command,freq_command);
}
break;
case CMD_RESP_RX_STEP:
// dialog box?
return NULL;
}
- g_idle_add(ext_remote_command,step_command);
+ g_idle_add(remote_command,step_command);
}
break;
case CMD_RESP_RX_MOVE:
// dialog box?
return NULL;
}
- g_idle_add(ext_remote_command,move_command);
+ g_idle_add(remote_command,move_command);
}
break;
case CMD_RESP_RX_MOVETO:
// dialog box?
return NULL;
}
- g_idle_add(ext_remote_command,move_to_command);
+ g_idle_add(remote_command,move_to_command);
}
break;
case CMD_RESP_RX_ZOOM:
// dialog box?
return NULL;
}
- g_idle_add(ext_remote_command,zoom_command);
+ g_idle_add(remote_command,zoom_command);
}
break;
case CMD_RESP_RX_PAN:
// dialog box?
return NULL;
}
- g_idle_add(ext_remote_command,pan_command);
+ g_idle_add(remote_command,pan_command);
}
break;
case CMD_RESP_RX_VOLUME:
// dialog box?
return NULL;
}
- g_idle_add(ext_remote_command,volume_command);
+ g_idle_add(remote_command,volume_command);
}
break;
case CMD_RESP_RX_AGC:
return NULL;
}
g_print("CMD_RESP_RX_AGC: id=%d agc=%d\n",agc_command->id,ntohs(agc_command->agc));
- g_idle_add(ext_remote_command,agc_command);
+ g_idle_add(remote_command,agc_command);
}
break;
case CMD_RESP_RX_AGC_GAIN:
// dialog box?
return NULL;
}
- g_idle_add(ext_remote_command,agc_gain_command);
+ g_idle_add(remote_command,agc_gain_command);
}
break;
case CMD_RESP_RX_GAIN:
// dialog box?
return NULL;
}
- g_idle_add(ext_remote_command,command);
+ g_idle_add(remote_command,command);
}
break;
case CMD_RESP_RX_ATTENUATION:
// dialog box?
return NULL;
}
- g_idle_add(ext_remote_command,attenuation_command);
+ g_idle_add(remote_command,attenuation_command);
}
break;
case CMD_RESP_RX_SQUELCH:
// dialog box?
return NULL;
}
- g_idle_add(ext_remote_command,squelch_command);
+ g_idle_add(remote_command,squelch_command);
}
break;
case CMD_RESP_RX_NOISE:
// dialog box?
return NULL;
}
- g_idle_add(ext_remote_command,noise_command);
+ g_idle_add(remote_command,noise_command);
}
break;
case CMD_RESP_RX_BAND:
// dialog box?
return NULL;
}
- g_idle_add(ext_remote_command,band_command);
+ g_idle_add(remote_command,band_command);
}
break;
case CMD_RESP_RX_MODE:
// dialog box?
return NULL;
}
- g_idle_add(ext_remote_command,mode_command);
+ g_idle_add(remote_command,mode_command);
}
break;
case CMD_RESP_RX_FILTER:
// dialog box?
return NULL;
}
- g_idle_add(ext_remote_command,filter_command);
+ g_idle_add(remote_command,filter_command);
}
break;
case CMD_RESP_SPLIT:
// dialog box?
return NULL;
}
- g_idle_add(ext_remote_command,split_command);
+ g_idle_add(remote_command,split_command);
}
break;
case CMD_RESP_SAT:
// dialog box?
return NULL;
}
- g_idle_add(ext_remote_command,sat_command);
+ g_idle_add(remote_command,sat_command);
}
break;
case CMD_RESP_DUP:
// dialog box?
return NULL;
}
- g_idle_add(ext_remote_command,dup_command);
+ g_idle_add(remote_command,dup_command);
}
break;
case CMD_RESP_LOCK:
// dialog box?
return NULL;
}
- g_idle_add(ext_remote_command,lock_command);
+ g_idle_add(remote_command,lock_command);
}
break;
case CMD_RESP_CTUN:
// dialog box?
return NULL;
}
- g_idle_add(ext_remote_command,ctun_command);
+ g_idle_add(remote_command,ctun_command);
}
break;
case CMD_RESP_RX_FPS:
// dialog box?
return NULL;
}
- g_idle_add(ext_remote_command,fps_command);
+ g_idle_add(remote_command,fps_command);
}
break;
case CMD_RESP_RX_SELECT:
// dialog box?
return NULL;
}
- g_idle_add(ext_remote_command,rx_select_command);
+ g_idle_add(remote_command,rx_select_command);
}
break;
case CMD_RESP_VFO:
// dialog box?
return NULL;
}
- g_idle_add(ext_remote_command,vfo_command);
+ g_idle_add(remote_command,vfo_command);
}
break;
case CMD_RESP_RIT_UPDATE:
// dialog box?
return NULL;
}
- g_idle_add(ext_remote_command,rit_update_command);
+ g_idle_add(remote_command,rit_update_command);
}
break;
case CMD_RESP_RIT_CLEAR:
// dialog box?
return NULL;
}
- g_idle_add(ext_remote_command,rit_clear_command);
+ g_idle_add(remote_command,rit_clear_command);
}
break;
case CMD_RESP_RIT:
// dialog box?
return NULL;
}
- g_idle_add(ext_remote_command,rit_command);
+ g_idle_add(remote_command,rit_command);
}
break;
case CMD_RESP_XIT_UPDATE:
xit_update_command->header.data_type=header.data_type;
xit_update_command->header.version=header.version;
xit_update_command->header.context.client=client;
- g_idle_add(ext_remote_command,xit_update_command);
+ g_idle_add(remote_command,xit_update_command);
}
break;
case CMD_RESP_XIT_CLEAR:
xit_clear_command->header.data_type=header.data_type;
xit_clear_command->header.version=header.version;
xit_clear_command->header.context.client=client;
- g_idle_add(ext_remote_command,xit_clear_command);
+ g_idle_add(remote_command,xit_clear_command);
}
break;
case CMD_RESP_XIT:
xit_command->header.data_type=header.data_type;
xit_command->header.version=header.version;
xit_command->header.context.client=client;
- g_idle_add(ext_remote_command,xit_command);
+ g_idle_add(remote_command,xit_command);
}
break;
case CMD_RESP_SAMPLE_RATE:
// dialog box?
return NULL;
}
- g_idle_add(ext_remote_command,sample_rate_command);
+ g_idle_add(remote_command,sample_rate_command);
}
break;
case CMD_RESP_RECEIVERS:
// dialog box?
return NULL;
}
- g_idle_add(ext_remote_command,receivers_command);
+ g_idle_add(remote_command,receivers_command);
}
break;
case CMD_RESP_RIT_INCREMENT:
// dialog box?
return NULL;
}
- g_idle_add(ext_remote_command,rit_increment_command);
+ g_idle_add(remote_command,rit_increment_command);
}
break;
case CMD_RESP_FILTER_BOARD:
// dialog box?
return NULL;
}
- g_idle_add(ext_remote_command,filter_board_command);
+ g_idle_add(remote_command,filter_board_command);
}
break;
case CMD_RESP_SWAP_IQ:
// dialog box?
return NULL;
}
- g_idle_add(ext_remote_command,swap_iq_command);
+ g_idle_add(remote_command,swap_iq_command);
}
break;
case CMD_RESP_REGION:
// dialog box?
return NULL;
}
- g_idle_add(ext_remote_command,region_command);
+ g_idle_add(remote_command,region_command);
}
break;
case CMD_RESP_MUTE_RX:
// dialog box?
return NULL;
}
- g_idle_add(ext_remote_command,mute_rx_command);
+ g_idle_add(remote_command,mute_rx_command);
}
break;
client_thread_id=g_thread_new("remote_client",client_thread,&server_host);
return 0;
}
+
+//
+// Execute a remote command throuth the GTK idle queue
+// and send a response.
+// Because of the response required, we cannot just
+// delegate to actions.c
+//
+
+//
+// A proper handling may be required if the "remote command" refers to
+// the second receiver while only 1 RX is present (this should probably
+// not happen, but who knows?
+// Therefore the CHECK_RX macro defined here logs such events
+//
+
+#define CHECK_RX(rx) if (rx > receivers) g_print("CHECK_RX %s:%d RX=%d > receivers=%d\n", \
+ __FUNCTION__, __LINE__, rx, receivers);
+
+static int remote_command(void *data) {
+ HEADER *header=(HEADER *)data;
+ REMOTE_CLIENT *client=header->context.client;
+ int temp;
+ switch(ntohs(header->data_type)) {
+ case CMD_RESP_RX_FREQ:
+ {
+ FREQ_COMMAND *freq_command=(FREQ_COMMAND *)data;
+ temp=active_receiver->pan;
+ int vfo=freq_command->id;
+ long long f=ntohll(freq_command->hz);
+ vfo_set_frequency(vfo,f);
+ vfo_update();
+ send_vfo_data(client,VFO_A);
+ send_vfo_data(client,VFO_B);
+ if(temp!=active_receiver->pan) {
+ send_pan(client->socket,active_receiver->id,active_receiver->pan);
+ }
+ }
+ break;
+ case CMD_RESP_RX_STEP:
+ {
+ STEP_COMMAND *step_command=(STEP_COMMAND *)data;
+ temp=active_receiver->pan;
+ short steps=ntohs(step_command->steps);
+ vfo_step(steps);
+ //send_vfo_data(client,VFO_A);
+ //send_vfo_data(client,VFO_B);
+ if(temp!=active_receiver->pan) {
+ send_pan(client->socket,active_receiver->id,active_receiver->pan);
+ }
+ }
+ break;
+ case CMD_RESP_RX_MOVE:
+ {
+ MOVE_COMMAND *move_command=(MOVE_COMMAND *)data;
+ temp=active_receiver->pan;
+ long long hz=ntohll(move_command->hz);
+ vfo_move(hz,move_command->round);
+ //send_vfo_data(client,VFO_A);
+ //send_vfo_data(client,VFO_B);
+ if(temp!=active_receiver->pan) {
+ send_pan(client->socket,active_receiver->id,active_receiver->pan);
+ }
+ }
+ break;
+ case CMD_RESP_RX_MOVETO:
+ {
+ MOVE_TO_COMMAND *move_to_command=(MOVE_TO_COMMAND *)data;
+ temp=active_receiver->pan;
+ long long hz=ntohll(move_to_command->hz);
+ vfo_move_to(hz);
+ send_vfo_data(client,VFO_A);
+ send_vfo_data(client,VFO_B);
+ if(temp!=active_receiver->pan) {
+ send_pan(client->socket,active_receiver->id,active_receiver->pan);
+ }
+ }
+ break;
+ case CMD_RESP_RX_ZOOM:
+ {
+ ZOOM_COMMAND *zoom_command=(ZOOM_COMMAND *)data;
+ temp=ntohs(zoom_command->zoom);
+ set_zoom(zoom_command->id,(double)temp);
+ send_zoom(client->socket,active_receiver->id,active_receiver->zoom);
+ send_pan(client->socket,active_receiver->id,active_receiver->pan);
+ }
+ break;
+ case CMD_RESP_RX_PAN:
+ {
+ PAN_COMMAND *pan_command=(PAN_COMMAND *)data;
+ temp=ntohs(pan_command->pan);
+ set_pan(pan_command->id,(double)temp);
+ send_pan(client->socket,active_receiver->id,active_receiver->pan);
+ }
+ break;
+ case CMD_RESP_RX_VOLUME:
+ {
+ VOLUME_COMMAND *volume_command=(VOLUME_COMMAND *)data;
+ temp=ntohs(volume_command->volume);
+ set_af_gain(volume_command->id,(double)temp/100.0);
+ }
+ break;
+ case CMD_RESP_RX_AGC:
+ {
+ AGC_COMMAND *agc_command=(AGC_COMMAND *)data;
+ int r=agc_command->id;
+ CHECK_RX(r);
+ RECEIVER *rx=receiver[r];
+ rx->agc=ntohs(agc_command->agc);
+ set_agc(rx,rx->agc);
+ send_agc(client->socket,rx->id,rx->agc);
+ g_idle_add(ext_vfo_update, NULL);
+ }
+ break;
+ case CMD_RESP_RX_AGC_GAIN:
+ {
+ AGC_GAIN_COMMAND *agc_gain_command=(AGC_GAIN_COMMAND *)data;
+ int r=agc_gain_command->id;
+ CHECK_RX(r);
+ temp=ntohs(agc_gain_command->gain);
+ set_agc_gain(r,(double)temp);
+ RECEIVER *rx=receiver[r];
+ send_agc_gain(client->socket,rx->id,(int)rx->agc_gain,(int)rx->agc_hang,(int)rx->agc_thresh);
+ }
+ break;
+ case CMD_RESP_RX_GAIN:
+ {
+ RFGAIN_COMMAND *command=(RFGAIN_COMMAND *) data;
+ double td=ntohd(command->gain);
+ set_rf_gain(command->id, td);
+ }
+ break;
+ case CMD_RESP_RX_ATTENUATION:
+ {
+ ATTENUATION_COMMAND *attenuation_command=(ATTENUATION_COMMAND *)data;
+ temp=ntohs(attenuation_command->attenuation);
+ set_attenuation(temp);
+ }
+ break;
+ case CMD_RESP_RX_SQUELCH:
+ {
+ SQUELCH_COMMAND *squelch_command=(SQUELCH_COMMAND *)data;
+ int r=squelch_command->id;
+ CHECK_RX(r);
+ receiver[r]->squelch_enable=squelch_command->enable;
+ temp=ntohs(squelch_command->squelch);
+ receiver[r]->squelch=(double)temp;
+ set_squelch(receiver[r]);
+ }
+ break;
+ case CMD_RESP_RX_NOISE:
+ {
+ NOISE_COMMAND *noise_command=(NOISE_COMMAND *)data;
+ int r=noise_command->id;
+ CHECK_RX(r);
+ RECEIVER *rx=receiver[r];
+ rx->nb=noise_command->nb;
+ rx->nb2=noise_command->nb2;
+ mode_settings[vfo[rx->id].mode].nb=rx->nb;
+ mode_settings[vfo[rx->id].mode].nb2=rx->nb2;
+ rx->nr=noise_command->nr;
+ rx->nr2=noise_command->nr2;
+ mode_settings[vfo[rx->id].mode].nr=rx->nr;
+ mode_settings[vfo[rx->id].mode].nr2=rx->nr2;
+ rx->anf=noise_command->anf;
+ mode_settings[vfo[rx->id].mode].anf=rx->anf;
+ rx->snb=noise_command->snb;
+ mode_settings[vfo[rx->id].mode].snb=rx->snb;
+ set_noise();
+ send_noise(client->socket,rx->id,rx->nb,rx->nb2,rx->nr,rx->nr2,rx->anf,rx->snb);
+ }
+ break;
+ case CMD_RESP_RX_BAND:
+ {
+ BAND_COMMAND *band_command=(BAND_COMMAND *)data;
+ int r=band_command->id;
+ CHECK_RX(r);
+ RECEIVER *rx=receiver[r];
+ short b=htons(band_command->band);
+ vfo_band_changed(r,b);
+ send_vfo_data(client,VFO_A);
+ send_vfo_data(client,VFO_B);
+ }
+ break;
+ case CMD_RESP_RX_MODE:
+ {
+ MODE_COMMAND *mode_command=(MODE_COMMAND *)data;
+ int r=mode_command->id;
+ CHECK_RX(r);
+ RECEIVER *rx=receiver[r];
+ short m=htons(mode_command->mode);
+ vfo_mode_changed(m);
+ send_vfo_data(client,VFO_A);
+ send_vfo_data(client,VFO_B);
+ send_filter(client->socket,r,m);
+ }
+ break;
+ case CMD_RESP_RX_FILTER:
+ {
+ FILTER_COMMAND *filter_command=(FILTER_COMMAND *)data;
+ int r=filter_command->id;
+ short f=htons(filter_command->filter);
+ vfo_filter_changed(f);
+ send_vfo_data(client,VFO_A);
+ send_vfo_data(client,VFO_B);
+ send_filter(client->socket,r,f);
+ }
+ break;
+ case CMD_RESP_SPLIT:
+ {
+ SPLIT_COMMAND *split_command=(SPLIT_COMMAND *)data;
+ if(can_transmit) {
+ split=split_command->split;
+ tx_set_mode(transmitter,get_tx_mode());
+ g_idle_add(ext_vfo_update, NULL);
+ }
+ send_split(client->socket,split);
+ }
+ break;
+ case CMD_RESP_SAT:
+ {
+ SAT_COMMAND *sat_command=(SAT_COMMAND *)data;
+ sat_mode=sat_command->sat;
+ g_idle_add(ext_vfo_update, NULL);
+ send_sat(client->socket,sat_mode);
+ }
+ break;
+ case CMD_RESP_DUP:
+ {
+ DUP_COMMAND *dup_command=(DUP_COMMAND *)data;
+ duplex=dup_command->dup;
+ g_idle_add(ext_vfo_update, NULL);
+ send_dup(client->socket,duplex);
+ }
+ break;
+ case CMD_RESP_LOCK:
+ {
+ LOCK_COMMAND *lock_command=(LOCK_COMMAND *)data;
+ locked=lock_command->lock;
+ g_idle_add(ext_vfo_update, NULL);
+ send_lock(client->socket,locked);
+ }
+ break;
+ case CMD_RESP_CTUN:
+ {
+ CTUN_COMMAND *ctun_command=(CTUN_COMMAND *)data;
+ int v=ctun_command->id;
+ vfo[v].ctun=ctun_command->ctun;
+ if(!vfo[v].ctun) {
+ vfo[v].offset=0;
+ }
+ vfo[v].ctun_frequency=vfo[v].frequency;
+ set_offset(active_receiver,vfo[v].offset);
+ g_idle_add(ext_vfo_update, NULL);
+ send_ctun(client->socket,v,vfo[v].ctun);
+ send_vfo_data(client,v);
+ }
+ break;
+ case CMD_RESP_RX_FPS:
+ {
+ FPS_COMMAND *fps_command=(FPS_COMMAND *)data;
+ int rx=fps_command->id;
+ CHECK_RX(rx);
+ receiver[rx]->fps=fps_command->fps;
+ calculate_display_average(receiver[rx]);
+ set_displaying(receiver[rx],1);
+ send_fps(client->socket,rx,receiver[rx]->fps);
+ }
+ break;
+ case CMD_RESP_RX_SELECT:
+ {
+ RX_SELECT_COMMAND *rx_select_command=(RX_SELECT_COMMAND *)data;
+ int rx=rx_select_command->id;
+ CHECK_RX(rx);
+ receiver_set_active(receiver[rx]);
+ send_rx_select(client->socket,rx);
+ }
+ break;
+ case CMD_RESP_VFO:
+ {
+ VFO_COMMAND *vfo_command=(VFO_COMMAND *)data;
+ int action=vfo_command->id;
+ switch(action) {
+ case VFO_A_TO_B:
+ vfo_a_to_b();
+ break;
+ case VFO_B_TO_A:
+ vfo_b_to_a();
+ break;
+ case VFO_A_SWAP_B:
+ vfo_a_swap_b();
+ break;
+ }
+ send_vfo_data(client,VFO_A);
+ send_vfo_data(client,VFO_B);
+ }
+ break;
+ case CMD_RESP_RIT_UPDATE:
+ {
+ RIT_UPDATE_COMMAND *rit_update_command=(RIT_UPDATE_COMMAND *)data;
+ int rx=rit_update_command->id;
+ vfo_rit_update(rx);
+ send_vfo_data(client,rx);
+ }
+ break;
+ case CMD_RESP_RIT_CLEAR:
+ {
+ RIT_CLEAR_COMMAND *rit_clear_command=(RIT_CLEAR_COMMAND *)data;
+ int rx=rit_clear_command->id;
+ vfo_rit_clear(rx);
+ send_vfo_data(client,rx);
+ }
+ break;
+ case CMD_RESP_RIT:
+ {
+ RIT_COMMAND *rit_command=(RIT_COMMAND *)data;
+ int rx=rit_command->id;
+ short rit=ntohs(rit_command->rit);
+ vfo_rit(rx,(int)rit);
+ send_vfo_data(client,rx);
+ }
+ break;
+ case CMD_RESP_XIT_UPDATE:
+ {
+ XIT_UPDATE_COMMAND *xit_update_command=(XIT_UPDATE_COMMAND *)data;
+ send_vfo_data(client,VFO_A);
+ send_vfo_data(client,VFO_B);
+ }
+ break;
+ case CMD_RESP_XIT_CLEAR:
+ {
+ XIT_CLEAR_COMMAND *xit_clear_command=(XIT_CLEAR_COMMAND *)data;
+ send_vfo_data(client,VFO_A);
+ send_vfo_data(client,VFO_B);
+ }
+ break;
+ case CMD_RESP_XIT:
+ {
+ XIT_COMMAND *xit_command=(XIT_COMMAND *)data;
+ short xit=ntohs(xit_command->xit);
+ send_vfo_data(client,VFO_A);
+ send_vfo_data(client,VFO_B);
+ }
+ break;
+ case CMD_RESP_SAMPLE_RATE:
+ {
+ SAMPLE_RATE_COMMAND *sample_rate_command=(SAMPLE_RATE_COMMAND *)data;
+ int rx=(int)sample_rate_command->id;
+ CHECK_RX(rx);
+ long long rate=ntohll(sample_rate_command->sample_rate);
+ if(rx==-1) {
+ radio_change_sample_rate((int)rate);
+ send_sample_rate(client->socket,-1,radio_sample_rate);
+ } else {
+ receiver_change_sample_rate(receiver[rx],(int)rate);
+ send_sample_rate(client->socket,rx,receiver[rx]->sample_rate);
+ }
+ }
+ break;
+ case CMD_RESP_RECEIVERS:
+ {
+ RECEIVERS_COMMAND *receivers_command=(RECEIVERS_COMMAND *)data;
+ int r=receivers_command->receivers;
+ radio_change_receivers(r);
+ send_receivers(client->socket,receivers);
+ }
+ break;
+ case CMD_RESP_RIT_INCREMENT:
+ {
+ RIT_INCREMENT_COMMAND *rit_increment_command=(RIT_INCREMENT_COMMAND *)data;
+ short increment=ntohs(rit_increment_command->increment);
+ rit_increment=(int)increment;
+ send_rit_increment(client->socket,rit_increment);
+ }
+ break;
+ case CMD_RESP_FILTER_BOARD:
+ {
+ FILTER_BOARD_COMMAND *filter_board_command=(FILTER_BOARD_COMMAND *)data;
+ filter_board=(int)filter_board_command->filter_board;
+ load_filters();
+ send_filter_board(client->socket,filter_board);
+ }
+ break;
+ case CMD_RESP_SWAP_IQ:
+ {
+ SWAP_IQ_COMMAND *swap_iq_command=(SWAP_IQ_COMMAND *)data;
+ iqswap=(int)swap_iq_command->iqswap;
+ send_swap_iq(client->socket,iqswap);
+ }
+ break;
+ case CMD_RESP_REGION:
+ {
+ REGION_COMMAND *region_command=(REGION_COMMAND *)data;
+ iqswap=(int)region_command->region;
+ send_region(client->socket,region);
+ }
+ break;
+ }
+ g_free(data);
+ return 0;
+}
#include "receiver.h"
#include "sliders.h"
#include "toolbar.h"
-#include "band_menu.h"
-#include "diversity_menu.h"
#include "vfo.h"
#include "radio.h"
#include "radio_menu.h"
#include "new_menu.h"
-#include "new_protocol.h"
-#ifdef PURESIGNAL
-#include "ps_menu.h"
-#endif
-#include "agc.h"
-#include "filter.h"
-#include "mode.h"
-#include "band.h"
-#include "bandstack.h"
#include "noise_menu.h"
-#include "wdsp.h"
-#ifdef CLIENT_SERVER
-#include "client_server.h"
-#endif
#include "ext.h"
#include "zoompan.h"
#include "equalizer_menu.h"
-#include "store.h"
// The following calls functions can be called usig g_idle_add
return 0;
}
-#ifdef CLIENT_SERVER
-//
-// Execute a remote command and send a response.
-// Because of the response required, we cannot just
-// delegate to actions.c
-//
-int ext_remote_command(void *data) {
- HEADER *header=(HEADER *)data;
- REMOTE_CLIENT *client=header->context.client;
- int temp;
- switch(ntohs(header->data_type)) {
- case CMD_RESP_RX_FREQ:
- {
- FREQ_COMMAND *freq_command=(FREQ_COMMAND *)data;
- temp=active_receiver->pan;
- int vfo=freq_command->id;
- long long f=ntohll(freq_command->hz);
- vfo_set_frequency(vfo,f);
- vfo_update();
- send_vfo_data(client,VFO_A);
- send_vfo_data(client,VFO_B);
- if(temp!=active_receiver->pan) {
- send_pan(client->socket,active_receiver->id,active_receiver->pan);
- }
- }
- break;
- case CMD_RESP_RX_STEP:
- {
- STEP_COMMAND *step_command=(STEP_COMMAND *)data;
- temp=active_receiver->pan;
- short steps=ntohs(step_command->steps);
- vfo_step(steps);
- //send_vfo_data(client,VFO_A);
- //send_vfo_data(client,VFO_B);
- if(temp!=active_receiver->pan) {
- send_pan(client->socket,active_receiver->id,active_receiver->pan);
- }
- }
- break;
- case CMD_RESP_RX_MOVE:
- {
- MOVE_COMMAND *move_command=(MOVE_COMMAND *)data;
- temp=active_receiver->pan;
- long long hz=ntohll(move_command->hz);
- vfo_move(hz,move_command->round);
- //send_vfo_data(client,VFO_A);
- //send_vfo_data(client,VFO_B);
- if(temp!=active_receiver->pan) {
- send_pan(client->socket,active_receiver->id,active_receiver->pan);
- }
- }
- break;
- case CMD_RESP_RX_MOVETO:
- {
- MOVE_TO_COMMAND *move_to_command=(MOVE_TO_COMMAND *)data;
- temp=active_receiver->pan;
- long long hz=ntohll(move_to_command->hz);
- vfo_move_to(hz);
- send_vfo_data(client,VFO_A);
- send_vfo_data(client,VFO_B);
- if(temp!=active_receiver->pan) {
- send_pan(client->socket,active_receiver->id,active_receiver->pan);
- }
- }
- break;
- case CMD_RESP_RX_ZOOM:
- {
- ZOOM_COMMAND *zoom_command=(ZOOM_COMMAND *)data;
- temp=ntohs(zoom_command->zoom);
- set_zoom(zoom_command->id,(double)temp);
- send_zoom(client->socket,active_receiver->id,active_receiver->zoom);
- send_pan(client->socket,active_receiver->id,active_receiver->pan);
- }
- break;
- case CMD_RESP_RX_PAN:
- {
- PAN_COMMAND *pan_command=(PAN_COMMAND *)data;
- temp=ntohs(pan_command->pan);
- set_pan(pan_command->id,(double)temp);
- send_pan(client->socket,active_receiver->id,active_receiver->pan);
- }
- break;
- case CMD_RESP_RX_VOLUME:
- {
- VOLUME_COMMAND *volume_command=(VOLUME_COMMAND *)data;
- temp=ntohs(volume_command->volume);
- set_af_gain(volume_command->id,(double)temp/100.0);
- }
- break;
- case CMD_RESP_RX_AGC:
- {
- AGC_COMMAND *agc_command=(AGC_COMMAND *)data;
- RECEIVER *rx=receiver[agc_command->id];
- rx->agc=ntohs(agc_command->agc);
- set_agc(rx,rx->agc);
- send_agc(client->socket,rx->id,rx->agc);
- g_idle_add(ext_vfo_update, NULL);
- }
- break;
- case CMD_RESP_RX_AGC_GAIN:
- {
- AGC_GAIN_COMMAND *agc_gain_command=(AGC_GAIN_COMMAND *)data;
- temp=ntohs(agc_gain_command->gain);
- set_agc_gain(agc_gain_command->id,(double)temp);
- RECEIVER *rx=receiver[agc_gain_command->id];
- send_agc_gain(client->socket,rx->id,(int)rx->agc_gain,(int)rx->agc_hang,(int)rx->agc_thresh);
- }
- break;
- case CMD_RESP_RX_GAIN:
- {
- RFGAIN_COMMAND *command=(RFGAIN_COMMAND *) data;
- double td=ntohd(command->gain);
- set_rf_gain(command->id, td);
- }
- break;
- case CMD_RESP_RX_ATTENUATION:
- {
- ATTENUATION_COMMAND *attenuation_command=(ATTENUATION_COMMAND *)data;
- temp=ntohs(attenuation_command->attenuation);
- set_attenuation(temp);
- }
- break;
- case CMD_RESP_RX_SQUELCH:
- {
- SQUELCH_COMMAND *squelch_command=(SQUELCH_COMMAND *)data;
- receiver[squelch_command->id]->squelch_enable=squelch_command->enable;
- temp=ntohs(squelch_command->squelch);
- receiver[squelch_command->id]->squelch=(double)temp;
- set_squelch(receiver[squelch_command->id]);
- }
- break;
- case CMD_RESP_RX_NOISE:
- {
- NOISE_COMMAND *noise_command=(NOISE_COMMAND *)data;
- RECEIVER *rx=receiver[noise_command->id];
- rx->nb=noise_command->nb;
- rx->nb2=noise_command->nb2;
- mode_settings[vfo[rx->id].mode].nb=rx->nb;
- mode_settings[vfo[rx->id].mode].nb2=rx->nb2;
- rx->nr=noise_command->nr;
- rx->nr2=noise_command->nr2;
- mode_settings[vfo[rx->id].mode].nr=rx->nr;
- mode_settings[vfo[rx->id].mode].nr2=rx->nr2;
- rx->anf=noise_command->anf;
- mode_settings[vfo[rx->id].mode].anf=rx->anf;
- rx->snb=noise_command->snb;
- mode_settings[vfo[rx->id].mode].snb=rx->snb;
- set_noise();
- send_noise(client->socket,rx->id,rx->nb,rx->nb2,rx->nr,rx->nr2,rx->anf,rx->snb);
- }
- break;
- case CMD_RESP_RX_BAND:
- {
- BAND_COMMAND *band_command=(BAND_COMMAND *)data;
- RECEIVER *rx=receiver[band_command->id];
- short b=htons(band_command->band);
- vfo_band_changed(rx->id,b);
- send_vfo_data(client,VFO_A);
- send_vfo_data(client,VFO_B);
- }
- break;
- case CMD_RESP_RX_MODE:
- {
- MODE_COMMAND *mode_command=(MODE_COMMAND *)data;
- RECEIVER *rx=receiver[mode_command->id];
- short m=htons(mode_command->mode);
- vfo_mode_changed(m);
- send_vfo_data(client,VFO_A);
- send_vfo_data(client,VFO_B);
- send_filter(client->socket,rx->id,m);
- }
- break;
- case CMD_RESP_RX_FILTER:
- {
- FILTER_COMMAND *filter_command=(FILTER_COMMAND *)data;
- RECEIVER *rx=receiver[filter_command->id];
- short f=htons(filter_command->filter);
- vfo_filter_changed(f);
- send_vfo_data(client,VFO_A);
- send_vfo_data(client,VFO_B);
- send_filter(client->socket,rx->id,f);
- }
- break;
- case CMD_RESP_SPLIT:
- {
- SPLIT_COMMAND *split_command=(SPLIT_COMMAND *)data;
- if(can_transmit) {
- split=split_command->split;
- tx_set_mode(transmitter,get_tx_mode());
- g_idle_add(ext_vfo_update, NULL);
- }
- send_split(client->socket,split);
- }
- break;
- case CMD_RESP_SAT:
- {
- SAT_COMMAND *sat_command=(SAT_COMMAND *)data;
- sat_mode=sat_command->sat;
- g_idle_add(ext_vfo_update, NULL);
- send_sat(client->socket,sat_mode);
- }
- break;
- case CMD_RESP_DUP:
- {
- DUP_COMMAND *dup_command=(DUP_COMMAND *)data;
- duplex=dup_command->dup;
- g_idle_add(ext_vfo_update, NULL);
- send_dup(client->socket,duplex);
- }
- break;
- case CMD_RESP_LOCK:
- {
- LOCK_COMMAND *lock_command=(LOCK_COMMAND *)data;
- locked=lock_command->lock;
- g_idle_add(ext_vfo_update, NULL);
- send_lock(client->socket,locked);
- }
- break;
- case CMD_RESP_CTUN:
- {
- CTUN_COMMAND *ctun_command=(CTUN_COMMAND *)data;
- int v=ctun_command->id;
- vfo[v].ctun=ctun_command->ctun;
- if(!vfo[v].ctun) {
- vfo[v].offset=0;
- }
- vfo[v].ctun_frequency=vfo[v].frequency;
- set_offset(active_receiver,vfo[v].offset);
- g_idle_add(ext_vfo_update, NULL);
- send_ctun(client->socket,v,vfo[v].ctun);
- send_vfo_data(client,v);
- }
- break;
- case CMD_RESP_RX_FPS:
- {
- FPS_COMMAND *fps_command=(FPS_COMMAND *)data;
- int rx=fps_command->id;
- receiver[rx]->fps=fps_command->fps;
- calculate_display_average(receiver[rx]);
- set_displaying(receiver[rx],1);
- send_fps(client->socket,rx,receiver[rx]->fps);
- }
- break;
- case CMD_RESP_RX_SELECT:
- {
- RX_SELECT_COMMAND *rx_select_command=(RX_SELECT_COMMAND *)data;
- int rx=rx_select_command->id;
- receiver_set_active(receiver[rx]);
- send_rx_select(client->socket,rx);
- }
- break;
- case CMD_RESP_VFO:
- {
- VFO_COMMAND *vfo_command=(VFO_COMMAND *)data;
- int action=vfo_command->id;
- switch(action) {
- case VFO_A_TO_B:
- vfo_a_to_b();
- break;
- case VFO_B_TO_A:
- vfo_b_to_a();
- break;
- case VFO_A_SWAP_B:
- vfo_a_swap_b();
- break;
- }
- send_vfo_data(client,VFO_A);
- send_vfo_data(client,VFO_B);
- }
- break;
- case CMD_RESP_RIT_UPDATE:
- {
- RIT_UPDATE_COMMAND *rit_update_command=(RIT_UPDATE_COMMAND *)data;
- int rx=rit_update_command->id;
- vfo_rit_update(rx);
- send_vfo_data(client,rx);
- }
- break;
- case CMD_RESP_RIT_CLEAR:
- {
- RIT_CLEAR_COMMAND *rit_clear_command=(RIT_CLEAR_COMMAND *)data;
- int rx=rit_clear_command->id;
- vfo_rit_clear(rx);
- send_vfo_data(client,rx);
- }
- break;
- case CMD_RESP_RIT:
- {
- RIT_COMMAND *rit_command=(RIT_COMMAND *)data;
- int rx=rit_command->id;
- short rit=ntohs(rit_command->rit);
- vfo_rit(rx,(int)rit);
- send_vfo_data(client,rx);
- }
- break;
- case CMD_RESP_XIT_UPDATE:
- {
- XIT_UPDATE_COMMAND *xit_update_command=(XIT_UPDATE_COMMAND *)data;
- send_vfo_data(client,VFO_A);
- send_vfo_data(client,VFO_B);
- }
- break;
- case CMD_RESP_XIT_CLEAR:
- {
- XIT_CLEAR_COMMAND *xit_clear_command=(XIT_CLEAR_COMMAND *)data;
- send_vfo_data(client,VFO_A);
- send_vfo_data(client,VFO_B);
- }
- break;
- case CMD_RESP_XIT:
- {
- XIT_COMMAND *xit_command=(XIT_COMMAND *)data;
- short xit=ntohs(xit_command->xit);
- send_vfo_data(client,VFO_A);
- send_vfo_data(client,VFO_B);
- }
- break;
- case CMD_RESP_SAMPLE_RATE:
- {
- SAMPLE_RATE_COMMAND *sample_rate_command=(SAMPLE_RATE_COMMAND *)data;
- int rx=(int)sample_rate_command->id;
- long long rate=ntohll(sample_rate_command->sample_rate);
- if(rx==-1) {
- radio_change_sample_rate((int)rate);
- send_sample_rate(client->socket,-1,radio_sample_rate);
- } else {
- receiver_change_sample_rate(receiver[rx],(int)rate);
- send_sample_rate(client->socket,rx,receiver[rx]->sample_rate);
- }
- }
- break;
- case CMD_RESP_RECEIVERS:
- {
- RECEIVERS_COMMAND *receivers_command=(RECEIVERS_COMMAND *)data;
- int r=receivers_command->receivers;
- radio_change_receivers(r);
- send_receivers(client->socket,receivers);
- }
- break;
- case CMD_RESP_RIT_INCREMENT:
- {
- RIT_INCREMENT_COMMAND *rit_increment_command=(RIT_INCREMENT_COMMAND *)data;
- short increment=ntohs(rit_increment_command->increment);
- rit_increment=(int)increment;
- send_rit_increment(client->socket,rit_increment);
- }
- break;
- case CMD_RESP_FILTER_BOARD:
- {
- FILTER_BOARD_COMMAND *filter_board_command=(FILTER_BOARD_COMMAND *)data;
- filter_board=(int)filter_board_command->filter_board;
- load_filters();
- send_filter_board(client->socket,filter_board);
- }
- break;
- case CMD_RESP_SWAP_IQ:
- {
- SWAP_IQ_COMMAND *swap_iq_command=(SWAP_IQ_COMMAND *)data;
- iqswap=(int)swap_iq_command->iqswap;
- send_swap_iq(client->socket,iqswap);
- }
- break;
- case CMD_RESP_REGION:
- {
- REGION_COMMAND *region_command=(REGION_COMMAND *)data;
- iqswap=(int)region_command->region;
- send_region(client->socket,region);
- }
- break;
- }
- g_free(data);
- return 0;
-}
-
int ext_receiver_remote_update_display(void *data) {
RECEIVER *rx=(RECEIVER *)data;
receiver_remote_update_display(rx);
gtk_window_set_title(GTK_WINDOW(top_window),(char *)data);
return 0;
}
-#endif
}
-void filter_width_changed(int rx,int increment) {
- int id=receiver[rx]->id;
+void filter_width_changed(int id,int increment) {
FILTER *mode_filters=filters[vfo[id].mode];
FILTER *filter=&mode_filters[vfo[id].filter];
-fprintf(stderr,"filter_width_changed: rx=%d mode=%d filter=%d increment=%d\n",rx,vfo[id].mode,vfo[id].filter,increment);
+fprintf(stderr,"filter_width_changed: rx=%d mode=%d filter=%d increment=%d\n",id,vfo[id].mode,vfo[id].filter,increment);
if(vfo[id].filter==filterVar1 || vfo[id].filter==filterVar2) {
}
}
-void filter_shift_changed(int rx,int increment) {
- int id=receiver[rx]->id;
+void filter_shift_changed(int id,int increment) {
FILTER *mode_filters=filters[vfo[id].mode];
FILTER *filter=&mode_filters[vfo[id].filter];
-fprintf(stderr,"filter_shift_changed: rx=%d mode=%d filter=%d increment=%d\n",rx,vfo[id].mode,vfo[id].filter,increment);
+fprintf(stderr,"filter_shift_changed: rx=%d mode=%d filter=%d increment=%d\n",id,vfo[id].mode,vfo[id].filter,increment);
if(vfo[id].filter==filterVar1 || vfo[id].filter==filterVar2) {
switch(vfo[id].mode) {
high_priority_buffer_to_radio[331]=phase>>8;
high_priority_buffer_to_radio[332]=phase;
- int power=0;
- if (xmit) {
- if(tune && !transmitter->tune_use_drive) {
- double fac=sqrt((double)transmitter->tune_percent * 0.01);
- power=(int)((double)transmitter->drive_level*fac);
- } else {
- power=transmitter->drive_level;
- }
- }
+ int power=transmitter->drive_level;
high_priority_buffer_to_radio[345]=power&0xFF;
alex_reverse_power_average = (alex_reverse_power + 3*alex_reverse_power_average) >> 2;
supply_volts=((buffer[49]&0xFF)<<8)|(buffer[50]&0xFF);
- // Stops CAT cw transmission if paddle hit
+ // Stops CAT cw transmission if radio reports "CW action"
if (dash || dot) {
CAT_cw_is_active=0;
cw_key_hit=1;
if (dash != previous_dash) keyer_event(0, dash);
if (dot != previous_dot ) keyer_event(1, dot );
}
+#else
+ //
+ // Note that if an external keyer is connected to the "CW" jack of
+ // the ANAN-7000, it will report its state via the "dot" state
+ // so we can do CW directly. Only act on dot state changes so we
+ // do not intervene with CAT CW.
+ //
+ if (!cw_keyer_internal && dot != previous_dot) {
+ cw_key_down=dot ? 960000 : 0;
+ }
#endif
if(previous_ptt!=local_ptt) {
dash=(control_in[0]&0x02)==0x02;
dot=(control_in[0]&0x04)==0x04;
- // Stops CAT cw transmission if paddle hit in "internal" CW
+ // Stops CAT cw transmission if radio reports "CW action"
if (dash || dot) {
cw_key_hit=1;
CAT_cw_is_active=0;
if (dash != previous_dash) keyer_event(0, dash);
if (dot != previous_dot ) keyer_event(1, dot );
}
+#else
+ //
+ // Note that if an external keyer is connected to the "CW" jack of
+ // the ANAN-7000, it will report its state via the "dot" state
+ // so we can do CW directly. Only act on dot state changes so we
+ // do not intervene with CAT CW.
+ //
+ if (!cw_keyer_internal && dot != previous_dot) {
+ cw_key_down=dot ? 960000 : 0;
+ }
#endif
if(previous_ptt!=local_ptt) {
break;
}
- output_buffer[C4]=0x04; // duplex
+ //
+ // ALWAYS set the duplex bit "on". This bit indicates to the
+ // FPGA that the TX frequency can be different from the RX
+ // frequency, which is the case with Split, XIT, CTUN
+ //
+ output_buffer[C4]=0x04;
//
// This is used to phase-synchronize RX1 and RX2 on some boards
// and enforces that the RX1 and RX2 frequencies are the same.
// (it would be sufficient to do so only with internal CW).
//
if(isTransmitting() || (txmode == modeCWU) || (txmode == modeCWL)) {
- if(tune && !transmitter->tune_use_drive) {
- double fac=sqrt((double)transmitter->tune_percent * 0.01);
- power=(int)((double)transmitter->drive_level*fac);
- } else {
- power=transmitter->drive_level;
- }
+ power=transmitter->drive_level;
if (device == DEVICE_HERMES_LITE2) {
//
// from the "intended" drive level power, calculate the
set_displaying(receiver[0],0);
g_print("radio_stop: RX0: CloseChannel: %d\n",receiver[0]->id);
CloseChannel(receiver[0]->id);
- set_displaying(receiver[1],0);
+ if (RECEIVERS == 2) {
+ set_displaying(receiver[1],0);
g_print("radio_stop: RX1: CloseChannel: %d\n",receiver[1]->id);
- CloseChannel(receiver[1]->id);
+ CloseChannel(receiver[1]->id);
+ }
}
void reconfigure_radio() {
g_print("radio_change_receivers: from %d to %d\n",receivers,r);
// The button in the radio menu will call this function even if the
// number of receivers has not changed.
- if (receivers == r) return;
+ if (receivers == r) return; // This is always the case if RECEIVERS==1
//
// When changing the number of receivers, restart the
// old protocol
tx_set_mode(transmitter,modeUSB);
break;
}
+ tune=state;
+ calcDriveLevel();
rxtx(state);
} else {
rxtx(state);
//
SetPSControl(transmitter->id, 0, 0, 1, 0);
}
+ tune=state;
+ calcDriveLevel();
}
- tune=state;
}
if(protocol==NEW_PROTOCOL) {
schedule_high_priority();
}
void calcDriveLevel() {
- transmitter->drive_level=calcLevel(transmitter->drive);
+ if (tune && !transmitter->tune_use_drive) {
+ transmitter->drive_level=calcLevel(transmitter->tune_drive);
+g_print("calcDriveLevel: tune=%d drive_level=%d\n",transmitter->tune_drive,transmitter->drive_level);
+ } else {
+ transmitter->drive_level=calcLevel(transmitter->drive);
+g_print("calcDriveLevel: drive=%d drive_level=%d\n",transmitter->drive,transmitter->drive_level);
+ }
if(isTransmitting() && protocol==NEW_PROTOCOL) {
schedule_high_priority();
}
-//g_print("calcDriveLevel: drive=%d drive_level=%d\n",transmitter->drive,transmitter->drive_level);
}
void setDrive(double value) {
}
double getTuneDrive() {
- return transmitter->tune_percent;
+ return transmitter->tune_drive;
}
void setSquelch(RECEIVER *rx) {
gpio_save_actions();
sprintf(value,"%d",receivers);
setProperty("receivers",value);
- for(i=0;i<receivers;i++) {
+ for(i=0;i<RECEIVERS;i++) {
receiver_save_state(receiver[i]);
}
int id=rx->id;
if(vfo[id].ctun) {
- int ctun_ok=1;
long long frequency=vfo[id].frequency;
long long half=(long long)rx->sample_rate/2LL;
long long rx_low=vfo[id].ctun_frequency+rx->filter_low;
//
// Perhaps this is paranoia, but a "legal" VFO might turn
// into an "illegal" when when reducing the sample rate,
- // thus narrowing the CTUN window
+ // thus narrowing the CTUN window.
+ // If the "filter window" has left the CTUN range, CTUN is
+ // reset such that the CTUN center frequency is placed at
+ // the new frequency
//
g_print("%s: CTUN freq out of range\n", __FUNCTION__);
vfo[id].frequency=vfo[id].ctun_frequency;
- ctun_ok=0;
}
if(rx->zoom>1) {
//
// Adjust PAN if new filter width has moved out of
// current display range
+ // TODO: what if this happens with CTUN "off"?
//
long long min_display=frequency-half+(long long)((double)rx->pan*rx->hz_per_pixel);
long long max_display=min_display+(long long)((double)rx->width*rx->hz_per_pixel);
}
//
- // Compute new offset and tell WDSP about it
+ // Compute new offset
//
vfo[id].offset=vfo[id].ctun_frequency-vfo[id].frequency;
if(vfo[id].rit_enabled) {
vfo[id].offset+=vfo[id].rit;
}
- set_offset(rx,vfo[id].offset);
+ } else {
//
- // If we have changed the CTUN center frequency,
- // we cannot return but must tell the radio about it
+ // This may be part of a CTUN ON->OFF transition
//
- if (ctun_ok) return;
+ vfo[id].offset=0;
+ if(vfo[id].rit_enabled) {
+ vfo[id].offset=vfo[id].rit;
+ }
}
+ //
+ // To make this bullet-proof, report the (possibly new) offset to WDSP
+ // and send the (possibly changed) frequency to the radio in any case.
+ //
+ set_offset(rx,vfo[id].offset);
switch(protocol) {
case ORIGINAL_PROTOCOL:
// P1 does this automatically
tx_set_filter(transmitter);
}
}
+ //
+ // TODO: Filter window has possibly moved outside CTUN range
+ //
}
void receiver_mode_changed(RECEIVER *rx) {
int rigctl_port_base=19090;
int rigctl_enable=0;
-// the port client will be connecting to
-// 2-26-17 K5JAE - Changed the defines to const ints to allow use via pointers.
-static const int TelnetPortA = 19090;
-static const int TelnetPortB = 19091;
-static const int TelnetPortC = 19092;
-
#define RIGCTL_THROTTLE_NSEC 15000000L
#define NSEC_PER_SEC 1000000000L
int threshold=atoi(&command[4]);
set_agc_gain(VFO_B,(double)threshold);
}
+ } else {
+ implemented=FALSE;
}
break;
case 'T': //ZZAT
if(command[4]==';') {
if(receivers==2) {
band_minus(receiver[1]->id);
+ } else {
+ implemented=FALSE;
}
}
break;
if(command[4]==';') {
if(receivers==2) {
band_plus(receiver[1]->id);
+ } else {
+ implemented=FALSE;
}
}
break;
break;
case 'U': //ZZGU
// set/read RX2 AGC
- if(command[4]==';') {
- sprintf(reply,"ZZGU%d;",receiver[1]->agc);
- send_resp(client->fd,reply) ;
- } else if(command[5]==';') {
- int agc=atoi(&command[4]);
- // update RX2 AGC
- receiver[1]->agc=agc;
- g_idle_add(ext_vfo_update,NULL);
+ if (receivers == 2) {
+ if(command[4]==';') {
+ sprintf(reply,"ZZGU%d;",receiver[1]->agc);
+ send_resp(client->fd,reply) ;
+ } else if(command[5]==';') {
+ int agc=atoi(&command[4]);
+ // update RX2 AGC
+ receiver[1]->agc=agc;
+ g_idle_add(ext_vfo_update,NULL);
+ }
+ } else {
+ implemented=FALSE;
}
break;
default:
receiver[1]->volume=(double)gain/100.0;
update_af_gain();
}
+ } else {
+ implemented=FALSE;
}
break;
case 'D': //ZZLD
break;
case 'C': //ZZNC
// set/read RX2 NB1
- if(command[4]==';') {
- sprintf(reply,"ZZNC%d;",receiver[1]->nb);
- send_resp(client->fd,reply);
- } else if(command[5]==';') {
- receiver[1]->nb=atoi(&command[4]);
- if(receiver[1]->nb) {
+ if (receivers == 2) {
+ if(command[4]==';') {
+ sprintf(reply,"ZZNC%d;",receiver[1]->nb);
+ send_resp(client->fd,reply);
+ } else if(command[5]==';') {
+ receiver[1]->nb=atoi(&command[4]);
+ if(receiver[1]->nb) {
receiver[1]->nb2=0;
+ }
+ update_noise();
}
- update_noise();
+ } else {
+ implemented=FALSE;
}
break;
case 'D': //ZZND
// set/read RX2 NB2
- if(command[4]==';') {
- sprintf(reply,"ZZND%d;",receiver[1]->nb2);
- send_resp(client->fd,reply);
- } else if(command[5]==';') {
- receiver[1]->nb2=atoi(&command[4]);
- if(receiver[1]->nb2) {
- receiver[1]->nb=0;
+ if (receivers == 2) {
+ if(command[4]==';') {
+ sprintf(reply,"ZZND%d;",receiver[1]->nb2);
+ send_resp(client->fd,reply);
+ } else if(command[5]==';') {
+ receiver[1]->nb2=atoi(&command[4]);
+ if(receiver[1]->nb2) {
+ receiver[1]->nb=0;
+ }
+ update_noise();
}
- update_noise();
+ } else {
+ implemented=FALSE;
}
break;
case 'L': //ZZNL
break;
case 'O': //ZZNO
// set/read RX2 SNB status
- if(command[4]==';') {
- sprintf(reply,"ZZNO%d;",receiver[1]->snb);
- send_resp(client->fd,reply);
- } else if(command[5]==';') {
- receiver[1]->snb=atoi(&command[4]);
- update_noise();
+ if (receivers == 2){
+ if(command[4]==';') {
+ sprintf(reply,"ZZNO%d;",receiver[1]->snb);
+ send_resp(client->fd,reply);
+ } else if(command[5]==';') {
+ receiver[1]->snb=atoi(&command[4]);
+ update_noise();
+ }
+ } else {
+ implemented=FALSE;
}
break;
case 'R': //ZZNR
// set/read RX1 NR
- if(command[4]==';') {
- sprintf(reply,"ZZNR%d;",receiver[0]->nr);
- send_resp(client->fd,reply);
- } else if(command[5]==';') {
- receiver[0]->nr=atoi(&command[4]);
- if(receiver[0]->nr) {
- receiver[0]->nr2=0;
+ if (receivers == 2){
+ if(command[4]==';') {
+ sprintf(reply,"ZZNR%d;",receiver[0]->nr);
+ send_resp(client->fd,reply);
+ } else if(command[5]==';') {
+ receiver[0]->nr=atoi(&command[4]);
+ if(receiver[0]->nr) {
+ receiver[0]->nr2=0;
+ }
+ update_noise();
}
- update_noise();
}
break;
case 'S': //ZZNS
break;
case 'U': //ZZNU
// set/read RX2 ANF
- if(command[4]==';') {
- sprintf(reply,"ZZNU%d;",receiver[1]->anf);
- send_resp(client->fd,reply);
- } else if(command[5]==';') {
- receiver[1]->anf=atoi(&command[4]);
- update_noise();
+ if (receivers == 2) {
+ if(command[4]==';') {
+ sprintf(reply,"ZZNU%d;",receiver[1]->anf);
+ send_resp(client->fd,reply);
+ } else if(command[5]==';') {
+ receiver[1]->anf=atoi(&command[4]);
+ update_noise();
+ }
+ } else {
+ implemented=FALSE;
}
break;
case 'V': //ZZNV
// set/read RX2 NR
- if(command[4]==';') {
- sprintf(reply,"ZZNV%d;",receiver[1]->nr);
- send_resp(client->fd,reply);
- } else if(command[5]==';') {
- receiver[1]->nr=atoi(&command[4]);
- if(receiver[1]->nr) {
- receiver[1]->nr2=0;
+ if (receivers == 2) {
+ if(command[4]==';') {
+ sprintf(reply,"ZZNV%d;",receiver[1]->nr);
+ send_resp(client->fd,reply);
+ } else if(command[5]==';') {
+ receiver[1]->nr=atoi(&command[4]);
+ if(receiver[1]->nr) {
+ receiver[1]->nr2=0;
+ }
+ update_noise();
}
- update_noise();
+ } else {
+ implemented=FALSE;
}
break;
case 'W': //ZZNW
// set/read RX2 NR2
- if(command[4]==';') {
- sprintf(reply,"ZZNW%d;",receiver[1]->nr2);
- send_resp(client->fd,reply);
- } else if(command[5]==';') {
- receiver[1]->nr2=atoi(&command[4]);
- if(receiver[1]->nr2) {
- receiver[1]->nr=0;
+ if (receivers == 2) {
+ if(command[4]==';') {
+ sprintf(reply,"ZZNW%d;",receiver[1]->nr2);
+ send_resp(client->fd,reply);
+ } else if(command[5]==';') {
+ receiver[1]->nr2=atoi(&command[4]);
+ if(receiver[1]->nr2) {
+ receiver[1]->nr=0;
+ }
+ update_noise();
}
- update_noise();
+ } else {
+ implemented=FALSE;
}
break;
default:
// reads the S Meter (in dB)
if(command[5]==';') {
int v=atoi(&command[4]);
- if(v==VFO_A || v==VFO_B) {
+ if(v >= 0 && v < receivers) {
double m=receiver[v]->meter;
m=fmax(-140.0,m);
m=fmin(-10.0,m);
sprintf(reply,"ZZSM%d%03d;",v,(int)((m+140.0)*2));
send_resp(client->fd,reply);
+ } else {
+ implemented=FALSE;
}
}
break;
sprintf(reply,"ZZXO%04d;",status);
send_resp(client->fd,reply);
}
+ } else {
+ implemented=FALSE;
}
break;
case 'S': //ZZXS
// switch receivers
if(command[5]==';') {
int v=atoi(&command[4]);
- if(v==0) {
- active_receiver=receiver[0];
- } else if(v==1) {
- if(receivers==2) {
- active_receiver=receiver[1];
- }
+ if(v >= 0 && v < receivers) {
+ active_receiver=receiver[v];
+ } else {
+ implemented=FALSE;
}
g_idle_add(ext_vfo_update,NULL);
}
send_resp(client->fd,reply) ;
} else if(command[3]==';') {
int id=atoi(&command[2]);
- switch(id) {
- case 0:
+ if (id >= 0 && id < receivers) {
active_receiver=receiver[id];
- break;
- case 1:
- if(receivers==2) {
- active_receiver=receiver[id];
- } else {
- implemented=FALSE;
- }
- break;
- default:
+ } else {
implemented=FALSE;
- break;
}
g_idle_add(ext_vfo_update, NULL);
}
// read the S meter
if(command[3]==';') {
int id=atoi(&command[2]);
- if(id==0 || id==1) {
+ if(id >= 0 && id < receivers) {
sprintf(reply,"SM%04d;",(int)receiver[id]->meter);
send_resp(client->fd,reply);
+ } else {
+ implemented=FALSE;
}
}
break;
void set_agc_gain(int rx,double value) {
g_print("%s\n",__FUNCTION__);
+ if (rx >= receivers) return;
receiver[rx]->agc_gain=value;
set_agc(receiver[rx], receiver[rx]->agc);
if(display_sliders) {
}
void set_af_gain(int rx,double value) {
+ if (rx >= receivers) return;
receiver[rx]->volume=value;
SetRXAPanelGain1 (receiver[rx]->id, receiver[rx]->volume);
if(display_sliders) {
}
void set_rf_gain(int rx,double value) {
+ if (rx >= receivers) return;
int rxadc=receiver[rx]->adc;
g_print("%s rx=%d adc=%d val=%f\n",__FUNCTION__, rx, rxadc, value);
if (!have_rx_gain) {
sprintf(name,"transmitter.%d.drive",tx->id);
sprintf(value,"%d",tx->drive);
setProperty(name,value);
- sprintf(name,"transmitter.%d.tune_percent",tx->id);
- sprintf(value,"%d",tx->tune_percent);
+ sprintf(name,"transmitter.%d.tune_drive",tx->id);
+ sprintf(value,"%d",tx->tune_drive);
setProperty(name,value);
sprintf(name,"transmitter.%d.tune_use_drive",tx->id);
sprintf(value,"%d",tx->tune_use_drive);
sprintf(name,"transmitter.%d.drive",tx->id);
value=getProperty(name);
if(value) tx->drive=atoi(value);
- sprintf(name,"transmitter.%d.tune_percent",tx->id);
+ sprintf(name,"transmitter.%d.tune_drive",tx->id);
value=getProperty(name);
- if(value) tx->tune_percent=atoi(value);
+ if(value) tx->tune_drive=atoi(value);
sprintf(name,"transmitter.%d.tune_use_drive",tx->id);
value=getProperty(name);
if(value) tx->tune_use_drive=atoi(value);
tx->am_carrier_level=0.5;
tx->drive=50;
- tx->tune_percent=10;
+ tx->tune_drive=10;
tx->tune_use_drive=0;
tx->compressor=0;
//
// "The magic factor" 0.00392 is slightly less than 1/255.
//
- if(tune && !tx->tune_use_drive) {
- double fac=sqrt((double)tx->tune_percent * 0.01);
- gain=gain*(double)tx->drive_level*fac*0.00392;
- } else {
- gain=gain*(double)tx->drive_level*0.00392;
- }
+ gain=gain*(double)tx->drive_level*0.00392;
}
if (txflag == 0 && protocol == NEW_PROTOCOL) {
int drive;
int tune_use_drive;
- int tune_percent;
+ int tune_drive;
int drive_level;
transmitter->tune_use_drive=gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget));
}
-static void tune_percent_cb (GtkWidget *widget, gpointer data) {
- transmitter->tune_percent=gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(widget));
+static void tune_drive_cb (GtkWidget *widget, gpointer data) {
+ transmitter->tune_drive=gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(widget));
}
static void swr_protection_cb (GtkWidget *widget, gpointer data) {
return FALSE;
}
-/*
-static void tune_value_changed_cb(GtkWidget *widget, gpointer data) {
- setTuneDrive(gtk_range_get_value(GTK_RANGE(tune_scale)));
-}
-*/
-
void tx_menu(GtkWidget *parent) {
int i;
char temp[32];
col++;
- GtkWidget *tune_percent_label=gtk_label_new(NULL);
- gtk_label_set_markup(GTK_LABEL(tune_percent_label), "<b>Tune Percent:</b>");
- gtk_widget_set_halign(tune_percent_label, GTK_ALIGN_START);
- gtk_widget_show(tune_percent_label);
- gtk_grid_attach(GTK_GRID(grid),tune_percent_label,col,row,1,1);
+ GtkWidget *tune_drive_label=gtk_label_new(NULL);
+ gtk_label_set_markup(GTK_LABEL(tune_drive_label), "<b>Drive for Tune:</b>");
+ gtk_widget_set_halign(tune_drive_label, GTK_ALIGN_START);
+ gtk_widget_show(tune_drive_label);
+ gtk_grid_attach(GTK_GRID(grid),tune_drive_label,col,row,1,1);
col++;
- GtkWidget *tune_percent=gtk_spin_button_new_with_range(1.0,100.0,1.0);
- gtk_spin_button_set_value(GTK_SPIN_BUTTON(tune_percent),(double)transmitter->tune_percent);
- gtk_grid_attach(GTK_GRID(grid),tune_percent,col,row,1,1);
- g_signal_connect(tune_percent,"value-changed",G_CALLBACK(tune_percent_cb),NULL);
+ GtkWidget *tune_drive=gtk_spin_button_new_with_range(1.0,100.0,1.0);
+ gtk_spin_button_set_value(GTK_SPIN_BUTTON(tune_drive),(double)transmitter->tune_drive);
+ gtk_grid_attach(GTK_GRID(grid),tune_drive,col,row,1,1);
+ g_signal_connect(tune_drive,"value-changed",G_CALLBACK(tune_drive_cb),NULL);
row++;
col=0;
// during receiver_vfo_changed ==> receiver_frequency_changed
//
- switch(id) {
- case 0:
+ if (id == 0) {
bandstack->current_entry=vfo[id].bandstack;
- vfo_apply_mode_settings(receiver[0]);
- receiver_vfo_changed(receiver[0]);
- break;
- case 1:
- if(receivers==2) {
- vfo_apply_mode_settings(receiver[1]);
- receiver_vfo_changed(receiver[1]);
- }
- break;
}
+ if (id < receivers) {
+ vfo_apply_mode_settings(receiver[id]);
+ receiver_vfo_changed(receiver[id]);
+ }
+
tx_vfo_changed();
set_alex_antennas(); // This includes scheduling hiprio and general packets
#ifdef SOAPYSDR
vfo[id].mode=entry->mode;
vfo[id].filter=entry->filter;
- switch(id) {
- case 0:
- bandstack->current_entry=vfo[id].bandstack;
- vfo_apply_mode_settings(receiver[0]);
- receiver_vfo_changed(receiver[0]);
- break;
- case 1:
- if(receivers==2) {
- vfo_apply_mode_settings(receiver[1]);
- receiver_vfo_changed(receiver[1]);
- }
- break;
+ if (id == 0) {
+ bandstack->current_entry=vfo[id].bandstack;
+ }
+ if (id < receivers) {
+ vfo_apply_mode_settings(receiver[id]);
+ receiver_vfo_changed(receiver[id]);
}
+
tx_vfo_changed();
set_alex_antennas(); // This includes scheduling hiprio and general packets
g_idle_add(ext_vfo_update,NULL);
vfo[id].mode=m;
- switch(id) {
- case 0:
- vfo_apply_mode_settings(receiver[0]);
- receiver_mode_changed(receiver[0]);
- receiver_filter_changed(receiver[0]);
- break;
- case 1:
- if(receivers==2) {
- vfo_apply_mode_settings(receiver[1]);
- receiver_mode_changed(receiver[1]);
- receiver_filter_changed(receiver[1]);
- }
- break;
+ if (id < receivers) {
+ vfo_apply_mode_settings(receiver[id]);
+ receiver_mode_changed(receiver[id]);
+ receiver_filter_changed(receiver[id]);
}
+
if(can_transmit) {
tx_set_mode(transmitter,get_tx_mode());
}
mode_settings[vfo[id].mode].filter = f;
vfo[id].filter=f;
- switch(id) {
- case 0:
- receiver_filter_changed(receiver[0]);
- break;
- case 1:
- if(receivers==2) {
- receiver_filter_changed(receiver[1]);
- }
- break;
+ if (id < receivers) {
+ receiver_filter_changed(receiver[id]);
}
g_idle_add(ext_vfo_update,NULL);
}
sid=id==0?1:0;
- other_receiver=receiver[sid];
+ if (sid < receivers) {
+ other_receiver=receiver[sid];
+ }
+ // other_receiver will be accessed only if receivers == 2
switch(sat_mode) {
case SAT_NONE:
}
sid=id==0?1:0;
- other_receiver=receiver[sid];
+ if (sid < receivers) {
+ other_receiver=receiver[sid];
+ }
switch(sat_mode) {
case SAT_NONE:
}
sid=id==0?1:0;
- other_receiver=receiver[sid];
+ if (sid < receivers) {
+ other_receiver=receiver[sid];
+ }
switch(sat_mode) {
case SAT_NONE:
}
sid=id==0?1:0;
- other_receiver=receiver[sid];
+ if (sid < receivers) {
+ other_receiver=receiver[sid];
+ }
switch(sat_mode) {
case SAT_NONE:
return vfo[txvfo].frequency;
}
}
-void vfo_rit_update(int rx) {
- vfo[receiver[rx]->id].rit_enabled=vfo[receiver[rx]->id].rit_enabled==1?0:1;
- receiver_frequency_changed(receiver[rx]);
+void vfo_rit_update(int id) {
+ vfo[id].rit_enabled=vfo[id].rit_enabled==1?0:1;
+ if (id < receivers) {
+ receiver_frequency_changed(receiver[id]);
+ }
g_idle_add(ext_vfo_update, NULL);
}
-void vfo_rit_clear(int rx) {
- vfo[receiver[rx]->id].rit=0;
- vfo[receiver[rx]->id].rit_enabled=0;
- receiver_frequency_changed(receiver[rx]);
+void vfo_rit_clear(int id) {
+ vfo[id].rit=0;
+ vfo[id].rit_enabled=0;
+ if (id < receivers) {
+ receiver_frequency_changed(receiver[id]);
+ }
g_idle_add(ext_vfo_update, NULL);
}
-void vfo_rit(int rx,int i) {
- double value=(double)vfo[receiver[rx]->id].rit;
+void vfo_rit(int id,int i) {
+ double value=(double)vfo[id].rit;
value+=(double)(i*rit_increment);
if(value<-10000.0) {
value=-10000.0;
} else if(value>10000.0) {
value=10000.0;
}
- vfo[receiver[rx]->id].rit=value;
- vfo[receiver[rx]->id].rit_enabled=(value!=0);
- receiver_frequency_changed(receiver[rx]);
+ vfo[id].rit=value;
+ vfo[id].rit_enabled=(value!=0);
+ if (id < receivers) {
+ receiver_frequency_changed(receiver[id]);
+ }
g_idle_add(ext_vfo_update,NULL);
}
//
void vfo_ctun_update(int id,int state) {
long long f;
+ //
+ // Note: if this VFO does not control a (running) receiver,
+ // receiver_set_frequency is *not* called therefore
+ // we should update ctun_frequency and offset
+ //
if (vfo[id].ctun == state) return; // no-op if no change
vfo[id].ctun=state;
if(vfo[id].ctun) {
// CTUN turned OFF->ON
vfo[id].ctun_frequency=vfo[id].frequency;
vfo[id].offset=0;
- if (id < receivers) receiver_set_frequency(receiver[id],vfo[id].ctun_frequency);
+ if (id < receivers) {
+ receiver_set_frequency(receiver[id],vfo[id].ctun_frequency);
+ }
} else {
// CTUN turned ON->OFF: keep frequency
vfo[id].frequency=vfo[id].ctun_frequency;
vfo[id].offset=0;
- if (id < receivers) receiver_set_frequency(receiver[id],vfo[id].ctun_frequency);
+ if (id < receivers) {
+ receiver_set_frequency(receiver[id],vfo[id].ctun_frequency);
+ }
}
}
void set_zoom(int rx,double value) {
//g_print("set_zoom: %f\n",value);
+ if (rx >= receivers) return;
receiver[rx]->zoom=value;
if(display_zoompan) {
gtk_range_set_value (GTK_RANGE(zoom_scale),receiver[rx]->zoom);
void set_pan(int rx,double value) {
g_print("set_pan: %f\n",value);
+ if (rx >= receivers) return;
receiver[rx]->pan=(int)value;
if(display_zoompan) {
gtk_range_set_value (GTK_RANGE(pan_scale),receiver[rx]->pan);
void remote_set_pan(int rx,double value) {
g_print("remote_set_pan: rx=%d pan=%f\n",rx,value);
+ if (rx >= receivers) return;
g_mutex_lock(&pan_zoom_mutex);
g_signal_handler_block(G_OBJECT(pan_scale),pan_signal_id);
gtk_range_set_range(GTK_RANGE(pan_scale),0.0,(double)(receiver[rx]->zoom==1?receiver[rx]->pixels:receiver[rx]->pixels-receiver[rx]->width));
projects / pihpsdr.git / commitdiff