编写d300sc-e1卡呼出程序.txt

编写D300SC-E1卡呼出程序 编写D300SC-E1卡呼出程序

int　(*funcptr)(int);
}TABLE;

/*　Other　defines　*/
#define　TABLE_SIZE　　　6

TABLE　table[TABLE_SIZE]=
　　　　　　{/*current_state　　dev_type　　event　　　　　　　　next_stat　　　　function　*/
　　　　　　{　ST_SZ_ACK,　　　　　　SC_DTI,　　　DTMM_BON,　　　　ST_MFC,　　　　　　dt_mfc　　　　},
　　　　　　{　ST_MFC,　　　　　　　　　SC_VOX,　　　DE_TONEON,　　　ST_MFC,　　　　　　dt_getbksig},
　　　　　　{　ST_MFC,　　　　　　　　　SC_VOX,　　　DE_TONEOFF,　　ST_MFC,　　　　　　dt_mfc　　　　},
　　　　　　{　ST_MFC,　　　　　　　　　SC_DTI,　　　DTMM_BOFF,　　　ST_IDLE,　　　　　dt_bwboff　},
　　　　　　{　ST_WAITOFHK,　　　　SC_DTI,　　　DTMM_AOFF,　　　ST_PLAYFILE,　dt_playf　　},
　　　　　　{　ST_PLAYFILE,　　　　SC_VOX,　　　TM_EOD,　　　　　　ST_IDLE,　　　　　dt_fwaon　　},
//　{Specify　your　own　State　Machine　Table　Items　here}
};

int　EventType;　//Dialogic　Event　Type;
int　DevType;　//Dialogic　Event　Device

/****************************************************************
* Fuction　　　　:　main()
* Description:　
*****************************************************************/
int　main()
{
sysinit();
wait_event(); 
return　0;
}

/*****************************************************************
*　Name:　　check_event()
*　Input:　int　channel　cur_num
*　　　　　　　　　　　　　　　　int　voice/msi　events
*　Des:　　　It　checks　the　current　state　of　a　channel,　look　up　in　the　state　
*　　　　　　　　　　　　　　　　for　the　next　state　of　the　channel　depanding　on　the　event　received
*　　　　　　　　　　　　　　　　sets　the　next　state　and　initiates　the　apprpriate　func.
*******************************************************************/
int　check_event(int　channel,　int　event)
{
　　　int　i;
　　　int　(*func_ptr)(int);

　　　//Hangup　detection　is　the　first　priority
　　　if((DevType==SC_DTI)&&(EventType==DTEV_SIG)&&(event==DTMM_AON))　{
printf("%s:　DTMM_AON　received\n",dev[channel].dtiname);
dt_bkaon(channel);
　　　　　　return　0;
　　　}

　　　for　(i=0;　i<　TABLE_SIZE;　i++)
　　　　　　if((dev[channel].state==table[i].current_state)　&&　
(DevType==table[i].dev_type)&&(table[i].event==event)){
func_ptr　=　table[i].funcptr;
if(DEBUG)　printf("%s:　Current　State　=%d,　Event　Function　Number　is　(%d)\n",dev[channel].voxname,dev[channel].state,i);
dev[channel].state　=　table[i].next_state;
return　(*func_ptr)(channel);
break;
　　　　　　}
return　-1;
}


