From d485ca32d973621e6a6ffb7eb057febce735bfda Mon Sep 17 00:00:00 2001 From: c vw Date: Tue, 24 Jan 2023 19:39:28 +0100 Subject: [PATCH] a) handle cases where RX2 is referred to but only one RX is available b) TX menu: TUNE power setting is now such that one gives a the value of the drive slider that should be effective when tuning, so no longer a percentage of the current position of the drive slider c) ClientServer: moved that part of this code that used to be in ext.c to client_server.c (where it belongs) d) Fixed frequency changes while CTUN is active e) allow for CW with a keyer attached to the radio when LOCALCW is not active --- actions.c | 34 ++-- client_server.c | 479 ++++++++++++++++++++++++++++++++++++++++++++---- ext.c | 391 --------------------------------------- filter.c | 10 +- new_protocol.c | 22 ++- old_protocol.c | 26 ++- radio.c | 26 ++- receiver.c | 28 ++- rigctl.c | 196 +++++++++++--------- sliders.c | 3 + transmitter.c | 17 +- transmitter.h | 2 +- tx_menu.c | 28 ++- vfo.c | 125 +++++++------ zoompan.c | 3 + 15 files changed, 732 insertions(+), 658 deletions(-) diff --git a/actions.c b/actions.c index c771c19..ebcee9a 100644 --- a/actions.c +++ b/actions.c @@ -311,8 +311,10 @@ int process_action(void *data) { 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) { @@ -333,8 +335,10 @@ int process_action(void *data) { 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) { @@ -895,8 +899,10 @@ int process_action(void *data) { 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); @@ -936,10 +942,10 @@ int process_action(void *data) { } 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) { @@ -1009,9 +1015,11 @@ int process_action(void *data) { 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) { @@ -1031,8 +1039,8 @@ int process_action(void *data) { 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: diff --git a/client_server.c b/client_server.c index ff4f662..0b972ee 100644 --- a/client_server.c +++ b/client_server.c @@ -48,6 +48,10 @@ #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 @@ -89,6 +93,7 @@ static gint listen_socket; static int audio_buffer_index=0; AUDIO_DATA audio_data; +static int remote_command(void * data); GMutex accumulated_mutex; static int accumulated_steps=0; @@ -481,7 +486,7 @@ g_print("server_client_thread: CMD_RESP_RX_FREQ\n"); // 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: @@ -498,7 +503,7 @@ g_print("server_client_thread: CMD_RESP_RX_STEP\n"); // 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: @@ -515,7 +520,7 @@ g_print("server_client_thread: CMD_RESP_RX_MOVE\n"); // 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: @@ -532,7 +537,7 @@ g_print("server_client_thread: CMD_RESP_RX_MOVETO\n"); // 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: @@ -549,7 +554,7 @@ g_print("server_client_thread: CMD_RESP_RX_ZOOM\n"); // 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: @@ -566,7 +571,7 @@ g_print("server_client_thread: CMD_RESP_RX_PAN\n"); // 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: @@ -583,7 +588,7 @@ g_print("server_client_thread: CMD_RESP_RX_VOLUME\n"); // 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: @@ -601,7 +606,7 @@ g_print("server_client_thread: CMD_RESP_RX_AGC\n"); 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: @@ -618,7 +623,7 @@ g_print("server_client_thread: CMD_RESP_RX_AGC_GAIN\n"); // 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: @@ -635,7 +640,7 @@ g_print("server_client_thread: CMD_RESP_RX_GAIN\n"); // dialog box? return NULL; } - g_idle_add(ext_remote_command,command); + g_idle_add(remote_command,command); } break; case CMD_RESP_RX_ATTENUATION: @@ -652,7 +657,7 @@ g_print("server_client_thread: CMD_RESP_RX_ATTENUATION\n"); // 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: @@ -669,7 +674,7 @@ g_print("server_client_thread: CMD_RESP_RX_SQUELCH\n"); // 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: @@ -686,7 +691,7 @@ g_print("server_client_thread: CMD_RESP_RX_NOISE\n"); // 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: @@ -703,7 +708,7 @@ g_print("server_client_thread: CMD_RESP_RX_BAND\n"); // 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: @@ -720,7 +725,7 @@ g_print("server_client_thread: CMD_RESP_RX_MODE\n"); // 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: @@ -737,7 +742,7 @@ g_print("server_client_thread: CMD_RESP_RX_FILTER\n"); // dialog box? return NULL; } - g_idle_add(ext_remote_command,filter_command); + g_idle_add(remote_command,filter_command); } break; case CMD_RESP_SPLIT: @@ -754,7 +759,7 @@ g_print("server_client_thread: CMD_RESP_RX_SPLIT\n"); // dialog box? return NULL; } - g_idle_add(ext_remote_command,split_command); + g_idle_add(remote_command,split_command); } break; case CMD_RESP_SAT: @@ -771,7 +776,7 @@ g_print("server_client_thread: CMD_RESP_RX_SAT\n"); // dialog box? return NULL; } - g_idle_add(ext_remote_command,sat_command); + g_idle_add(remote_command,sat_command); } break; case CMD_RESP_DUP: @@ -788,7 +793,7 @@ g_print("server_client_thread: CMD_RESP_DUP\n"); // dialog box? return NULL; } - g_idle_add(ext_remote_command,dup_command); + g_idle_add(remote_command,dup_command); } break; case CMD_RESP_LOCK: @@ -805,7 +810,7 @@ g_print("server_client_thread: CMD_RESP_LOCK\n"); // dialog box? return NULL; } - g_idle_add(ext_remote_command,lock_command); + g_idle_add(remote_command,lock_command); } break; case CMD_RESP_CTUN: @@ -822,7 +827,7 @@ g_print("server_client_thread: CMD_RESP_CTUN\n"); // 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: @@ -839,7 +844,7 @@ g_print("server_client_thread: CMD_RESP_RX_FPS\n"); // 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: @@ -856,7 +861,7 @@ g_print("server_client_thread: CMD_RESP_RX_SELECT\n"); // 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: @@ -873,7 +878,7 @@ g_print("server_client_thread: CMD_RESP_VFO\n"); // 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: @@ -890,7 +895,7 @@ g_print("server_client_thread: CMD_RESP_RIT_UPDATE\n"); // 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: @@ -907,7 +912,7 @@ g_print("server_client_thread: CMD_RESP_RIT_CLEAR\n"); // 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: @@ -924,7 +929,7 @@ g_print("server_client_thread: CMD_RESP_RIT\n"); // 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: @@ -934,7 +939,7 @@ g_print("server_client_thread: CMD_RESP_XIT_UPDATE\n"); 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: @@ -944,7 +949,7 @@ g_print("server_client_thread: CMD_RESP_XIT_CLEAR\n"); 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: @@ -954,7 +959,7 @@ g_print("server_client_thread: CMD_RESP_XIT\n"); 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: @@ -971,7 +976,7 @@ g_print("server_client_thread: CMD_RESP_SAMPLE_RATE\n"); // 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: @@ -988,7 +993,7 @@ g_print("server_client_thread: CMD_RESP_RECEIVERS\n"); // 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: @@ -1005,7 +1010,7 @@ g_print("server_client_thread: CMD_RESP_RIT_INCREMENT\n"); // 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: @@ -1022,7 +1027,7 @@ g_print("server_client_thread: CMD_RESP_FILTER_BOARD\n"); // 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: @@ -1039,7 +1044,7 @@ g_print("server_client_thread: CMD_RESP_SWAP_IQ\n"); // 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: @@ -1056,7 +1061,7 @@ g_print("server_client_thread: CMD_RESP_REGION\n"); // 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: @@ -1073,7 +1078,7 @@ g_print("server_client_thread: CMD_RESP_MUTE_RX\n"); // dialog box? return NULL; } - g_idle_add(ext_remote_command,mute_rx_command); + g_idle_add(remote_command,mute_rx_command); } break; @@ -2537,3 +2542,403 @@ g_print("radio_connect_remote: socket %d bound to %s:%d\n",client_socket,host,po 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; +} diff --git a/ext.c b/ext.c index 30e209c..4948b54 100644 --- a/ext.c +++ b/ext.c @@ -27,30 +27,14 @@ #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 @@ -119,380 +103,6 @@ int ext_set_duplex(void *data) { 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); @@ -514,4 +124,3 @@ int ext_set_title(void *data) { gtk_window_set_title(GTK_WINDOW(top_window),(char *)data); return 0; } -#endif diff --git a/filter.c b/filter.c index e8f215b..02f7f2e 100644 --- a/filter.c +++ b/filter.c @@ -420,12 +420,11 @@ void filterRestoreState() { } -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) { @@ -450,12 +449,11 @@ fprintf(stderr,"filter_width_changed: rx=%d mode=%d filter=%d increment=%d\n",rx } } -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) { diff --git a/new_protocol.c b/new_protocol.c index 5b14ec0..fd87e09 100644 --- a/new_protocol.c +++ b/new_protocol.c @@ -867,15 +867,7 @@ static void new_protocol_high_priority() { 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; @@ -1942,7 +1934,7 @@ static void process_high_priority() { 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; @@ -1952,6 +1944,16 @@ static void process_high_priority() { 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) { diff --git a/old_protocol.c b/old_protocol.c index 548b1bb..e87d621 100644 --- a/old_protocol.c +++ b/old_protocol.c @@ -907,7 +907,7 @@ static void process_control_bytes() { 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; @@ -917,6 +917,16 @@ static void process_control_bytes() { 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) { @@ -1540,7 +1550,12 @@ void ozy_send_buffer() { 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. @@ -1637,12 +1652,7 @@ void ozy_send_buffer() { // (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 diff --git a/radio.c b/radio.c index 2537c36..130dca0 100644 --- a/radio.c +++ b/radio.c @@ -379,9 +379,11 @@ g_print("radio_stop: TX: CloseChannel: %d\n",transmitter->id); 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() { @@ -1420,7 +1422,7 @@ void radio_change_receivers(int r) { 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 @@ -1809,6 +1811,8 @@ void setTune(int state) { tx_set_mode(transmitter,modeUSB); break; } + tune=state; + calcDriveLevel(); rxtx(state); } else { rxtx(state); @@ -1828,8 +1832,9 @@ void setTune(int state) { // SetPSControl(transmitter->id, 0, 0, 1, 0); } + tune=state; + calcDriveLevel(); } - tune=state; } if(protocol==NEW_PROTOCOL) { schedule_high_priority(); @@ -1873,11 +1878,16 @@ static int calcLevel(double d) { } 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) { @@ -1896,7 +1906,7 @@ void setDrive(double value) { } double getTuneDrive() { - return transmitter->tune_percent; + return transmitter->tune_drive; } void setSquelch(RECEIVER *rx) { @@ -2386,7 +2396,7 @@ g_print("radioSaveState: %s\n",property_path); gpio_save_actions(); sprintf(value,"%d",receivers); setProperty("receivers",value); - for(i=0;iid; 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; @@ -1350,17 +1349,20 @@ void receiver_frequency_changed(RECEIVER *rx) { // // 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); @@ -1376,19 +1378,26 @@ void receiver_frequency_changed(RECEIVER *rx) { } // - // 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 @@ -1411,6 +1420,9 @@ void receiver_filter_changed(RECEIVER *rx) { tx_set_filter(transmitter); } } + // + // TODO: Filter window has possibly moved outside CTUN range + // } void receiver_mode_changed(RECEIVER *rx) { diff --git a/rigctl.c b/rigctl.c index 83d27d9..2d8978c 100644 --- a/rigctl.c +++ b/rigctl.c @@ -68,12 +68,6 @@ 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 @@ -837,6 +831,8 @@ gboolean parse_extended_cmd (char *command,CLIENT *client) { int threshold=atoi(&command[4]); set_agc_gain(VFO_B,(double)threshold); } + } else { + implemented=FALSE; } break; case 'T': //ZZAT @@ -863,6 +859,8 @@ gboolean parse_extended_cmd (char *command,CLIENT *client) { if(command[4]==';') { if(receivers==2) { band_minus(receiver[1]->id); + } else { + implemented=FALSE; } } break; @@ -871,6 +869,8 @@ gboolean parse_extended_cmd (char *command,CLIENT *client) { if(command[4]==';') { if(receivers==2) { band_plus(receiver[1]->id); + } else { + implemented=FALSE; } } break; @@ -1461,14 +1461,18 @@ gboolean parse_extended_cmd (char *command,CLIENT *client) { 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: @@ -1578,6 +1582,8 @@ gboolean parse_extended_cmd (char *command,CLIENT *client) { receiver[1]->volume=(double)gain/100.0; update_af_gain(); } + } else { + implemented=FALSE; } break; case 'D': //ZZLD @@ -1750,28 +1756,36 @@ gboolean parse_extended_cmd (char *command,CLIENT *client) { 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 @@ -1794,25 +1808,31 @@ gboolean parse_extended_cmd (char *command,CLIENT *client) { 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 @@ -1840,38 +1860,50 @@ gboolean parse_extended_cmd (char *command,CLIENT *client) { 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: @@ -2061,12 +2093,14 @@ gboolean parse_extended_cmd (char *command,CLIENT *client) { // 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; @@ -2435,6 +2469,8 @@ gboolean parse_extended_cmd (char *command,CLIENT *client) { sprintf(reply,"ZZXO%04d;",status); send_resp(client->fd,reply); } + } else { + implemented=FALSE; } break; case 'S': //ZZXS @@ -2500,12 +2536,10 @@ gboolean parse_extended_cmd (char *command,CLIENT *client) { // 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); } @@ -2747,20 +2781,10 @@ int parse_cmd(void *data) { 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); } @@ -3627,9 +3651,11 @@ int parse_cmd(void *data) { // 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; diff --git a/sliders.c b/sliders.c index 2fa7ff5..d1f8d15 100644 --- a/sliders.c +++ b/sliders.c @@ -287,6 +287,7 @@ static void agcgain_value_changed_cb(GtkWidget *widget, gpointer data) { 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) { @@ -346,6 +347,7 @@ void update_af_gain() { } 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) { @@ -406,6 +408,7 @@ void update_rf_gain() { } 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) { diff --git a/transmitter.c b/transmitter.c index e3a4ba0..81c5760 100644 --- a/transmitter.c +++ b/transmitter.c @@ -235,8 +235,8 @@ void transmitter_save_state(TRANSMITTER *tx) { 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); @@ -342,9 +342,9 @@ void transmitter_restore_state(TRANSMITTER *tx) { 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); @@ -882,7 +882,7 @@ fprintf(stderr,"create_transmitter: id=%d buffer_size=%d mic_sample_rate=%d mic_ 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; @@ -1240,12 +1240,7 @@ static void full_tx_buffer(TRANSMITTER *tx) { // // "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) { diff --git a/transmitter.h b/transmitter.h index 897f23b..2735e86 100644 --- a/transmitter.h +++ b/transmitter.h @@ -91,7 +91,7 @@ typedef struct _transmitter { int drive; int tune_use_drive; - int tune_percent; + int tune_drive; int drive_level; diff --git a/tx_menu.c b/tx_menu.c index f5242df..8c84a0a 100644 --- a/tx_menu.c +++ b/tx_menu.c @@ -124,8 +124,8 @@ static void tune_use_drive_cb (GtkWidget *widget, gpointer data) { 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) { @@ -221,12 +221,6 @@ static gboolean emp_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]; @@ -492,17 +486,17 @@ void tx_menu(GtkWidget *parent) { col++; - GtkWidget *tune_percent_label=gtk_label_new(NULL); - gtk_label_set_markup(GTK_LABEL(tune_percent_label), "Tune Percent:"); - 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), "Drive for Tune:"); + 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; diff --git a/vfo.c b/vfo.c index ea7c726..d28fc16 100644 --- a/vfo.c +++ b/vfo.c @@ -451,19 +451,14 @@ void vfo_band_changed(int id,int b) { // 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 @@ -494,19 +489,14 @@ void vfo_bandstack_changed(int b) { 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); @@ -523,20 +513,12 @@ void vfo_mode_changed(int m) { 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()); } @@ -564,15 +546,8 @@ void vfo_filter_changed(int f) { 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); @@ -769,7 +744,10 @@ void vfo_step(int steps) { } 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: @@ -823,7 +801,9 @@ void vfo_id_step(int id, int steps) { } sid=id==0?1:0; - other_receiver=receiver[sid]; + if (sid < receivers) { + other_receiver=receiver[sid]; + } switch(sat_mode) { case SAT_NONE: @@ -902,7 +882,9 @@ void vfo_id_move(int id,long long hz,int round) { } sid=id==0?1:0; - other_receiver=receiver[sid]; + if (sid < receivers) { + other_receiver=receiver[sid]; + } switch(sat_mode) { case SAT_NONE: @@ -983,7 +965,9 @@ void vfo_move_to(long long hz) { } sid=id==0?1:0; - other_receiver=receiver[sid]; + if (sid < receivers) { + other_receiver=receiver[sid]; + } switch(sat_mode) { case SAT_NONE: @@ -1492,30 +1476,36 @@ long long get_tx_freq() { 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); } @@ -1560,18 +1550,27 @@ void vfo_set_frequency(int v,long long f) { // 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); + } } } diff --git a/zoompan.c b/zoompan.c index ee92af7..9fbb9bd 100644 --- a/zoompan.c +++ b/zoompan.c @@ -99,6 +99,7 @@ g_print("zoom_value_changed_cb\n"); 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); @@ -171,6 +172,7 @@ g_print("pan_value_changed_cb\n"); 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); @@ -207,6 +209,7 @@ g_print("set_pan: %f\n",value); 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)); -- 2.45.2