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

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

#include<dxxxlib.h>
#include<dtilib.h>
#include<sctools.h>

#define　MAXCHAN　30　　　　　　　　//Maximum　number　of　channels　allowed.　
#define　MAXTHREAD　MAXCHAN　//For　multi-threading:-　Maximum　#　of　threads　
#define　DNIS_LEN　3　　　　　　　　//The　Dialed　Number　Identification　Number　Service　length,　can　change
#define　ANI_LEN　　7　　　　　　　　　//The　Automatic　Number　identification　length,　can　change

#define　PLAY_TIME　　　60　　//seconds　to　play　sample.vox
#define　SZ_ACK_TIME　　6　　//seconds　to　wait　seize　acknowladge
#define　IDLE_TIME　　　10　　//seconds　before　next　dial

char　Dnis[DNIS_LEN+3]={"321"};
char　Ani[ANI_LEN+3]={"1234567"};

DV_TPT　r2_tpt[6];
TN_GEN　tngen[15];
DX_IOTT　play_iott;
DV_TPT　play_tpt;

char　*voxchannels[]　=　{
　　　"dxxxB1C1"　,　"dxxxB1C2"　,　"dxxxB1C3"　,　"dxxxB1C4",
　　　"dxxxB2C1"　,　"dxxxB2C2"　,　"dxxxB2C3"　,　"dxxxB2C4",
　　　"dxxxB3C1"　,　"dxxxB3C2"　,　"dxxxB3C3"　,　"dxxxB3C4",
　　　"dxxxB4C1"　,　"dxxxB4C2"　,　"dxxxB4C3"　,　"dxxxB4C4",
　　　"dxxxB5C1"　,　"dxxxB5C2"　,　"dxxxB5C3"　,　"dxxxB5C4",
　　　"dxxxB6C1"　,　"dxxxB6C2"　,　"dxxxB6C3"　,　"dxxxB6C4",
　　　"dxxxB7C1"　,　"dxxxB7C2"　,　"dxxxB7C3"　,　"dxxxB7C4",
　　　"dxxxB8C1"　,　"dxxxB8C2"　,　
NULL,
};

char　*dtichannels[]　=　{
　　　"dtiB1T1"　,　"dtiB1T2"　,　"dtiB1T3"　,　"dtiB1T4",
　　　"dtiB1T5"　,　"dtiB1T6"　,　"dtiB1T7"　,　"dtiB1T8",
　　　"dtiB1T9"　,　"dtiB1T10",　"dtiB1T11",　"dtiB1T12",
　　　"dtiB1T13",　"dtiB1T14",　"dtiB1T15",　"dtiB1T16",
　　　"dtiB1T17",　"dtiB1T18",　"dtiB1T19",　"dtiB1T20",
　　　"dtiB1T21",　"dtiB1T22",　"dtiB1T23",　"dtiB1T24",
　　　"dtiB1T25",　"dtiB1T26",　"dtiB1T27",　"dtiB1T28",
　　　"dtiB1T29",　"dtiB1T30",　
　　　NULL,
};

int　fsig[15][2]={
{1380,1500},{1380,1620},{1500,1620},{1380,1740},{1500,1740},
{1620,1740},{1380,1860},{1500,1860},{1620,1860},{1740,1860},
{1380,1980},{1500,1980},{1620,1980},{1740,1980},{1860,1980}
};

int　bsig[15][2]={
{1140,1020},{1140,　900},{1020,　900},{1140,　780},{1020,　780},
{　900,　780},{1140,　660},{1020,　660},{　900,　660},{　780,　660},
{1140,　540},{1020,　540},{　900,　540},{　780,　540},{　660,　540}
};

typedef　struct　CHANNEL　{
int　vox;
int　dti;
int　hook;
char　voxname[20];
char　dtiname[20];
}　;
struct　CHANNEL　dev[MAXCHAN];