/*****************************************************************
*　Name:　　　process_event
*　Input:　　int　channel　cur_num
*　output:　returns　a　voice　event
*　Des:　　　　It　retreives　voice　events　on　a　channel　by　calling　sr_getevttype()
*　　　　　　　　　　　　　　　　　sr_getevtdatap()　and　returns　it　to　the　wait_event()
*
*
******************************************************************/
int　process_event(int　channel)
{
　　　int　event;
int　index;
int　*datap;
　　　long　term;
　　　DX_CST　*cstp;
　　　
EventType　=　sr_getevttype();

　　　if((DevType==SC_DTI)&&(EventType==DTEV_SIG))
{
//printf("---　EVENT　TYPE:　DTEV_SIG\n");
datap=(int*)sr_getevtdatap();
　　　 for(index=0;index<4;index++){
switch　(*datap&(0x1111<<index)){
case　DTMM_AON:
//printf("---　EVENT　DATA:　DTMM_AON\n");
return　DTMM_AON;
break;
case　DTMM_AOFF:
//printf("---　EVENT　DATA:　DTMM_AOFF\n");
return　DTMM_AOFF;
break;
case　DTMM_BON:
//printf("---　EVENT　DATA:　DTMM_BON\n");
return　DTMM_BON;
break;
case　DTMM_BOFF:
//printf("---　EVENT　DATA:　DTMM_BOFF\n");
return　DTMM_BOFF;
break;
}//END　CASE 
}//END　FOR
//Specify　your　own　event　here
}

　　　if(DevType==SC_VOX)　
switch(EventType){
case　TDX_CST:
//printf("---　EVENT　TYPE:　TDX_CST\n");
cstp=(DX_CST*)sr_getevtdatap();
switch　(cstp->cst_event){
case　DE_TONEON:
//printf("---　EVENT　DATA:　DE_TONEON\n");
return　DE_TONEON;
break;
case　DE_TONEOFF:
//printf("---　EVENT　DATA:　DE_TONEOFF\n");
return　DE_TONEOFF;
break;
}

case　TDX_PLAY:　/*　Play　ENDS*/
//printf("---　EVENT　TYPE:　TDX_PLAY\n");
term=ATDX_TERMMSK(dev[channel].vox);
if(term　&　TM_USRSTOP)
printf("%s:　Play　ended　by　TM_USRSTOP\n",dev[channel].voxname); 
if(term　&　TM_MAXTIME)
printf("%s:　Play　ended　by　TM_MAXTIME\n",dev[channel].voxname); 
if(term　&　TM_EOD)
printf("%s:　Play　ended　by　TM_EOD\n",dev[channel].voxname); 
return　TM_EOD; 
break;
case　TDX_PLAYTONE:
//printf("---　EVENT　DATA:　TDX_PLAYTONE\n");
return　TM_TONE;
break;
/***********************************************************
From　here　you　can　specify　your　own　Event　type　and　Event　data
case　Event_Type(You　want):
return　Event_Data(you　want);
break;
***********************************************************/
default:
//printf("---　EVENT　TYPE　AND　DATA:　0X%X　UNKNOWN\n",event);
return　event;
break;
}　　//　end　switch
}

/*******************************************************************
*　NAME:　　　wait_event()
*　Input:　　None
*　Des:　　　　It　blocks　at　sr_waitevt()　and　　wait　for　events,　once　the　event　is
*　　　　　　　　　　　　　　　　　received,　it　find　out　the　device　and　channel　cur_num　and　calls
*　　　　　　　　　　　　　　　　　process_events()　for　voice　and　ms_process_event()　for　msi　events.
*　　　　　　　　　　　　　　　　　After　getting　an　event,　it　calls　check_events()　to　initiate　the
*　　　　　　　　　　　　　　　　　appropriate　function.
*******************************************************************/
void　wait_event()
{
　　　int　channel;
　　　int　chdev;
　　　int　event;
char　key;

while　(　1　)　　{
if(_kbhit()){
key=_getch();
if(key==27)　break;//while
}
begin_dial();
　　　　　　/*　Wait　for　Completion　of　an　Event　*/
　　　　　　if(sr_waitevt(0)==-1){
continue;
}
//printf("-----------------　Event　comes.　---------------\n");
　　　　　　//　Get　the　channel　cur_num　from　which　the　event　was　received.
　　　　　　　
　　　　　　channel　=　0;
　　　　　　chdev　=　sr_getevtdev();
　　　　　　while　(channel　<　MAXCHAN)　{
if(dev[channel].dti==chdev)
{
DevType=SC_DTI;
break;
}
if(dev[channel].vox==chdev)
{
DevType=SC_VOX;
break;
}
channel++;
　　　　　　}
if(DEBUG)　printts(channel);
event　=　process_event(channel);
check_event(channel,event);
　　　}　/*　end　while　*/
end_prog();
}


/***************************************************************
*　Name　:　end_prog()
*　Input:　none.
*　Des:　　　This　function　stops,　setonhook　and　closes　all　channels
*
******************************************************************/
int　end_prog()
{
int　i;
printf("\nClosing　channels\n");
for(i=0;i<MAXCHAN;i++){
dx_stopch(dev[i].vox,EV_ASYNC);
dt_fwaon(i);
dx_close(dev[i].vox);
dt_close(dev[i].dti);
printf(".");
}
dx_fileclose(promptfh);
printf("\nAll　channels　closed.\n");
return　0;
}


/*****************************************************************
* Fuction　　　　:　dt_bwboff()
* Description:　Backword　hangup　during　MFC
*****************************************************************/
int　dt_bwboff(int　i)
{
int　retval;

dx_stopch(dev[i].vox,EV_ASYNC);
//backword　signal　hangs　up　first
//BW:11-->10
if((retval=dt_settssig(dev[i].dti,DTB_ABIT,DTA_ADDMSK))!=0){
printf("%s:　dt_settssig()　in　dt_bwboff()　error\n",dev[i].dtiname);
return　-1;
}

return　chan_init(i);
}

