updown.cpp

串口可交换程序

#include <math.h>
#include <stdio.h>
#include <string.h>
#include <graphics.h>

#include <conio.h>

#include "keydef.h"
#include "global.h"
#include "g_func.h"
#include "cursor.h"
#include "numkeyp.h"
#include "marker.h"
#include "updown.h"
#include "freqkey.h"
#include "sweepkey.h"
#include "system.h"
#include "store.h"
#include "scale.h"
#include "powerkey.h"

extern char sweep[];
//void updownkey_p(KEY key)
extern float max(float a,float b);
void updownkey_p(KEY key,char counts)
{
	char i;
	int aa;
	long ff;
	float pp;
	long  ssw;
	int swpp;
	float vol,old_vol,max_min;
	int old_pos;
	int avg;
	int old_sys;
	if(_keyid==SWEEP&&_softkeyid==2&&_sweep[ch_sel].flag1==1)
		goto proc;
	if(!digital_en)
		return;
proc:
	if(key==LR_L)
		key=DOWN;
	else if(key==LR_R)
		key=UP;
	switch(_keyid)
	{
	case FREQ:
		switch(_softkeyid)
		{
		case 1:
			fst_updown_f();
			if(key==DOWN)
				ff=_freq[ch_sel].start_freq-counts*pow(10,(bit_cnt-cnt));
			else if(key==UP)
				ff=_freq[ch_sel].start_freq+counts*pow(10,(bit_cnt-cnt));
			if(ff<100000 ||
				ff>_freq[ch_sel].end_freq-_status[ch_sel].sweep_points)
				return;
			_freq[ch_sel].start_freq=ff;
			_freq[ch_sel].is_dot_freq=FALSE;
			aa=bit_cnt;
			bit_cnt_frq(_freq[ch_sel].start_freq);
			bc_xch_f(key,aa);
			refr_frq_f1();
			update_cs_f();
			stat_xch=1;
			break;
		case 2:
			fst_updown_f();
			if(key==DOWN)
				ff=_freq[ch_sel].end_freq-counts*pow(10,(bit_cnt-cnt));
			else if(key==UP)
				ff=_freq[ch_sel].end_freq+counts*pow(10,(bit_cnt-cnt));
			if(ff<_freq[ch_sel].start_freq+_status[ch_sel].sweep_points||
				ff>50000000)
				return;
			_freq[ch_sel].end_freq=ff;
			_freq[ch_sel].is_dot_freq=FALSE;
			aa=bit_cnt;
			bit_cnt_frq(_freq[ch_sel].end_freq);
			bc_xch_f(key,aa);
			refr_frq_f2();
			update_cs_f();
			stat_xch=1;
			break;
		case 3:
			if(_freq[ch_sel].is_dot_freq==TRUE)
				break;
			fst_updown_f();
			if(key==DOWN)
				ff=_freq[ch_sel].center_freq-counts*pow(10,(bit_cnt-cnt));
			else if(key==UP)
				ff=_freq[ch_sel].center_freq+counts*pow(10,(bit_cnt-cnt));

			if(ff<100000+501||ff>50000000-501)
				return;
			if(ff-_freq[ch_sel].freq_width/2<100000)
			{
				_freq[ch_sel].center_freq = ff;
				_freq[ch_sel].freq_width = (ff-100000)*2;
			}
			else if(ff+_freq[ch_sel].freq_width/2>50000000)
			{
				_freq[ch_sel].center_freq = ff;
				_freq[ch_sel].freq_width = (50000000-ff)*2;
			}
			else
				_freq[ch_sel].center_freq=ff;
			_freq[ch_sel].is_dot_freq=FALSE;
			aa=bit_cnt;
			bit_cnt_frq(_freq[ch_sel].center_freq);
			bc_xch_f(key,aa);
			refr_ln3();
			refr_frq_f3();
			update_ss_f();
			stat_xch=1;
			break;
		case 4:
			fst_updown_f();
			if(key==DOWN)
				ff=_freq[ch_sel].freq_width-counts*pow(10,(bit_cnt-cnt));
			if(key==UP)
				ff=_freq[ch_sel].freq_width+counts*pow(10,(bit_cnt-cnt));
			if((ff<501||ff>49900000)
				||(_freq[ch_sel].center_freq-ff/2<100000)||(_freq[ch_sel].center_freq+ff/2>50000000)||
			   ff<_status[ch_sel].sweep_points)
				return;
			_freq[ch_sel].freq_width=ff;
			_freq[ch_sel].is_dot_freq=FALSE;
			aa=bit_cnt;
			bit_cnt_frq(_freq[ch_sel].freq_width);
			bc_xch_f(key,aa);
			refr_frq_f4();
			update_ss_f();
			stat_xch=1;
			break;
		case 5:
			fst_updown_f();
			if(key==DOWN)
				ff=_freq[ch_sel].dot_freq-counts*pow(10,(bit_cnt-cnt));
			else if(key==UP)
				ff=_freq[ch_sel].dot_freq+counts*pow(10,(bit_cnt-cnt));
			if(ff >= 100000&&ff<=50000000)
				_freq[ch_sel].dot_freq=ff;
			_freq[ch_sel].start_freq=_freq[ch_sel].dot_freq;
			_freq[ch_sel].end_freq=_freq[ch_sel].dot_freq;
			update_cs_f();
			for(i=0;i<8;i++)
				if(_marker[ch_sel].mark[i].on_off==ON)
					_marker[ch_sel].mark[i].freq=_freq[ch_sel].dot_freq;

			stat_xch=1;
//			_freq[ch_sel].is_dot_freq=OFF;
			aa=bit_cnt;
			bit_cnt_frq(_freq[ch_sel].dot_freq);
			bc_xch_f(key,aa);
			refr_frq_f5();
			break;
		default:
			break;
		}
		cursor();
		break;
	case POWER:
		if(_softkeyid==1){
			if(index>0){
				set_power();
				cnt=bit_cnt;
				x_pos=119+cnt*13;
			}
			if(key==DOWN)
				pp=_power[ch_sel].output_power-counts*pow(10,(bit_cnt-cnt-2));
			else if(key==UP)
				pp=_power[ch_sel].output_power+counts*pow(10,(bit_cnt-cnt-2));
			if((key==DOWN&&pp<-70.0)||(key==UP&&pp>13.0))
				return;
			_power[ch_sel].output_power=pp;
			refresh_up();
/*			if(_power[ch_sel].output_power>-0.001){
				outportb(0x35c,0);
			}
			else if(_power[ch_sel].output_power>-10.001){
				outportb(0x35c,0x1);
			}
			else if(_power[ch_sel].output_power>-20.001){
				outportb(0x35c,0x2);
			}
			else if(_power[ch_sel].output_power>-30.001){
				outportb(0x35c,0x3);
			}
			else if(_power[ch_sel].output_power>-40.001){
				outportb(0x35c,0x6);
			}
			else if(_power[ch_sel].output_power>-50.001){
				outportb(0x35c,0x7);
			}
			else if(_power[ch_sel].output_power>-60.001){
				outportb(0x35c,0x0e);
			}
			else if(_power[ch_sel].output_power>-70.001){
				outportb(0x35c,0x0f);
			}
*/
			set_relay(_power[ch_sel].output_power);
			aa=bit_cnt;
			bit_cnt_pwr(_power[ch_sel].output_power);
			bc_xch_p(key,aa);
			refr_pwr_f1();
			cursor();
			stat_xch=1;
		}
		else if(_softkeyid1==21){
			if(index>0){
				set_power();
				cnt=bit_cnt;
				x_pos=119+cnt*13;
			}
			if(key==DOWN)
				pp=_power[ch_sel].start_power-counts*pow(10,(bit_cnt-cnt-2));
			else if(key==UP)
				pp=_power[ch_sel].start_power+counts*pow(10,(bit_cnt-cnt-2));
			if((key==DOWN&&pp<-80.0)||(key==UP&&pp>_power[ch_sel].end_power))
				return;
			_power[ch_sel].start_power=pp;
			aa=bit_cnt;
			bit_cnt_pwr(_power[ch_sel].start_power);
			bc_xch_p(key,aa);
			refr_pwr_f21();
			stat_xch=1;
		}
		else if(_softkeyid1==22){
			if(index>0){
				set_power();
				cnt=bit_cnt;
				x_pos=119+cnt*13;
			}
			if(key==DOWN)
				pp=_power[ch_sel].end_power-counts*pow(10,(bit_cnt-cnt-2));
			else if(key==UP)
				pp=_power[ch_sel].end_power+counts*pow(10,(bit_cnt-cnt-2));
			if(pp<_power[ch_sel].start_power||pp>13.0)
				return;
			_power[ch_sel].end_power=pp;

			aa=bit_cnt;
			bit_cnt_pwr(_power[ch_sel].end_power);
			bc_xch_p(key,aa);
			refr_pwr_f22();
			stat_xch=1;
		}
		cursor();
		break;
	case SWEEP:
		if(_softkeyid==1){
			if(index>0){
				rst_num_mem();
				curs_flag=1;
				_softkeyid=1;
				_softkeyid1=0;
				disp_menu12((char**)sweep,7);
				setfillstyle(SOLID_FILL,TEXTMENUBK);
				bar(B_LX,139,B_RX-3,159);
				flags_s1();
				setfillstyle(SOLID_FILL,TEXTMENUBK);
				bar(B_LX,318,B_RX-3,338);
				flags_s2();
				bar(B_LX,80,B_RX-3,101);
				ms_ors();

				cnt=bit_cnt-1;
				if(_sweep[ch_sel].sweep_time>=1000)
					x_pos=107+cnt*13;
				else
					x_pos=107+(cnt-1)*13;
			}
			if(key==DOWN)
				ssw=_sweep[ch_sel].sweep_time-counts*pow(10,bit_cnt-cnt);
			else if(key==UP)
				ssw=_sweep[ch_sel].sweep_time+counts*pow(10,bit_cnt-cnt);
			if((key==DOWN&&ssw<50)||(key==UP&&ssw>100000))
				return;
			_sweep[ch_sel].sweep_time=ssw;
			stat_xch=1;
			aa=bit_cnt;
			bit_cnt_swp(_sweep[ch_sel].sweep_time);
			if(key==DOWN&&bit_cnt<aa){
				if(cnt==1)
					goto next_sw;
				x_pos-=13;
				cnt--;
			}
			else if(key==UP&&bit_cnt>aa){
				x_pos+=13;
				cnt++;
				if(bit_cnt==4)
					x_pos+=13;
			}
next_sw:		ms_ors();
		}
		else if(_softkeyid==2&&_sweep[ch_sel].flag1==1){
			if(key==DOWN)
				swpp=_sweep[ch_sel].swp_pc-counts*pow(10,bit_cnt-cnt);
			else if(key==UP)
				swpp=_sweep[ch_sel].swp_pc+counts*pow(10,bit_cnt-cnt);
			if(swpp>=0&&swpp<_status[ch_sel].sweep_points){
				_sweep[ch_sel].swp_pc=swpp;
				stat_xch=1;
				aa=bit_cnt;
				bit_cnt_swpp(_sweep[ch_sel].swp_pc);
				bc_xch_sw(key,aa);
				refr_swp_f2();
			}
		}
		cursor();
		break;
	case SCALE:
		if(_softkeyid==3){
			old_vol=_scale[ch_sel].ref_vol;
			if(key==DOWN)
//				_scale[ch_sel].ref_vol-=pow(10,bit_cnt-cnt-1);
				_scale[ch_sel].ref_vol-=counts*pow(10,bit_cnt-cnt);
			else if(key==UP)
//				_scale[ch_sel].ref_vol+=pow(10,bit_cnt-cnt-1);
				_scale[ch_sel].ref_vol+=counts*pow(10,bit_cnt-cnt);
//			if(_scale[ch_sel].ref_vol<-70||_scale[ch_sel].ref_vol>100||!scl_err()){
			if(_scale[ch_sel].ref_vol<-70||_scale[ch_sel].ref_vol>100){
				_scale[ch_sel].ref_vol=old_vol;
				return;
			}
			scl_xch = TRUE;
			aa=bit_cnt;
			bit_cnt_vol(_scale[ch_sel].ref_vol);
			bc_xch_vol(key,aa);
			refr_scl_f3();
		}
		else if(_softkeyid==4){
			old_pos=_scale[ch_sel].ref_pos;
			if(key==DOWN)
				_scale[ch_sel].ref_pos-=counts*1;
			else if(key==UP)
				_scale[ch_sel].ref_pos+=counts*1;
//			if(_scale[ch_sel].ref_pos<0||_scale[ch_sel].ref_pos>10||!scl_err()){
			if(_scale[ch_sel].ref_pos<0||_scale[ch_sel].ref_pos>10){
				_scale[ch_sel].ref_pos=old_pos;
				return;
			}
			scl_xch = TRUE;
			refr_scl_f4();
		}
		refresh_up();
		vision();
		cursor();
		break;
	case MARKER:
		switch(_softkeyid)
		{
		case 1:
		case 2:
		case 3:
		//
			fst_updown_mkr();
			if(key==DOWN)
			{
				ff=_marker[ch_sel].mark[_softkeyid-1].freq-counts*pow(10,(bit_cnt-cnt));
			}  //
			else if(key==UP)
			{
				ff=_marker[ch_sel].mark[_softkeyid-1].freq+counts*pow(10,(bit_cnt-cnt));
			}  //
			if(ff<_freq[ch_sel].start_freq || ff>_freq[ch_sel].end_freq)
				return;
			_marker[ch_sel].mark[_softkeyid-1].freq=ff;
			mkr_xch = TRUE;
			aa=bit_cnt;
			bit_cnt_frq(_marker[ch_sel].mark[_softkeyid-1].freq);
			bc_xch_f(key,aa);
			//marker_show1(_softkeyid);
			//mkr_show_mark_all(_softkeyid-1);
			refr_menu_mkr_all(_softkeyid-1);
			 refresh_down_mark();
			 cursor();
//		sprintf(cc,"%d",ii++);
//			 outtextxy(440,272,cc);
//			 outtextxy(290,272,"3");
///
			break;
		case 4:
			fst_updown_mkr();
			if(key==DOWN)
				ff=_marker[ch_sel].mark[_softkeyid1-38].freq-counts*pow(10,(bit_cnt-cnt));
			else if(key==UP)
				ff=_marker[ch_sel].mark[_softkeyid1-38].freq+counts*pow(10,(bit_cnt-cnt));
			if(ff<_freq[ch_sel].start_freq || ff>_freq[ch_sel].end_freq)
				return;
			_marker[ch_sel].mark[_softkeyid1-38].freq=ff;
			mkr_xch = TRUE;
			aa=bit_cnt;
			bit_cnt_frq(_marker[ch_sel].mark[_softkeyid1-38].freq);
			bc_xch_f(key,aa);
			//marker_show2(_softkeyid1-40);
//			mkr_show_mark_all(_softkeyid-40-1+3);
			refr_menu_mkr_all(_softkeyid1-38);
			refresh_down_mark();
			cursor();
			break;
		case 6:
			if(index>0){
				set_marker();
				cnt=bit_cnt;
				x_pos=119+cnt*13;
			}
			if(key==DOWN)
				pp=_marker[ch_sel].marker_fun[_softkeyid1-61].power-counts*pow(10,(bit_cnt-cnt-2));
			else if(key==UP)
				pp=_marker[ch_sel].marker_fun[_softkeyid1-61].power+counts*pow(10,(bit_cnt-cnt-2));
//			max_min = max(Min(_freq[ch_sel].start_freq,_marker[ch_sel].cen_mkr.freq,ch_sel),
//					   Min(_marker[ch_sel].cen_mkr.freq,_freq[ch_sel].end_freq,ch_sel));
			if(_chab[ch_sel].flag==0){
//				if(pp<(max_min-_power[ch_sel].output_power-_marker[ch_sel].max_mkr.power))
//					pp=max_min-_power[ch_sel].output_power-_marker[ch_sel].max_mkr.power;
//				if(pp < 0)

			}
			else if(_chab[ch_sel].flag==1){
//				if(pp<(max_min-_marker[ch_sel].max_mkr.power))
//					pp=max_min-_marker[ch_sel].max_mkr.power;
			}
			else
				return;
//			if((pp<max(Min(_freq[ch_sel].start_freq,_marker[ch_sel].cen_mkr.freq,ch_sel),
//					   Min(_marker[ch_sel].cen_mkr.freq,_freq[ch_sel].end_freq,ch_sel))
//				||pp>=-0.001))
//				return;
			if(pp < 0)
				_marker[ch_sel].marker_fun[_softkeyid1-61].power=pp;
			mkr_xch = TRUE;
			aa=bit_cnt;
//			init_cur_pwr(_marker[ch_sel].marker_fun[_softkeyid1-60].power);
			bit_cnt_pwr(_marker[ch_sel].marker_fun[_softkeyid1-61].power);
			bc_xch_p(key,aa);
			refresh_down_mark();
			cursor();
			break;
		case 7:
			set_marker();
			if(_softkeyid1==73&&_softkeyid2==731){
				if(key==UP)
					pp=_marker[ch_sel].cen_mkr.set_attenuate+counts*pow(10,(bit_cnt-cnt-2));
				else if(key==DOWN){
					pp=_marker[ch_sel].cen_mkr.set_attenuate-counts*pow(10,(bit_cnt-cnt-2));
				}
				if(pp>=-0.001||pp<max(Min(_freq[ch_sel].start_freq,_marker[ch_sel].cen_mkr.freq,ch_sel),
					   Min(_marker[ch_sel].cen_mkr.freq,_freq[ch_sel].end_freq,ch_sel)))
					return;