tic

tic

The tic instruction controls a telephone interface line (channel).

Synopsis

tic('C', ctype.dialstr, type.rings)
tic('D', ctype.dialstr)
tic('O', ctype.dialstr)
tic('X', ctype.dialstr, type.xferwhen)
tic('a')
tic('d', ctype.dialstr)
tic('h')
tic('o', ctype.dialstr)
tic('x', ctype.dialstr, type.xferwhen)

Description

The tic instruction provides the script with control functions for the telephone interface line (channel) that the script is currently using. The function that the tic instruction performs depends on the value of its first argument. These argument values and their corresponding functions are listed below.

Note:
This instruction handles differences between telephony types better than tic(`O').

The tic instruction uses script registers 0 (r.0) and 1 (r.1) to return a result. This result may differ according to whether the script is using a T1, E1, or PRI channel. Where such variations exist, they are noted below.

The following table lists the possible return values for the different forms of the tic instruction. Note that the set of possible return values depends on the type of channel: T1, E1, or PRI.

If your script encounters a secondary dial tone, you can use a sequence of two tic instructions, the first dialing the access number and waiting for secondary dial tone, and the second dialing the remainder of the telephone number.

If you use the tic('d') instruction to send touch tones between two scripts, the tones may be lost if one script sends tones before the other script turns on its DTMF receiver. To avoid this problem, insert a delay of more than 70 milliseconds (for example, use nap(10) to cause the script to sleep for 100 milliseconds) before the tic('d') instruction.

If the system encounters a glare condition (that is, an incoming call is detected at almost the same moment the system is dialing out), the system drops the outgoing call and answers the incoming call. The termination of the script dialing out is treated as a hangup, meaning that if there is an EHANGUP event subroutine defined by the script (see the event instruction), it is executed before the script ends. This may mean that more than the usual number of rings are heard by the caller before the incoming call is answered.

Example

The following example is a portion of a script that uses the tic instruction. In this example, the script copies 9999 into NUMBER, then originates a call to that number. Depending on what is returned, the script either jumps to the end or ok label.

#define NUMBER 5

strcpy(ch.NUMBER, "9999")
tic('O', ch.NUMBER)
jmp(r.0 == -1, end) /* hardware failure */
jmp(r.0 == -2, end) /* timeout, no response */
jmp(r.0 == 'B', end) /* busy */
jmp(r.0 == 'R', ok) /* ring */
end:
quit()
ok:
tic('h')
rts()

Feature related changes for PRI

The following information applies to the tic instruction when using it with PRI in an application.

Using tic with PRI

The supported tic instruction options for PRI are listed in the following table. These options are used in the same manner for PRI as for T1.

Some options to the tic instruction are not applicable to the PRI. These options are listed in the following table.

The tic(`C') and tic(`O') Return Values and ISDN Cause Values

