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

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

if((strcmp(dev[i].cur_string,Ani)==0)&&(dev[i].cur_num>=ANI_LEN))
fwsig=SIGI_15;
else
fwsig=(dev[i].cur_string[dev[i].cur_num]==＇0＇)?SIGI_10:(dev[i].cur_string[dev[i].cur_num]-0x31+SIGI_1);
dev[i].cur_num++;
break;
case　SIGA_6:
strcpy(dev[i].cur_string,Ani);
dev[i].cur_num=0;
fwsig=SIGI_1;
break;
case　SIGA_3:
dev[i].cur_num=-1;
fwsig=SIGII_3;
break;
default:
//end　MFC;
fwsig=SIGII_3;
dev[i].state=ST_WAITOFHK;
return　0;
break;
}

if(DEBUG)　printf("%s:　State　%2d,　In　dt_mfc(),　fwsig=%d\n",dev[i].voxname,dev[i].state,fwsig);
return　r2_playfsig(dev[i].vox,fwsig,EV_ASYNC);
}

/*****************************************************************
* Fuction　　　　:　dt_fwaon()
* Description:　Forward　hangup　after　end　of　play
******************************************************************/
int　　dt_fwaon(int　i)
{
InfoDebug(i,"dt_fwaon()");
if(dt_settssig(dev[i].dti,DTB_ABIT,DTA_ADDMSK)!=0){
printf("%s:　dt_settssig()　error.\n",dev[i].dtiname);
return　-1;
}
chan_init(i);
return　0;
}

/**************************************************************
* Fuction　　　　:　dt_bkaon()
* Description:　backward　hangup　during　play
****************************************************************/
int　　dt_bkaon(int　i)
{
InfoDebug(i,"In　dt_bkaon()");
dx_stopch(dev[i].vox,EV_ASYNC);
if(dt_settssig(dev[i].dti,DTB_ABIT,DTA_ADDMSK)!=0){
printf("%s:　dt_settssig()　error.\n",dev[i].dtiname);
return　-1;
}
chan_init(i);
return　0;
}

/*******************************************************************
*
* Fuction　　　　:　dt_getbksig()
* Description:　Get　backward　signal
*********************************************************************/
int　dt_getbksig(int　i)
{
InfoDebug(i,"In　dt_getbksig()");
cstp=(DX_CST*)sr_getevtdatap();
dev[i].bksig=cstp->cst_data;
return　0;
}

/********************************************************************
　* FUNCTION　NAME:　begin_dial()
　* DESCRIPTION:　to　initialize　state
　*　　RETURN:　
　*************************************************************/
int　begin_dial()
{
int　i;
static　int　start_ch=0;
time_t　endt;

endt=time(NULL);
for(i=start_ch;i<MAXCHAN;i++){
//to　delay　IDLE_TIME　seconds　between　two　calls
if((dev[i].state==ST_IDLE)&&(difftime(endt,dev[i].start_t)>1.0*IDLE_TIME)){
//channel　0..29;
dt_seize(i);
start_ch=(i>=MAXCHAN-1)?0:i++;　
return　0;
}
//to　check　SZ_ACK_TIME　seconds
if((dev[i].state==ST_SZ_ACK)&&(difftime(endt,dev[i].start_t)>1.0*SZ_ACK_TIME)){
//channel　0..29;
printf("%s:　Timeout　ST_SZ_ACK　+++++++++++　%2d\n",dev[i].dtiname,i);
chan_init(i);
start_ch=(i>=MAXCHAN-1)?0:i++;　
return　0;
}
//to　check　no　response　in　MFC_TIME　seconds　before　Seize　Acknowledge
if((dev[i].state==ST_MFC)&&(difftime(endt,dev[i].start_t)>1.0*MFC_TIME)){
printf("%s:　Timeout　ST_MFC　+++++++++++　%2d\n",dev[i].dtiname,i);
//printts(i);
chan_init(i);
start_ch=(i>=MAXCHAN-1)?0:i++;　
return　0;
}
//to　check　no　response　in　CYCLE_TIME　seconds　for　one　channel
if(difftime(endt,dev[i].start_t)>1.0*CYCLE_TIME){
printf("%s:　Channel　%d　timeout　for　one　cycle,　State　%d　++++++++\n",dev[i].dtiname,i,dev[i].state);
//printts(i);
chan_init(i);
start_ch=(i>=MAXCHAN-1)?0:i++;　
return　0;
}
}
return　0;
}