//　Declarations　for　the　multithreaded　part
DWORD　WINAPI　ThreadProc(int　*);
/*　You　can　specify　either　of　the　two　hangup-detect　methods　to
　　　detect　BON　event　from　CPE　*/
DWORD　WINAPI　hangup_detection(int　*);
int　Aon_handler(int);　//handler
int　r2_playfsig(int　voxdev,　int　forwardsig,　int　mode);
int　r2_creatbsig(int　voxdev);
int　dt_onhook_out(int　i);
int　printts(int　i);
int　dialout(int　i,　char　*dnis,　char　*ani);
void　printstart(void);
int　play_init(void);

/*************************************************************************
　*　　　　　　　　NAME　:　main()
　*　DESCRIPTION　:　Entry　point　to　application.
　*　　　　　RETURNS　:　0.
　*　　　　CAUTIONS　:　none.
　*************************************************************************/
int　main(void)
{
int　　　　i,　handle[MAXCHAN];
HANDLE　hThread[MAXTHREAD],tThread;
DWORD　　dwThreadId;

printstart();
//printf("DTEV_SIG=%d,　DTG_SIGEVT=%d\n",DTEV_SIG,DTG_SIGEVT);
play_init();
//　Open　all　channels 
for　(i　=　0;　i　<　MAXCHAN;　i++)　{
strcpy(dev[i].voxname,voxchannels[i]);
strcpy(dev[i].dtiname,dtichannels[i]);
if　((dev[i].vox　=　dx_open(dev[i].voxname,　0))　==　-1)　{
printf("Error　opening　channel　%s\n",dev[i].voxname);
exit(1);
}
if　((dev[i].dti　=　dt_open(dev[i].dtiname,　0))　==　-1)　{
printf("Error　opening　channel　%s\n",dev[i].dtiname);
exit(1);
}
if(nr_scroute(dev[i].dti,SC_DTI,dev[i].vox,SC_VOX,SC_FULLDUP)==-1){
printf("Can　not　route　SC.%d\n",i);
exit(1);
}
//set　tone　detection
if(r2_creatbsig(dev[i].vox)==-1){
printf("r2_creatfsig()　error.\n");
return　-1;
}
dev[i].hook=DX_ONHOOK;
printf(".");
}
dt_setevtmsk(EV_ANYDEV,DTG_SIGEVT,DTMM_AON,DTA_SETMSK);
printf("\nAll　Channels　opened.\n");

//　Spawn　off　a　thread　for　each　channel

for　(i　=　0;　i　<　MAXTHREAD;　i++)　{
handle[i]=i;
hThread[i]　=　CreateThread(NULL,　0,　ThreadProc,　&(handle[i]),
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　CREATE_SUSPENDED,　&dwThreadId);
SetThreadPriority(hThread[i],　THREAD_PRIORITY_NORMAL);
}

for　(i　=　0;　i　<　MAXTHREAD;　i++)　{
ResumeThread(hThread[i]);
Sleep(50);
}
　　　/*
tThread　=　CreateThread(NULL,　0,　hangup_detection,　&(handle[1]),
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　CREATE_SUSPENDED,　&dwThreadId);
SetThreadPriority(tThread,　THREAD_PRIORITY_NORMAL);
ResumeThread(tThread);
　　　*/
WaitForMultipleObjects(min(MAXTHREAD,64),　hThread,　TRUE,　INFINITE);
/*
if　(MAXTHREAD　>　MAXIMUM_WAIT_OBJECTS)　{
WaitForMultipleObjects(MAXTHREAD　-　MAXIMUM_WAIT_OBJECTS,
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　&(hThread[MAXIMUM_WAIT_OBJECTS]),　TRUE,　INFINITE);
}
*/
printf("Exiting　the　program\n");

for　(i　=　MAXCHAN-1;　i　=　0;　i--)　{
if　(dx_close(dev[i].vox)　==　-1)　{
printf("Error　closing　channel　%s\n",dev[i].voxname);
exit(1);
}
if　(dt_close(dev[i].dti)　==　-1)　{
printf("Error　closing　channel　%s\n",dev[i].dtiname);
exit(1);
}
printf("-\n");
}
printf("All　Channels　closed.\n");
for　(i　=　0;　i　<　MAXTHREAD;　i++)　CloseHandle(hThread[i]);

CloseHandle(tThread);
　　　
return　0;
}

