key.c

通讯误码仪测试软件

/*
*********************************************************************************************************
*						MPT 1327
*					 Trunking radio system
*
*				  (c) Copyright 2002-2005, Hu Jia Xi  胡家熙
*					   All Rights Reserved
*
*					 M16C620  Specific code
*					   Singal Chip	Model
*
* File : key.C
* By   : Hu Jia Xi
*********************************************************************************************************
*/
#define 	KEY_GLOBALS
#include        "key.h"

const INT16U key_code_table[5][16]={0,0x2000,0x40,0x2040,0x1a,0x201a,0x5a,0x205a,0x20,0x2020,0x60,0x2060,0x3a,0x203a,0x7a,0x207a,
				    0,0x0400,0x17,0x0417,0x18,0x0418,0,0,0x19,0x0419,0,0,0,0,0,0,
				    0,0x1000,0x14,0x1014,0x15,0x1015,0,0,0x16,0x1016,0,0,0,0,0,0,
				    0,0x0800,0x11,0x0811,0x12,0x0812,0,0,0x13,0x0813,0,0,0,0,0,0,
				    0,0,0x80,0,0x0200,0x0200,0x0280,0x0280,0x0100,0x0100,0x0180,0x0100,0x0300,0x0300,0x0380,0x0380};
const INT8U key_num_table[16]={0,1,1,2,1,2,2,3,1,2,2,3,2,3,3,4};

const INT16U key_analyze_table[3][KSTATUS_ANALYZE_NUM]={
	KSTATUS_NORMAL_GROUP,KSTATUS_EDIT_GROUP,KSTATUS_DIAL_GROUP,KSTATUS_VOICE_GROUP,
	KSTATUS_NORMAL_MULTI,KSTATUS_EDIT_MULTI,KSTATUS_DIAL_MULTI,KSTATUS_VOICE_MULTI,
	KSTATUS_NORMAL_MMULTI,KSTATUS_EDIT_MMULTI,KSTATUS_DIAL_MMULTI,KSTATUS_VOICE_MMULTI};
INT8U key_wait_time;

void int_key()
{
 if(key_valid())
   {
    // ir_key = 0;
    enable_timer_key(LEVEL_KEY_TIMER);
    }
 }

void int_timer_key()
{
 switch(key_symbol.status){
 	case STATUS_KEY_SCAN:
		timer_key_counter++;
		if(!key_valid()) 
		  {
		   disable_timer_key();
		   break;
		   }
		if(timer_key_counter < KEY_TWITTER_NUM) break;
		key_scan(0);
	    	chang_timer_key_counter(T_KEYDOWN);
    		key_symbol.status = STATUS_KEY_DOWN;
    		key_symbol.end = 0;
    		key_symbol.fix = 0;
    		key_symbol.group = 0;
    		key_symbol.multi = 0;
    		key_symbol.mmulti = 0;
    	        encode_key(0);
    	        if(!get_keycode(0))
    	          {
    	           key_symbol.end = 1;
    	           break;	
    	           }
		if(key_symbol.group|key_symbol.multi) break;
		key_symbol.fix = 1;
		analyze_key();
    		break;

 	case STATUS_KEY_DOWN:
		timer_key_counter++;

		if(!key_valid())
		   {
		    key_symbol.status = STATUS_KEY_UP;
		    break;	
		    }
		analyze_key();
		break;

 	case STATUS_KEY_UP:
		timer_key_counter++;

		if(key_valid())
		   {
		    key_symbol.status = STATUS_KEY_DOWN;
		    break;	
		    }
		key_symbol.fix = 1;
		analyze_key();
		disable_timer_key();
		break;

	default:
		disable_timer_key();
		break;
	}	
 }

INT16U key_valid(void)
{
 port_keyscan &= (MASK_KEYSCAN^0x0ff);
 if((port_keyin & (MASK_KEYIN^0xff)) == (MASK_KEYIN^0xff)) return FALSE;
 return TRUE;	
 }

INT16U key_scan(INT8U type)
{
 INT8U i,j,k=0;
 INT8U scan_shift = MASK_SCANSHIFT;
 
 if(type)k=1;

 for(i = 0;i < KEYSCAN_LINE;i++)
    {
     port_keyscan |= MASK_KEYSCAN;
     port_keyscan &= (scan_shift ^ 0xff);
     j = 10;
     do{
	}while(j-- != 0);
     key_tmp[k][i] = (port_keyin ^ 0x0ff)&(MASK_KEYIN ^ 0x0ff);
     key_tmp[k][i] >>= 4;
     scan_shift = scan_shift << 1;
     }
 port_keyscan &= (MASK_KEYSCAN^0x0ff);
 return key_valid();
 }

 
void enable_key(INT8U int_level)
{
 intic_key = 0;
 intic_key = int_level;
}

void disable_key(void)
{
 intic_key = 0;
// key_symbol.status = STATUS_KEY_SCAN1;	
 }
 
void chang_timer_key_counter(INT16U counter)
{
 tsr_key_timer = 0;
 t_key_timer = counter;
 tsr_key_timer = 1;
 timer_key_counter = 0;
 }
 
void enable_timer_key(INT8U int_level)
{
 disable_key();
 chang_timer_key_counter(T_TWITTER);
 timer_key_counter = 0;
 key_symbol.status = STATUS_KEY_SCAN;	
 key_symbol.end = 0;	
 intic_key_timer = 0;
 intic_key_timer = int_level;
}

void disable_timer_key(void)
{
 tsr_key_timer = 0;
 intic_key_timer = 0;
 key_symbol.status = STATUS_KEY_IDLE;
 enable_key(LEVEL_KEY);	
 }
 
