Setting the BACK DIGITS variable - Revision history

Allyntree: Needs revising edit

2018-04-19T12:40:35Z

Needs revising edit

← Older revision		Revision as of 08:40, 19 April 2018
Line 2:		Line 2:
	The default CASR2 scripts included with Toolpack present a way to configure the sequence of tone requests sent by the backward end.		The default CASR2 scripts included with Toolpack present a way to configure the sequence of tone requests sent by the backward end.

	To learn how to set a CASR2 variable in Toolpack, refer to ~~the~~ [[Setting CASR2 variables]] ~~article~~.		To learn how to set a CASR2 variable in Toolpack, refer to [[Setting CASR2 variables]].

	''The digit meanings in this article are the ones defined in the [[CASR2 ITU specification]]. Digit meanings may vary depending on the variant specification.''		''The digit meanings in this article are the ones defined in the [[CASR2 ITU specification]]. Digit meanings may vary depending on the variant specification.''
Line 41:		Line 41:
	Backward : 1 1 1 1 1 1 1 1 1 5 5 5 5 5 5 5 3 6		Backward : 1 1 1 1 1 1 1 1 1 5 5 5 5 5 5 5 3 6

	In this final example, the backward end sent an ~~extra~~ extra '5' digit, and the backward end responded with 'F' to mark the end of the calling number. Then, the backward end sent digit '3' which represent two things: request of the category again, and also signify to the forward end that the next digit belongs to a different grouping (named "Group B"). Once the category was received, the backward end accepted the call with the '6'.		In this final example, the backward end sent an extra '5' digit, and the backward end responded with 'F' to mark the end of the calling number. Then, the backward end sent digit '3' which represent two things: request of the category again, and also signify to the forward end that the next digit belongs to a different grouping (named "Group B"). Once the category was received, the backward end accepted the call with the '6'.

	== The BACK_DIGITS variable ==		== The BACK_DIGITS variable ==
Line 55:		Line 55:

	With such a string, the only thing to worry about is the length of the called number. If the called number length may vary, the number of '1's must match the longest possible number. In the case where the forward end receives a '1' when it has sent all its digits, the conventional way of handling this is for the forward end to not emit anything for a while, until the backward end detects this condition and requests something else. In this case, the default scripts in Toolpack will handle this case gracefully and skip the remaining '1's found in the BACK_DIGITS variable.		With such a string, the only thing to worry about is the length of the called number. If the called number length may vary, the number of '1's must match the longest possible number. In the case where the forward end receives a '1' when it has sent all its digits, the conventional way of handling this is for the forward end to not emit anything for a while, until the backward end detects this condition and requests something else. In this case, the default scripts in Toolpack will handle this case gracefully and skip the remaining '1's found in the BACK_DIGITS variable.

	~~[[category:Needs revising]]~~

Lucas Trottier: Add redirect to new page name

2011-12-05T23:41:43Z

Add redirect to new page name

← Older revision		Revision as of 19:41, 5 December 2011
Line 1:		Line 1:
			#REDIRECT [[Setting the CAS R2 BACK DIGITS variable]]
	The default CASR2 scripts included with Toolpack present a way to configure the sequence of tone requests sent by the backward end.		The default CASR2 scripts included with Toolpack present a way to configure the sequence of tone requests sent by the backward end.

Lucas Trottier: Change CAS R2 to CASR2 to match in search with "casr2"

2011-12-05T23:36:31Z

Change CAS R2 to CASR2 to match in search with "casr2"

Lucas Trottier: /* The BACK_DIGITS variable */

2011-11-29T22:06:10Z

The BACK_DIGITS variable