/*************************************************************************
　*　　　　　　　　NAME　:　ThreadProc(i)
　*　DESCRIPTION　:　Each　threads　starting　routine.
　*　　　　　　　INPUT　:　i　=　Chanel　device　subscript
　*　　　　　　OUTPUT　:　none
　*　　　　　RETURNS　:　none
　*　　　　CAUTIONS　:　none
　*************************************************************************/
DWORD　WINAPI　ThreadProc(int　*channel)
{
char　chan[4];
int　i=2;

while(1){
if(MAXCHAN　==　1){ 
printf("\n\nPlease　input　the　telephone　number　you　want　to　dial　to:　");
gets(Dnis);
printf("Please　input　the　channel　number　you　want　to　use　(1..30):　");
gets(chan);
i=atoi(chan);
if((i<1)　||　(i>30))　{
printf("Invalid　channel　number,　use　default　1.\n");
i=1;
} 
i--;
}　else　{　i=*channel;　}　

dt_onhook_out(i);
printf("%s:　%2d　OnHook\n",dev[i].dtiname,i);
//printts(i);
Sleep(IDLE_TIME　*　1000);
printf("%s:　%2d　Dialing　%s...\n",dev[i].voxname,i,Dnis);
if(dialout(i,Dnis,Ani)==-1){
printf("%s:　Unsuccessful　Dial.\n",dev[i].voxname);
continue;
}
dev[i].hook=DX_OFFHOOK;
if(sr_enbhdlr(dev[i].dti,DTEV_SIG,Aon_handler)==-1){
printf("sr_enbhdlr()\n");
exit(1);
}

printf("%s:　%2d　OffHook,　Playing...\n",dev[i].voxname,i);

if(dx_play(dev[i].vox,&play_iott,&play_tpt,PM_TONE|EV_SYNC)==-1)
printf("Error　playing　file,　%s\n",ATDV_ERRMSGP(dev[i].vox));

if(dev[i].hook==DX_ONHOOK){
printf("%s:　%2d　User　hangup　first.\n",dev[i].voxname,i);
}　
if(sr_dishdlr(dev[i].dti,DTEV_SIG,Aon_handler)==-1){
printf("sr_enbhdlr()\n");
exit(1);
} 
}

return　0L;
}