/***************************************************************
* Fuction　　　　:　dt_bwbon()
* Description:　Backward　hangup　
*****************************************************************/
int　dt_bwbon(int　i)
{
int　retval;

InfoDebug(i,"In　dt_bkbon()");
//Seize_acknowledge
//BW:10-->11　after　FW:10-->00
if((retval=dt_settssig(dev[i].dti,DTB_BBIT,DTA_ADDMSK))!=0){
printf("%s:　dt_settssig()　in　dt_bkohhk()\n",dev[i].dtiname);
return　-1;
}
chan_init(i);
return　0;//successful
}******************************************************
　*　　　　　　　　　　Name:　int　chan_init(int　i)
　*　　　　　　Function:　set　dti　device　on　hook
　* 　　　　Parameter:　channel　cur_num
　*　　Return　value:　0,　if　successful
　* 　:　-1,　unsuccessful 　
　********************************************************/
int　chan_init(int　i)
{
InfoDebug(i,"In　chan_init()");
strcpy(dev[i].cur_string,dev[i].dnis);
dev[i].cur_num=0;
dev[i].state=ST_IDLE;
dev[i].bksig=SIGA_1;
time(&dev[i].start_t);
dt_settssigsim(dev[i].dti,DTB_AON|DTB_BOFF|DTB_CON|DTB_DON);
return　0;
}

/****************************************************************
　* FUNCTION　NAME:　r2_creatbsig()
　* DESCRIPTION:　to　build　backward　signal　detection
　* INPUT:　voice　device　handle
　*　　RETURN:　
　***************************************************************/
int　r2_creatbsig(int　voxdev)
{
int　td;

if(dx_deltones(voxdev)==-1){
printf("dx_deltones()\n");
return　-1;
}

for(td=SIGA_1;td<=SIGA_15;td++){
if(dx_blddt(td,bsig[td-SIGA_1][0],50,bsig[td-SIGA_1][1],50,TN_LEADING)==-1){
printf("dx_blddt　error\n");
return　-1;
}
if(dx_addtone(voxdev,NULL,0)==-1)　{
printf("dx_addtone　error\n");
return　-1;
}
}
return　0;
}

/*****************************************************************
　* FUNCTION　NAME:　r2_playfsig()
　* DESCRIPTION:　to　play　a　forward　signal
　* INPUT:　voice　device　handle,　forwardsig,　and　play　mode
　*　　RETURN:　if　in　EV_SYNC　mode　the　return　the　terminate　backward　ToneID
　******************************************************************/
int　r2_playfsig(int　voxdev,　int　forwardsig,　int　mode)
{
int　i,bksig;
int　term;

for(i=0;i<MAXCHAN;i++)　
if　(dev[i].vox==voxdev){
InfoDebug(i,"In　r2_playfsig()");
break;
}

i=forwardsig　-　SIGI_1;

if(mode==EV_ASYNC)　return　dx_playtone(voxdev,&tngen[i],r2_tpt,mode);
/*　ELSE　mode==EV_SYNC,　return　ToneID　*/
if(dx_playtone(voxdev,&tngen[i],r2_tpt,EV_SYNC)==-1){
printf("%s:　Error　in　dx_playtone　%s\n",ATDV_NAMEP(voxdev),ATDV_ERRMSGP(voxdev));
return　-1;
} 
if((term=ATDX_TERMMSK(voxdev))==-1){
printf("%s:　ATDX_TERMMSK　error\n",ATDV_NAMEP(voxdev));
return　-1;
}
if(term&TM_TONE){
if((bksig=ATDX_TONEID(voxdev))==-1){
printf("%s:　ATDX_TONEID　error\n",ATDV_NAMEP(voxdev));
return　-1;
}
return　bksig;
}　else　{
printf("%s:　No　Backward　Signal　Detect\n",ATDV_NAMEP(voxdev));
return　-1;
}
}

/******************************************************************
* Fuction　　　　:　dt_mfc()
* Description:　MultiFrequencyControl　Procedure
*******************************************************************/
int　dt_mfc(int　i)
{
int　fwsig;
time_t　end_t;

time(&end_t);
if((dev[i].cur_num==0)&&(strcmp(dev[i].cur_string,dev[i].dnis))==0){
printf("%s:　ST_SZ_ACK　time　%4.1f\n",dev[i].dtiname,difftime(end_t,dev[i].start_t));
}
switch　(dev[i].bksig)　{
case　SIGA_1:　
if(dev[i].cur_num==-1){
dev[i].state=ST_WAITOFHK;
return　0;
};