← Older revision		Revision as of 18:06, 29 November 2011
Line 44:		Line 44:
	== The BACK_DIGITS variable ==		== The BACK_DIGITS variable ==

	In the CAS R2 default scripts found in Toolpack, the BACK_DIGITS variable expresses the digits that must be emitted from the incoming ~~end~~. A functioning BACK_DIGITS variable that complies with the second example of the last section would be:		In the CAS R2 default scripts found in Toolpack, the BACK_DIGITS variable expresses the digits that must be emitted from the backward end (incoming CAS R2 call). A functioning BACK_DIGITS variable that complies with the second example of the last section would be:
	BACK_DIGITS = "111111111555555536"		BACK_DIGITS = "111111111555555536"

Line 53:		Line 53:
	BACK_DIGITS = "1111111115A3V"		BACK_DIGITS = "1111111115A3V"

	With such a string, the only thing to worry about is the length of the called number. If the called number length may vary, the number of '1's must match the longest possible number. In the case where the ~~outgoing~~ end receives a '1' when it has sent all its digits, the conventional way of handling this is for the ~~outgoing~~ end to not emit anything for a while, until the ~~incoming~~ end detects this condition and requests something else. In this case, the default scripts in Toolpack will handle this case gracefully and skip the remaining '1's found in the BACK_DIGITS variable.		With such a string, the only thing to worry about is the length of the called number. If the called number length may vary, the number of '1's must match the longest possible number. In the case where the forward end receives a '1' when it has sent all its digits, the conventional way of handling this is for the forward end to not emit anything for a while, until the backward end detects this condition and requests something else. In this case, the default scripts in Toolpack will handle this case gracefully and skip the remaining '1's found in the BACK_DIGITS variable.

	[[category:Needs revising]]		[[category:Needs revising]]

Lucas Trottier at 21:25, 29 November 2011

2011-11-29T21:25:10Z

← Older revision		Revision as of 17:25, 29 November 2011
Line 1:		Line 1:
	The default CAS R2 scripts included with Toolpack present a way to configure the sequence of tone requests sent by the ~~incoming~~ end.		The default CAS R2 scripts included with Toolpack present a way to configure the sequence of tone requests sent by the backward end.

	To learn how to set a CAS R2 variable in Toolpack, refer to the [[Setting CAS R2 variables]] article.		To learn how to set a CAS R2 variable in Toolpack, refer to the [[Setting CAS R2 variables]] article.

Lucas Trottier: /* Compelled sequence and information exchange */

2011-11-29T20:39:57Z

Compelled sequence and information exchange

← Older revision		Revision as of 16:39, 29 November 2011
Line 8:		Line 8:
	[[File:Casr2_fwd_bwd_diagram.png]]		[[File:Casr2_fwd_bwd_diagram.png]]

	In most implementations, the information available from CAS R2 signaling is exchanged through compelled sequences of tones. A compelled sequence consists into the ~~outgoing~~ end ~~first~~ emitting a digit and the ~~incoming~~ end responding with a second digit. The ~~outgoing~~ end confirms reception of the ~~incoming~~ digit by stopping to emit, and waits for the ~~incoming~~ end to do so as well to initiate the next sequence. In a way, the ~~outgoing~~ end is mostly passive: it responds to ~~incoming~~ requests, except when the requests cannot be met, or for the first sequence.		In most implementations, the information available from CAS R2 signaling is exchanged through compelled sequences of tones. A compelled sequence consists into the forward end emitting a digit and the backward end responding with a second digit. The backward end confirms reception of the digit by stopping to emit, and waits for the forward end to do so as well to initiate the next sequence. In a way, the forward end is mostly passive: it responds to backward end requests, except when the requests cannot be met, or for the first sequence.

	One way of representing such exchanges can be expressed as follows:		One way of representing such exchanges can be expressed as follows:
	Called number: 4506558993		Called number: 4506558993
	~~Outgoing~~: 4 5 0 6 5 5 8 9 9 3		Forward : 4 5 0 6 5 5 8 9 9 3
	~~Incoming~~: 1 1 1 1 1 1 1 1 1 6		Backward : 1 1 1 1 1 1 1 1 1 6

	In the previous example, the ~~outgoing~~ end ~~first~~ emits the first digit of the called number '4'. The ~~incoming~~ end responds with the '1' digit, which request the next called number digit. The exchanges goes on until the ~~incoming~~ end has received all the digits it needed, and closed the exchange with the '6' digit, which means the call was accepted.		In the previous example, the forward end emits the first digit of the called number '4'. The backward end responds with the '1' digit, which request the next called number digit. The exchanges goes on until the backward end has received all the digits it needed, and closed the exchange with the '6' digit, which means the call was accepted.

	The incoming end may (and will, most of the time) request the calling number and the calling party category as well:		The incoming end may (and will, most of the time) request the calling number and the calling party category as well:
Line 21:		Line 21:
	Calling number: 4506559511		Calling number: 4506559511
	Calling party category: 1 (Subscriber without priority)		Calling party category: 1 (Subscriber without priority)
	~~Outgoing~~: 4 5 0 6 5 5 8 9 9 3 1 4 5 0 6 5 5 9 5 1 1		Forward : 4 5 0 6 5 5 8 9 9 3 1 4 5 0 6 5 5 9 5 1 1
	~~Incoming~~: 1 1 1 1 1 1 1 1 1 5 5 5 5 5 5 5 5 5 5 5 6		Backward : 1 1 1 1 1 1 1 1 1 5 5 5 5 5 5 5 5 5 5 5 6

	In this example, the ~~incoming~~ end requested the calling party category (using digit '5') after having received all the called number digits. Still using digit '5', it then requested the calling number. Once it was fully received, the ~~incoming~~ end accepted the call with digit '6'.		In this example, the backward end requested the calling party category (using digit '5') after having received all the called number digits. Still using digit '5', it then requested the calling number. Once it was fully received, the backward end accepted the call with digit '6'.

	Here is a second example where the ~~incoming~~ send an extra '5' when gathering the calling number (The picture also shows the different CAS R2 concepts and TelcoBridges Cas R2 script BACK_DIGITS variable):		Here is a second example where the backward send an extra '5' when gathering the calling number (The picture also shows the different CAS R2 concepts and TelcoBridges Cas R2 script BACK_DIGITS variable):
	Called number: 4506558993		Called number: 4506558993
	Calling number: 4506559511		Calling number: 4506559511
Line 37:		Line 37:
	Calling number: 12345		Calling number: 12345
	Calling party category: 2 (Subscriber with priority)		Calling party category: 2 (Subscriber with priority)
	~~Outgoing~~: 4 5 0 6 5 5 8 9 9 3 2 1 2 3 4 5 F 2		Forward : 4 5 0 6 5 5 8 9 9 3 2 1 2 3 4 5 F 2
	~~Incoming~~: 1 1 1 1 1 1 1 1 1 5 5 5 5 5 5 5 3 6		Backward : 1 1 1 1 1 1 1 1 1 5 5 5 5 5 5 5 3 6

	In this final example, the ~~incoming~~ end sent ~~one~~ '5' ~~too much~~, and the ~~outgoing~~ end responded with 'F' to mark the end of the calling number. Then, the ~~incoming~~ end sent ~~the~~ '3' ~~digit~~ which ~~did~~ two things: request the category again, and signify to the ~~outgoing~~ end that the next digit belongs to a different grouping (named "Group B"). Once the category was received, the ~~incoming~~ end accepted the call with the '6'.		In this final example, the backward end sent an extra extra '5' digit, and the backward end responded with 'F' to mark the end of the calling number. Then, the backward end sent digit '3' which represent two things: request of the category again, and also signify to the forward end that the next digit belongs to a different grouping (named "Group B"). Once the category was received, the backward end accepted the call with the '6'.

	== The BACK_DIGITS variable ==		== The BACK_DIGITS variable ==

Lucas Trottier: /* Compelled sequence and information exchange */

2011-11-29T20:13:52Z

Compelled sequence and information exchange