/***************************************************************************
　* FUNCTION　NAME:　dialout()
　* DESCRIPTION:　give　an　outbound　dial
　* INPUT:　device　handle　and　dialstring
　*　　RETURN:　
　**************************************************************************/
int　dialout(int　i,　char　*dnis,　char　*ani)
{
int　cur_num=0;
int　time=0,timeout=15000;//15　seconds　if　no　answer
long　tsbits;
int　arcv,brcv,axmt,bxmt;
int　fwsig,bksig;
int　voxdev=dev[i].vox,dtidev=dev[i].dti;


//set　1011-->0011　and　waits　for　1111
if(dt_settssig(dtidev,DTB_ABIT,DTA_SUBMSK)!=0){
printf("%s:　dt_settssig()　error.\n",dev[i].voxname);
return　-1;
}
do{
Sleep(40);
time+=40;
if((tsbits=ATDT_TSSGBIT(dtidev))==AT_FAILURE){
printf("%s:　ATDT_TSSGBIT()　error\n",dev[i].voxname);
return　-1;
}
arcv=(tsbits　&　DTSG_RCVA)?1:0;
brcv=(tsbits　&　DTSG_RCVB)?1:0;
axmt=(tsbits　&　DTSG_XMTA)?1:0;
bxmt=(tsbits　&　DTSG_XMTB)?1:0;
//printf("RX(%d,%d);TX(%d,%d)\n",arcv,brcv,axmt,bxmt);
if(time>(1000*SZ_ACK_TIME)){
printf("%s:　Timeout　waiting　for　Seize　Ack\n",dev[i].voxname);
return　-1;
}
}while(!((arcv==1)&&(brcv==1)&&(axmt==0)&&(bxmt==0)));

//Multiple　Frequency　Control　Process　Starts
//----------　D　N　I　S　---------x-------　A　N　I　-----------
//FW:　6　　5　　0　　4　　5　　3　　6　　5　　x　　1　　2　　3　　4　　5　　6　　7　　SIGI_15　SIGII_3
//BW:　　A1　A1　A1　A1　A1　A1　A1　A6　A1　A1　A1　A1　A1　A1　A1　A1　　　　A3　　　　B1

//Send　DNIS　number
cur_num=0;
do{
fwsig=(dnis[cur_num]==＇0＇)?SIGI_10:(dnis[cur_num]-0x31+SIGI_1);
if((bksig=r2_playfsig(voxdev,fwsig,EV_SYNC))==-1)　return　-1;
//printf("%s:　Backward　is　%d\n",dev[i].voxname,bksig);
cur_num++;
}　while　((bksig!=SIGA_6)||(cur_num>DNIS_LEN));

//Send　Charge　type　SIGI_1;
fwsig=SIGI_1;
if((bksig=r2_playfsig(voxdev,fwsig,EV_SYNC))==-1)　return　-1;
//printf("%s:　Backward　is　%d\n",dev[i].voxname,bksig);

//Send　ANI　number;
cur_num=0;
do{
fwsig=(ani[cur_num]==＇0＇)?SIGI_10:(ani[cur_num]-0x31+SIGI_1);
if((bksig=r2_playfsig(voxdev,fwsig,EV_SYNC))==-1)　return　-1;
//printf("%s:　Backward　is　%d\n",dev[i].voxname,bksig);
cur_num++;
}　while　(cur_num<ANI_LEN);

//Send　SIGI_15;
fwsig=SIGI_15;
if((bksig=r2_playfsig(voxdev,fwsig,EV_SYNC))==-1)　return　-1;
//printf("%s:　Backward　is　%d\n",dev[i].voxname,bksig);

//Send　SIGII_3;
fwsig=SIGII_3;
if((bksig=r2_playfsig(voxdev,fwsig,EV_SYNC))==-1)　return　-1;
//printf("%s:　Backward　is　%d\n",dev[i].voxname,bksig);

printf("%s:　%2d　Ringing...\n",dev[i].voxname,i);
//MFC　ends　here.
time=0;
do{
if((tsbits=ATDT_TSSGBIT(dtidev))==AT_FAILURE){
printf("%s:　ATDT_TSSGBIT()　error.\n",dev[i].voxname);
return　-1;
}
arcv=(tsbits　&　DTSG_RCVA)?1:0;
brcv=(tsbits　&　DTSG_RCVB)?1:0;
axmt=(tsbits　&　DTSG_XMTA)?1:0;
bxmt=(tsbits　&　DTSG_XMTB)?1:0;
if(brcv==0)　{
printf("%s:　Backward　hangup\n",dev[i].voxname);
return　-1;
}
Sleep(50);
time+=50;
if(time>timeout){
printf("%s:　The　line　%s　has　no　answer.\n",dev[i].voxname,dnis);
return　-1;
}
}　while(arcv==1);//11-->01　From　ONHOOK　to　OFFHOOK
//printf("%s:　%2d　%s　OffHook.\n",dev[i].voxname,i,dnis);
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;

i=forwardsig　-　SIGI_1;