/*******************************************************************
　* Fuction　　　　:　dt_seize(i)
　* Description:　set　abit　off　(j<MAXCHAN)　prepare　to　dialout
　*******************************************************************/
int　dt_seize(int　i)
{
long　tsbits;
int　arcv,brcv,crcv,drcv,axmt,bxmt,cxmt,dxmt;
int　chan_ok=0;

InfoDebug(i,"In　dt_seize()");

if((tsbits=ATDT_TSSGBIT(dev[i].dti))==AT_FAILURE){
printf("ATDT_TSSGBIT()　error.\n");
return　-1;
}
arcv=(tsbits　&　DTSG_RCVA)?1:0;
brcv=(tsbits　&　DTSG_RCVB)?1:0;
crcv=(tsbits　&　DTSG_RCVC)?1:0;
drcv=(tsbits　&　DTSG_RCVD)?1:0;
axmt=(tsbits　&　DTSG_XMTA)?1:0;
bxmt=(tsbits　&　DTSG_XMTB)?1:0;
cxmt=(tsbits　&　DTSG_XMTC)?1:0;
dxmt=(tsbits　&　DTSG_XMTD)?1:0;

chan_ok=(arcv==1)&&(brcv==0)&&(crcv==1)&&(drcv==1);
if(!chan_ok){
if(DEBUG)printf("%s:　RX(%d%d%d%d)　******　CPE　Not　Ready　*****　%2d\n",
dev[i].dtiname,arcv,brcv,crcv,drcv,i);
chan_init(i);
return　0;
}

chan_ok=(axmt==1)&&(bxmt==0)&&(cxmt==1)&&(dxmt==1);
if(!chan_ok){
if(DEBUG)printf("%s:　TX(%d%d%d%d)　******　CO　Not　Ready　*****　%2d\n",
dev[i].dtiname,axmt,bxmt,cxmt,dxmt,i);
chan_init(i);
return　0;
}

if(dt_settssig(dev[i].dti,DTB_ABIT,DTA_SUBMSK)!=0){
printf("%s:　dt_settssig()　error.\n",dev[i].dtiname);
return　-1;
}
dev[i].state=ST_SZ_ACK;
time(&dev[i].start_t);
return　0;
}

/***************************************************************
　*　　　　　　　　NAME:　void　sysinit()
　*　DESCRIPTION:　Start　System
　****************************************************************/
void　sysinit(void)
{
int　i;

promptfh=dx_fileopen("sample.vox",O_RDONLY|O_BINARY);
if(promptfh<=0){
printf("File　SAMPLE.VOX　not　found,　please　　copy　it　to　the　current　directory.\n");
exit(0);
};

printf("D/300SC-E1　Dial　out　demo　program　for　Windows　NT\n");
printf("From　Dialogic　Beijing　Office\n");
printf("Please　wait　opening　channels\n");
for　(i　=　0;　i　<　MAXCHAN;　i++)　{
strcpy(dev[i].voxname,voxchannels[i]);
if　((dev[i].vox　=　dx_open(dev[i].voxname,　0))　==　-1)　{
printf("%s:　Error　opening　this　channel\n",dev[i].voxname);
exit(1);
}
strcpy(dev[i].dtiname,dtichannels[i]);
if　((dev[i].dti　=　dt_open(dev[i].dtiname,　0))　==　-1)　{
printf("%s:　Error　opening　this　channel\n",dev[i].dtiname);
exit(1);
}
sprintf(dev[i].dnis,"1%02d",i);
printf("dnis=%s\n",dev[i].dnis);

if(nr_scunroute(dev[i].dti,SC_DTI,dev[i].vox,SC_VOX,SC_FULLDUP)==-1){
printf("%s　<===　UnRoute　Failed　===>　%s\n",dev[i].voxname,dev[i].dtiname);
printf("Reason:　%s\n",ATDV_ERRMSGP(dev[i].vox));
exit(1);
} 

if(nr_scroute(dev[i].dti,SC_DTI,dev[i].vox,SC_VOX,SC_FULLDUP)==-1){
printf("%s　<===　Route　Failed　===>　%s\n",dev[i].voxname,dev[i].dtiname);
printf("Reason:　%d,%s\n",ATDV_LASTERR(dev[i].vox),ATDV_ERRMSGP(dev[i].vox));
exit(1);
}

r2_creatbsig(dev[i].vox);

if(dt_setevtmsk(dev[i].dti,DTG_SIGEVT,DTMM_AON|DTMM_AOFF|DTMM_BON|DTMM_BOFF,DTA_SETMSK)==-1){
printf("%s:　dt_setevtmsk()\n",dev[i].dtiname);
exit(1);
}

if(dt_settssig(dev[i].dti,DTB_ABIT|DTB_CBIT|DTB_DBIT,DTA_SETMSK)==-1){
printf("dt_settssig()\n");
exit(1);
}
chan_init(i);
printf(".");

}

play_init();
printf("\nAll　Channels　opened,　dial　out　now.\n");

}

/***************************************************************
　* FUNCTION　NAME:　play_init()
　* DESCRIPTION:　to　initialize　tonegen　and　r2_tpt
　*　　RETURN:　
　****************************************************************/