← Older revision		Revision as of 16:13, 29 November 2011
Line 6:		Line 6:

	== Compelled sequence and information exchange ==		== Compelled sequence and information exchange ==
			[[File:Casr2_fwd_bwd_diagram.png]]

	In most implementations, the information available from CAS R2 signaling is exchanged through compelled sequences of tones. A compelled sequence consists into the outgoing end first emitting a digit and the incoming end responding with a second digit. The outgoing end confirms reception of the incoming digit by stopping to emit, and waits for the incoming end to do so as well to initiate the next sequence. In a way, the outgoing end is mostly passive: it responds to incoming requests, except when the requests cannot be met, or for the first sequence.		In most implementations, the information available from CAS R2 signaling is exchanged through compelled sequences of tones. A compelled sequence consists into the outgoing end first emitting a digit and the incoming end responding with a second digit. The outgoing end confirms reception of the incoming digit by stopping to emit, and waits for the incoming end to do so as well to initiate the next sequence. In a way, the outgoing end is mostly passive: it responds to incoming requests, except when the requests cannot be met, or for the first sequence.

Atremblay at 23:01, 28 February 2011

2011-02-28T23:01:35Z

← Older revision		Revision as of 19:01, 28 February 2011
Line 46:		Line 46:
	BACK_DIGITS = "111111111555555536"		BACK_DIGITS = "111111111555555536"

	However, such a sequence has many problems. Firsthand, the called number may be invalid and the call should be refused. To let Toolpack handle the decision of accepting or refusing the call when in group B, the 'V' symbol is used. With the aid of tables found in the script, Toolpack will be able to find the appropriate digit to emit considering the acceptation or		However, such a sequence has many problems. Firsthand, the called number may be invalid and the call should be refused. To let Toolpack handle the decision of accepting or refusing the call when in group B, the 'V' symbol is used. With the aid of tables found in the script, Toolpack will be able to find the appropriate digit to emit considering the acceptation or refusal of the call.
	BACK_DIGITS = "11111111155555553V"		BACK_DIGITS = "11111111155555553V"

Atremblay: Typos

2010-11-05T19:33:13Z

Typos

← Older revision		Revision as of 15:33, 5 November 2010
Line 7:		Line 7:
	== Compelled sequence and information exchange ==		== Compelled sequence and information exchange ==

	In most implementations, the information available from CAS R2 signaling is exchanged through compelled sequences of tones. A compelled sequence consists into the outgoing end first emitting a digit and the ~~outgoing~~ end responding with a second digit. The outgoing end confirms reception of the incoming digit by stopping to emit, and waits for the incoming end to do so as well to initiate the next sequence. In a way, the outgoing end is mostly passive: it responds to ~~outgoing~~ requests, except when the requests cannot be met, or for the first sequence.		In most implementations, the information available from CAS R2 signaling is exchanged through compelled sequences of tones. A compelled sequence consists into the outgoing end first emitting a digit and the incoming end responding with a second digit. The outgoing end confirms reception of the incoming digit by stopping to emit, and waits for the incoming end to do so as well to initiate the next sequence. In a way, the outgoing end is mostly passive: it responds to incoming requests, except when the requests cannot be met, or for the first sequence.

	One way of representing such exchanges can be expressed as follows:		One way of representing such exchanges can be expressed as follows:
Line 40:		Line 40:

	In this final example, the incoming end sent one '5' too much, and the outgoing end responded with 'F' to mark the end of the calling number. Then, the incoming end sent the '3' digit which did two things: request the category again, and signify to the outgoing end that the next digit belongs to a different grouping (named "Group B"). Once the category was received, the incoming end accepted the call with the '6'.		In this final example, the incoming end sent one '5' too much, and the outgoing end responded with 'F' to mark the end of the calling number. Then, the incoming end sent the '3' digit which did two things: request the category again, and signify to the outgoing end that the next digit belongs to a different grouping (named "Group B"). Once the category was received, the incoming end accepted the call with the '6'.



	== The BACK_DIGITS variable ==		== The BACK_DIGITS variable ==

Cbilodeau: add description to picture

2010-09-09T15:41:37Z

add description to picture