The PRI implementation of the tic(`C') (Call) and tic(`O') (Originate) instructions provide additional return code information for disconnected calls on a T1 interface. Register r.1 returns the ISDN cause value (if available) for an incomplete call. These cause values are returned by the network and are passed to the script. The cause value is also passed in register r.1 for a disconnect event. The following table contains a list of ISDN cause values returned in register r.1. These are arranged in groups according to the more general call disposition value returned in register r.0.

Note:
If the called party is not an ISDN subscriber, there is no ISDN cause value and -2 is returned to the script. Until ISDN is more widely used, -2 is a common return. The include (header) file (/att/include/tas_defs.h) provides macro definitions of these values. This file can be used by your application by including the following line in your script source file: #include "tas_defs.h"

You should be aware of the following issues when using these ISDN values:

• Dialtone detected (`D') indicates disconnection. It is comparable to dial tone detection on analog lines.
• Busy (`B') is comparable to busy, although there may be no audible busy tone.
• Fast busy (`F') is comparable to fast busy, although there may be no audible fast busy tone.

Example of PRI Heading

The following example shows how to use this feature in an outbound call script. This script outdials customer numbers retrieved from an account database. If the number dialed was unassigned, invalid, or incomplete, the script sends a message back to the database indicating this. The customer record can then be checked.

#include "tas_defs.h" /* VIS provided header file */

#include "dip_defs.h" /* Application dip header file */

#define DIALED_NUMBER 0 /* location of dialed number string */

/* Specify the speech file you wish to use */

tfile(application)

Begin:

/* Get the number to be dialed from a database */

dbase (DIP14, RETRIEVE_NUMBER, ch.DIALED_NUMBER, ... )

/* Telephone number to be dialed is now in ch.DIAL_NUMBER */

tic('O', ch.DIALED_NUMBER)

/* Check to see if the call was answered */

jmp (r.0 == 'P', Continue) /* Call answered, speak */

/* Call was not answered */

/* Did PRI indicate that the number does not exist? */

jmp (r.1 == CV_UN, UnassignedNumber)

/* Did PRI indicate that the number was incomplete? */

jmp (r.1 == CV_INF, InvalidNumberFormat)

/* Did PRI indicate that the number has been changed? */

jmp (r.1 == CV_NC, NumberChanged)

/* Otherwise hangup */

tic('h')

quit()

NumberChanged:

/*Send request to database to mark this telephone number as */

/* changed. (Client's number can be updated later) */

dbase (DIP14, NUMBER_CHANGED, ch.RESULT, ch.DIALED_NUMBER, ... )

quit()

UnassignedNumber:

/* Send request to database to mark this telephone number

/* as unassigned. (Check Client's number for accuracy) */

dbase (DIP1, UNASSIGNED_NUMBER, ch.RESULT, ch.DIALED_NUMBER, ... )

quit()

InvalidNumberFormat:

/* Send request to database to mark this phone number as */

/* bad. (Client's number can be check for completeness) */

dbase (DIP1, INVALID_NUMBER, ch.RESULT, ch.DIALED_NUMBER, ... )

quit()

Continue:

/* continue with normal call processing */

talk ( "Hello" )

...

quit()

Using tic with Full CCA

Be aware that if Full CCA (available only for US and Canada) determines that an outbound call cannot be completed because of a ring-no answer, the transaction should hang up the call using a tic('h') as soon as possible. If the call is not hung up immediately, the called party could answer (their phone is still ringing). The application will be unaware of this and will hang up on the called party as soon as the application completes. This not only annoys the called party but also could result in the calling party being billed for a failed call.

Do not use the tic('W') or tic('w') instruction with Full CCA.

Full CCA Call Dispositions

The following table lists the possible return values for the tic('C'), tic('D'), and tic('O') instructions when Full_CCA is turned on using the setcca instruction. Note that the set of possible return values depends on the type of channel: E1, T1, or PRI.

You should be aware of the following issues when using these dispositions:

• Fast busy ('F') represents any temporary error condition not explicitly listed; for example, congestion or circuit busy, as well as fast busy. A blind success (0) means that the call was dialed successfully but that the system does not know if the call was answered.
• A timeout (-2) means any type of timeout including a timeout on a tic instruction or on the classifier.
• When D or F is returned for outdials on PRI channels, more information (the ISDN cause value) on the call disposition is available in register r.1. For more information, see "The tic(`C') and tic(`O') Return Values and ISDN Cause Values."

Example

The following example shows an excerpt from a script showing how a developer might use the setcca and tic instructions in a Full CCA application.

setcca(1,10,-1)

nextcall:

dbase( .... ) /* get number to dial from DIP */

tic('O', r.3) /* call number in register 3 */

jmp(r.0 == 'N', noAns) /* no answer after 10 rings */

jmp(r.0 == 'B', busy)

jmp(r.0 == 'F', retry)

jmp(r.0 == 'A', answer)

noAns:

tic('h') /* put line on-hook to stop ringing */

busy:

dbase ( .... ) /* report result to controlling DIP */

goto (nextcall)

answer:

talk("Hello, you may be the winner of a free trip to Hawaii")

dbase ( .... ) /* report result to controlling DIP */

goto (nextcall)

© 2006 Avaya Inc. All Rights Reserved.