int　play_init(void)
{
int　i;

memset(tngen,0,sizeof(tngen));
for(i=0;i<15;i++)
dx_bldtngen(&tngen[i],fsig[i][0],fsig[i][1],R2_DEFAMPL,R2_DEFAMPL,200);

memset(r2_tpt,0,sizeof(r2_tpt));

r2_tpt[0].tp_type=IO_CONT;
r2_tpt[0].tp_termno=DX_TONE;
r2_tpt[0].tp_length=SIGA_1;
r2_tpt[0].tp_flags=TF_TONE;
r2_tpt[0].tp_data=DX_TONEON;

r2_tpt[1].tp_type=IO_CONT;
r2_tpt[1].tp_termno=DX_TONE;
r2_tpt[1].tp_length=SIGA_6;
r2_tpt[1].tp_flags=TF_TONE;
r2_tpt[1].tp_data=DX_TONEON;

r2_tpt[2].tp_type=IO_CONT;
r2_tpt[2].tp_termno=DX_TONE;
r2_tpt[2].tp_length=SIGA_3;
r2_tpt[2].tp_flags=TF_TONE;
r2_tpt[2].tp_data=DX_TONEON;

r2_tpt[3].tp_type=IO_CONT;
r2_tpt[3].tp_termno=DX_TONE;
r2_tpt[3].tp_length=SIGB_1;
r2_tpt[3].tp_flags=TF_TONE;
r2_tpt[3].tp_data=DX_TONEON;

r2_tpt[4].tp_type=IO_EOT;
r2_tpt[4].tp_termno=DX_MAXTIME;
r2_tpt[4].tp_length=300;
r2_tpt[4].tp_flags=TF_10MS;

　　　memset(play_tpt,0,sizeof(play_tpt));
　　　/*　Terminate　Play　on　Receiving　any　DTMF　tone　*/
　　　play_tpt[0].tp_type　=　IO_CONT;
　　　play_tpt[0].tp_termno　=　DX_MAXDTMF;
　　　play_tpt[0].tp_length　=　1;
　　　play_tpt[0].tp_flags　=　TF_MAXDTMF;

　　　/*　Terminate　　on　MAXTIME　*/
　　　play_tpt[1].tp_type　=　IO_EOT;
　　　play_tpt[1].tp_termno　=　DX_MAXTIME;
　　　play_tpt[1].tp_length　=　10*PLAY_TIME;
　　　play_tpt[1].tp_flags　=　TF_MAXTIME;

play_iott.io_type=IO_DEV|IO_LINK;
play_iott.io_bufp=0;
play_iott.io_offset=0;
play_iott.io_length=-1;
play_iott.io_fhandle=promptfh;
play_iott.io_nextp=&play_iott;

return　0;
}

/*************************************************************
*
* Fuction　　　　:　dt_playf()
* Description:　Set　up　IOTT　and　TPT＇s　and　Play-Back　sample.vox
*************************************************************/
int　dt_playf(int　i)
{
time_t　end_t;

//play　sample.vox　file
dev[i].cur_num=0;
　　　dx_clrdigbuf(dev[i].vox);
/*　Play　VOX　File　on　D/4x　Channel,　Normal　Play　Back　*/
　　　
if　(dx_play(dev[i].vox,&play_iott,&play_tpt,PM_TONE|EV_ASYNC)==-1　){
　　　　　　InfoDebug(i,"In　dt_playf()");
return　-1;
　　　}

time(&end_t);
printf("%s:　%2d,　%4.1fs　MFC,　Playing...\n",dev[i].voxname,i,difftime(end_t,dev[i].start_t));
return　0;
}

/*************************************************************
　*　　Function:　InfoDebug(int　channel,　char　*　FunctionName).　
　*************************************************************/
int　InfoDebug(int　channel,　char　*　FunctionName)
{
if　(DEBUG)　{
printf("%s:　State　%2d,　%s\n",dev[channel].voxname,dev[channel].state,FunctionName);
　　　printts(channel);
}
return　0;
}

/*******************************************************************
*　Name:　printts()
*　Function:　To　show　the　RX　and　TX　bits.
*
********************************************************************/
int　printts(int　i)
{
long　tsbits;
int　arcv,brcv,crcv,drcv,axmt,bxmt,cxmt,dxmt;

if((tsbits=ATDT_TSSGBIT(dev[i].dti))==AT_FAILURE){
printf("ATDT_TSSGBIT()　error.\n");
return　-1;
}
arcv=(tsbits　&　DTSG_RCVA)?1:0;
brcv=(tsbits　&　DTSG_RCVB)?1:0;
crcv=(tsbits　&　DTSG_RCVC)?1:0;
drcv=(tsbits　&　DTSG_RCVD)?1:0;
axmt=(tsbits　&　DTSG_XMTA)?1:0;
bxmt=(tsbits　&　DTSG_XMTB)?1:0;
cxmt=(tsbits　&　DTSG_XMTC)?1:0;
dxmt=(tsbits　&　DTSG_XMTD)?1:0;
printf("%s:　TX=%d%d%d%d,　RX=%d%d%d%d\n",
dev[i].dtiname,
axmt,bxmt,cxmt,dxmt,arcv,brcv,crcv,drcv);
return　0;
}

/******************************************************************
* PRO