← Older revision		Revision as of 11:41, 9 September 2010
Line 30:		Line 30:
	Calling party category: 2 (Subscriber without priority)		Calling party category: 2 (Subscriber without priority)

	[[Image:Casr2_bwd_digit_string.png\|widthpx\| ]]		[[Image:Casr2_bwd_digit_string.png\|widthpx\|Backward digit string overview]]

	Finally, here is a final example:		Finally, here is a final example:

← Older revision		Revision as of 19:36, 5 December 2011
Line 1:		Line 1:
	The default ~~CAS R2~~ scripts included with Toolpack present a way to configure the sequence of tone requests sent by the backward end.		The default CASR2 scripts included with Toolpack present a way to configure the sequence of tone requests sent by the backward end.

	To learn how to set a ~~CAS R2~~ variable in Toolpack, refer to the [[Setting ~~CAS R2~~ variables]] article.		To learn how to set a CASR2 variable in Toolpack, refer to the [[Setting CASR2 variables]] article.

	''The digit meanings in this article are the ones defined in the [[~~CAS R2~~ ITU specification]]. Digit meanings may vary depending on the variant specification.''		''The digit meanings in this article are the ones defined in the [[CASR2 ITU specification]]. Digit meanings may vary depending on the variant specification.''

	== Compelled sequence and information exchange ==		== Compelled sequence and information exchange ==
	[[File:Casr2_fwd_bwd_diagram.png]]		[[File:Casr2_fwd_bwd_diagram.png]]

	In most implementations, the information available from ~~CAS R2~~ signaling is exchanged through compelled sequences of tones. A compelled sequence consists into the forward end emitting a digit and the backward end responding with a second digit. The backward end confirms reception of the digit by stopping to emit, and waits for the forward end to do so as well to initiate the next sequence. In a way, the forward end is mostly passive: it responds to backward end requests, except when the requests cannot be met, or for the first sequence.		In most implementations, the information available from CASR2 signaling is exchanged through compelled sequences of tones. A compelled sequence consists into the forward end emitting a digit and the backward end responding with a second digit. The backward end confirms reception of the digit by stopping to emit, and waits for the forward end to do so as well to initiate the next sequence. In a way, the forward end is mostly passive: it responds to backward end requests, except when the requests cannot be met, or for the first sequence.

	One way of representing such exchanges can be expressed as follows:		One way of representing such exchanges can be expressed as follows:
Line 26:		Line 26:
	In this example, the backward end requested the calling party category (using digit '5') after having received all the called number digits. Still using digit '5', it then requested the calling number. Once it was fully received, the backward end accepted the call with digit '6'.		In this example, the backward end requested the calling party category (using digit '5') after having received all the called number digits. Still using digit '5', it then requested the calling number. Once it was fully received, the backward end accepted the call with digit '6'.

	Here is a second example where the backward send an extra '5' when gathering the calling number (The picture also shows the different ~~CAS R2~~ concepts and TelcoBridges Cas R2 script BACK_DIGITS variable):		Here is a second example where the backward send an extra '5' when gathering the calling number (The picture also shows the different CASR2 concepts and TelcoBridges Cas R2 script BACK_DIGITS variable):
	Called number: 4506558993		Called number: 4506558993
	Calling number: 4506559511		Calling number: 4506559511
Line 44:		Line 44:
	== The BACK_DIGITS variable ==		== The BACK_DIGITS variable ==

	In the ~~CAS R2~~ default scripts found in Toolpack, the BACK_DIGITS variable expresses the digits that must be emitted from the backward end (incoming ~~CAS R2~~ call). A functioning BACK_DIGITS variable that complies with the second example of the last section would be:		In the CASR2 default scripts found in Toolpack, the BACK_DIGITS variable expresses the digits that must be emitted from the backward end (incoming CASR2 call). A functioning BACK_DIGITS variable that complies with the second example of the last section would be:
	BACK_DIGITS = "111111111555555536"		BACK_DIGITS = "111111111555555536"