void init_key(void)
{
 portd_keyin &= MASK_KEYIN;  
 portd_keyscan |= MASK_KEYSCAN;
 port_keyscan &= (MASK_KEYSCAN ^0x0ff);

 key_buf_start = 0;
 key_buf_end = 0;
 key_buf_num = 0;
 
 pu25 = 1;			//upload
 
 tmr_key_timer = 0x80;		//f32
 tsr_key_timer = 0;

 enable_key(LEVEL_KEY);
 }

INT16U encode_key(INT8U type)
{
 INT8U i,j,k = 0,m=0;
 
 if(type) m=1;
 if(key_buf_num >= KEY_BUF_LENGTH) return FALSE;
 key_code_tmp[m]=0;
 
 for(i = 0;i < KEYSCAN_LINE;i++)
    {
     j = key_tmp[m][i];
     key_code_tmp[m] |= key_code_table[i][j];
     if((key_code_table[i][j]&0x0010)) k++;
     }
// if(k>1) key_code_tmp[m] &= 0x0ffe0;
 if(k>1) key_code_tmp[m] = 0x0;
 return TRUE;
 }

void analyze_key(void)
{
 INT16U i;
 
 if(key_symbol.end) return;
 
 if(key_symbol.fix)
   {
    save_keycode();
    if(key_symbol.mmulti)
      {
       key_symbol.end = 0;
       timer_key_counter = 0;
       key_symbol.fix = 0;
       }
    return;	
    }	

 if(key_symbol.group)
   {
    if(timer_key_counter < KEY_GROUP_NUM) return;
    key_symbol.fix = 1;
    key_symbol.group = 0;
    key_scan(1);
    encode_key(1);
    if(get_keycode(1))
      {
       if((key_code_tmp[1] & key_code_tmp[0]) == key_code_tmp[0]) key_code[0] = key_code[1];
       }
    } 

 if(key_symbol.multi)
   {
    if(timer_key_counter < key_wait_time) return;
    key_code[0] |= KCODE_MULTI_SYMBOL;
    key_symbol.fix = 1;
    }

 if(key_symbol.mmulti)
   {
    if(timer_key_counter < key_wait_time) return;
    key_code[0] |= KCODE_MULTI_SYMBOL;
    key_symbol.fix = 1;
    }
 
 if(key_symbol.fix)
   {
    save_keycode();
    if(key_symbol.mmulti)
      {
       key_symbol.end = 0;
       timer_key_counter = 0;
       key_symbol.fix = 0;
       }
    return;	
    }	
 }
 
INT16U get_keycode(INT8U type)
{
 INT16U i,j;
 
 i = 0;
 if(type) i =1;
 j = key_analyze_table[0][slcd.status] ^ 0xffff;
 ucode.code = key_code_tmp[i];

 if((ucode.code & key_analyze_table[0][slcd.status]) && (!key_symbol.fix))
   {
    if(ucode.code & j) return FALSE;	
    if(!i) key_symbol.group = 1;
    }

 if(ucode.code & key_analyze_table[1][slcd.status])
   {
    if(!i) 
      {
       key_symbol.multi = 1;
       key_wait_time = KEY_MULTI_NUM;
       }
    }

 if(ucode.code & key_analyze_table[2][slcd.status])
   {
    if(!i) 
      {
       key_symbol.mmulti = 1;
       key_wait_time = KEY_MMULTI_NUM;
       }
    }

 if(ucode.scode.dflag)			//数字按键不能和其他键复用
   {
    if(ucode.code & 0xffe0) return FALSE;	
    }

 return get_key_validcode(type);
 }
 
void save_keycode(void)
{
 key_symbol.end = 1;

 key_code_buf[key_buf_start] = key_code[0];	
 key_buf_start++;
 key_buf_num++;
 if(key_buf_start >= KEY_BUF_LENGTH) key_buf_start=0;
 }

INT16U get_key_validcode(INT8U type)
{
 INT16U i,j=0,k;
 if(ucode.scode.dflag) 
   {
    key_code[type] = ucode.scode.digit;
    return TRUE;
    }
 i = ucode.code >> 5;
 k = i&0xf;
 j += key_num_table[k];
 i = i >> 4;	
 k = i&0xf;
 j += key_num_table[k];
 i = i >> 4;	
 k = i&0xf;
 j += key_num_table[k];
 if(j == 0) return FALSE;
 if(j == 1)
   {
    if(ucode.scode.alarm)
      {
       key_code[type] = KCODE_ALARM;
       return TRUE;	
       }

    if(ucode.scode.power)
      {
       key_code[type] = KCODE_POWER;
       return TRUE;	
       }

    if(ucode.scode.up)
      {
       key_code[type] = KCODE_UP;
       return TRUE;	
       }

    if(ucode.scode.down)
      {
       key_code[type] = KCODE_DOWN;
       return TRUE;	
       }

    if(ucode.scode.onhook)
      {
       key_code[type] = KCODE_ONHOOK;
       return TRUE;	
       }

    if(ucode.scode.func)
      {
       key_code[type] = KCODE_FUNC;
       return TRUE;	
       }

    if(ucode.scode.clr)
      {
       key_code[type] = KCODE_CLR;
       return TRUE;	
       }

    if(ucode.scode.ok)
      {
       key_code[type] = KCODE_OK;
       return TRUE;	
       }

    if(ucode.scode.number)
      {
       key_code[type] = KCODE_NUMBER;
       return TRUE;	
       }

    if(ucode.scode.asterisk)
      {
       key_code[type] = KCODE_ASTERISK;
       return TRUE;	
       }

    return FALSE;	
    }

 return FALSE;	
 }