// via the menu prior to changing the frequency
//
SET_FREQUENCY *set_frequency=(SET_FREQUENCY *)data;
-g_print("ext_set_frequency: vfo=%d freq=%lld\n",set_frequency->vfo,set_frequency->frequency);
vfo_set_frequency(set_frequency->vfo,set_frequency->frequency);
free(data);
return 0;
// such that they can be filtered out if they come at high rate
//
int ext_vfo_update(void *data) {
- if (vfo_timeout ==0) {
+ if (vfo_timeout==0) {
vfo_timeout=g_timeout_add(100, vfo_timeout_cb, NULL);
}
return 0;
}
int ext_mox_update(void *data) {
-g_print("%s\n",__FUNCTION__);
mox_update(GPOINTER_TO_INT(data));
return 0;
}
int ext_band_select(void *data) {
int b=GPOINTER_TO_INT(data);
- g_print("%s: %d\n",__FUNCTION__,b);
vfo_band_changed(active_receiver->id,b);
return 0;
}
AGC_COMMAND *agc_command=(AGC_COMMAND *)data;
RECEIVER *rx=receiver[agc_command->id];
rx->agc=ntohs(agc_command->agc);
-g_print("AGC_COMMAND: set_agc id=%d agc=%d\n",rx->id,rx->agc);
set_agc(rx,rx->agc);
send_agc(client->socket,rx->id,rx->agc);
g_idle_add(ext_vfo_update, NULL);
BAND_COMMAND *band_command=(BAND_COMMAND *)data;
RECEIVER *rx=receiver[band_command->id];
short b=htons(band_command->band);
-g_print("BAND_COMMAND: id=%d band=%d\n",rx->id,b);
vfo_band_changed(rx->id,b);
send_vfo_data(client,VFO_A);
send_vfo_data(client,VFO_B);
MODE_COMMAND *mode_command=(MODE_COMMAND *)data;
RECEIVER *rx=receiver[mode_command->id];
short m=htons(mode_command->mode);
-g_print("MODE_COMMAND: id=%d mode=%d\n",rx->id,m);
vfo_mode_changed(m);
send_vfo_data(client,VFO_A);
send_vfo_data(client,VFO_B);
FILTER_COMMAND *filter_command=(FILTER_COMMAND *)data;
RECEIVER *rx=receiver[filter_command->id];
short f=htons(filter_command->filter);
-g_print("FILTER_COMMAND: id=%d filter=%d\n",rx->id,f);
vfo_filter_changed(f);
send_vfo_data(client,VFO_A);
send_vfo_data(client,VFO_B);
case CMD_RESP_SPLIT:
{
SPLIT_COMMAND *split_command=(SPLIT_COMMAND *)data;
-g_print("SPLIT_COMMAND: split=%d\n",split);
if(can_transmit) {
split=split_command->split;
tx_set_mode(transmitter,get_tx_mode());
{
SAT_COMMAND *sat_command=(SAT_COMMAND *)data;
sat_mode=sat_command->sat;
-g_print("SAT_COMMAND: sat_mode=%d\n",sat_mode);
g_idle_add(ext_vfo_update, NULL);
send_sat(client->socket,sat_mode);
}
{
DUP_COMMAND *dup_command=(DUP_COMMAND *)data;
duplex=dup_command->dup;
-g_print("DUP: duplex=%d\n",duplex);
g_idle_add(ext_vfo_update, NULL);
send_dup(client->socket,duplex);
}
{
LOCK_COMMAND *lock_command=(LOCK_COMMAND *)data;
locked=lock_command->lock;
-g_print("LOCK: locked=%d\n",locked);
g_idle_add(ext_vfo_update, NULL);
send_lock(client->socket,locked);
}
case CMD_RESP_CTUN:
{
CTUN_COMMAND *ctun_command=(CTUN_COMMAND *)data;
-g_print("CTUN: vfo=%d ctun=%d\n",ctun_command->id,ctun_command->ctun);
int v=ctun_command->id;
vfo[v].ctun=ctun_command->ctun;
if(!vfo[v].ctun) {
{
FPS_COMMAND *fps_command=(FPS_COMMAND *)data;
int rx=fps_command->id;
-g_print("FPS: rx=%d fps=%d\n",rx,fps_command->fps);
receiver[rx]->fps=fps_command->fps;
calculate_display_average(receiver[rx]);
set_displaying(receiver[rx],1);
{
RX_SELECT_COMMAND *rx_select_command=(RX_SELECT_COMMAND *)data;
int rx=rx_select_command->id;
-g_print("RX_SELECT: rx=%d\n",rx);
receiver_set_active(receiver[rx]);
send_rx_select(client->socket,rx);
}
{
VFO_COMMAND *vfo_command=(VFO_COMMAND *)data;
int action=vfo_command->id;
-g_print("VFO: action=%d\n",action);
switch(action) {
case VFO_A_TO_B:
vfo_a_to_b();
{
RIT_UPDATE_COMMAND *rit_update_command=(RIT_UPDATE_COMMAND *)data;
int rx=rit_update_command->id;
-g_print("RIT_UPDATE: rx=%d\n",rx);
vfo_rit_update(rx);
send_vfo_data(client,rx);
}
{
RIT_CLEAR_COMMAND *rit_clear_command=(RIT_CLEAR_COMMAND *)data;
int rx=rit_clear_command->id;
-g_print("RIT_CLEAR: rx=%d\n",rx);
vfo_rit_clear(rx);
send_vfo_data(client,rx);
}
RIT_COMMAND *rit_command=(RIT_COMMAND *)data;
int rx=rit_command->id;
short rit=ntohs(rit_command->rit);
-g_print("RIT: rx=%d rit=%d\n",rx,(int)rit);
vfo_rit(rx,(int)rit);
send_vfo_data(client,rx);
}
case CMD_RESP_XIT_UPDATE:
{
XIT_UPDATE_COMMAND *xit_update_command=(XIT_UPDATE_COMMAND *)data;
-g_print("XIT_UPDATE\n");
send_vfo_data(client,VFO_A);
send_vfo_data(client,VFO_B);
}
case CMD_RESP_XIT_CLEAR:
{
XIT_CLEAR_COMMAND *xit_clear_command=(XIT_CLEAR_COMMAND *)data;
-g_print("XIT_CLEAR\n");
send_vfo_data(client,VFO_A);
send_vfo_data(client,VFO_B);
}
{
XIT_COMMAND *xit_command=(XIT_COMMAND *)data;
short xit=ntohs(xit_command->xit);
-g_print("XIT_CLEAR: xit=%d\n",xit);
send_vfo_data(client,VFO_A);
send_vfo_data(client,VFO_B);
}
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);
-g_print("SAMPLE_RATE: rx=%d rate=%d\n",rx,(int)rate);
if(rx==-1) {
radio_change_sample_rate((int)rate);
send_sample_rate(client->socket,-1,radio_sample_rate);
{
RECEIVERS_COMMAND *receivers_command=(RECEIVERS_COMMAND *)data;
int r=receivers_command->receivers;
-g_print("RECEIVERS: receivers=%d\n",r);
radio_change_receivers(r);
send_receivers(client->socket,receivers);
}
{
RIT_INCREMENT_COMMAND *rit_increment_command=(RIT_INCREMENT_COMMAND *)data;
short increment=ntohs(rit_increment_command->increment);
-g_print("RIT_INCREMENT: increment=%d\n",increment);
rit_increment=(int)increment;
send_rit_increment(client->socket,rit_increment);
}
case CMD_RESP_FILTER_BOARD:
{
FILTER_BOARD_COMMAND *filter_board_command=(FILTER_BOARD_COMMAND *)data;
-g_print("FILTER_BOARD: board=%d\n",(int)filter_board_command->filter_board);
filter_board=(int)filter_board_command->filter_board;
load_filters();
send_filter_board(client->socket,filter_board);
case CMD_RESP_SWAP_IQ:
{
SWAP_IQ_COMMAND *swap_iq_command=(SWAP_IQ_COMMAND *)data;
-g_print("SWAP_IQ: board=%d\n",(int)swap_iq_command->iqswap);
iqswap=(int)swap_iq_command->iqswap;
send_swap_iq(client->socket,iqswap);
}
case CMD_RESP_REGION:
{
REGION_COMMAND *region_command=(REGION_COMMAND *)data;
-g_print("REGION: region=%d\n",(int)region_command->region);
iqswap=(int)region_command->region;
send_region(client->socket,region);
}
int ext_remote_set_zoom(void *data) {
int zoom=GPOINTER_TO_INT(data);
-g_print("ext_remote_set_zoom: %d\n",zoom);
remote_set_zoom(active_receiver->id,(double)zoom);
return 0;
}
int ext_remote_set_pan(void *data) {
int pan=GPOINTER_TO_INT(data);
-g_print("ext_remote_set_pan: %d\n",pan);
remote_set_pan(active_receiver->id,(double)pan);
return 0;
}
vfo_step(pos);
}
-static uint64_t epochMilli;
-
-static void initialiseEpoch() {
- struct timespec ts ;
-
- clock_gettime (CLOCK_MONOTONIC_RAW, &ts) ;
- epochMilli = (uint64_t)ts.tv_sec * (uint64_t)1000 + (uint64_t)(ts.tv_nsec / 1000000L) ;
-}
-
-static uint32_t millis () {
- uint64_t now ;
- struct timespec ts ;
- clock_gettime (CLOCK_MONOTONIC_RAW, &ts) ;
- now = (uint64_t)ts.tv_sec * (uint64_t)1000 + (uint64_t)(ts.tv_nsec / 1000000L) ;
- return (uint32_t)(now - epochMilli) ;
-}
-
-static uint32_t debounce_time=50; // 50ms
-static uint32_t t;
-static uint32_t debounce=0;
-
void i2c_interrupt() {
unsigned int flags;
unsigned int ints;
// Perhaps we should determine the lock status and simply return if it is locked.
//
g_mutex_lock(&i2c_mutex);
- t=millis();
for (;;) {
flags=read_word_data(0x0E); // indicates which switch caused the interrupt
// More than one bit may be set if two input lines
if (flags == 0) break; // "forever" loop is left if no interrups pending
ints=read_word_data(0x10); // input lines at time of interrupt
// only those bits set in "flags" are meaningful!
+//g_print("%s: flags=%04X ints=%04X\n",__FUNCTION__,flags,ints);
if(t<debounce) break;
for(i=0; i<16 && flags; i++) { // leave loop if no bits left in flags.
if(i2c_sw[i] & flags) {
// The input line associated with switch #i has triggered an interrupt
+//g_print("%s: switches=%p sw=%d action=%d\n",__FUNCTION__,switches,i,switches[i].switch_function);
flags &= ~i2c_sw[i]; // clear *this* bit in flags
schedule_action(switches[i].switch_function, (ints & i2c_sw[i]) ? PRESSED : RELEASED, 0);
}
}
}
- debounce=t+debounce_time;
g_mutex_unlock(&i2c_mutex);
}
flags=read_word_data(0x0E);
if(flags) {
ints=read_word_data(0x10);
- fprintf(stderr,"flush interrupt: flags=%04X ints=%04X\n",flags,ints);
count++;
if(count==10) {
return;
}
} while(flags!=0);
- initialiseEpoch();
-
}
#endif