PROGRAM_NAME='EF Devices AMX Control Panel, v. 1.00.03' (* DATE:08/30/00 TIME:11:07:38 *) (* This code supports control of ASPI Digital's EF200 Phone Add. *) (* The code controls single devices as well as multiple devices *) (* that are connected together via the ASPI Bus. *) (*******************************************************************) (* Device Number Definitions *) (*******************************************************************) DEFINE_DEVICE SP = 2 TP = 128 (*******************************************************************) (* Constant Definitions *) (*******************************************************************) DEFINE_CONSTANT (* Buttons on MAIN page *) B_DIAL1 = 17 B_DIAL2 = 18 B_DIAL3 = 19 B_DIAL4 = 20 B_DIAL5 = 21 B_DIAL6 = 22 B_DIAL7 = 23 B_DIAL8 = 24 B_DIAL9 = 25 B_DIALS = 26 B_DIAL0 = 27 B_DIALP = 28 B_PHONE = 33 B_PRIVACY = 34 B_FLASH = 35 B_REMCON = 36 B_HOLD = 37 B_CALLP_STAT = 1 B_CID_DATE = 2 B_CID_NAME = 3 B_CID_NUMBER = 4 B_DIAL_STAT = 5 (* Buttons on Options page *) B_AA = 50 B_AGC = 51 B_GAINP = 55 B_GAINPUP = 56 B_GAINPDN = 57 B_GAINP_DISPLAY = 58 B_GAINA = 59 B_GAINAUP = 60 B_GAINADN = 61 B_GAINA_DISPLAY = 62 B_MUTEP = 63 B_MUTER = 64 B_AH = 65 B_PASSCODE = 66 LEVEL_GAINA = 1 LEVEL_GAINP = 2 (* Buttons on Advanced page *) B_CALLP = 80 B_CALLERID = 81 B_DTMF = 82 B_DTMFC = 83 B_ERROR = 84 B_LEC = 85 B_NS = 86 B_RING = 87 B_TONEE = 88 B_TONER = 89 B_NS_LEVEL = 90 B_LOCKFP = 91 B_RESTNV = 92 B_SAVENV = 93 (* Buttons on ABOUT page *) B_MASTERPROG = 225 B_COMPREV = 226 B_EF200REV = 227 B_EF200ID = 228 (* Buttons on Devices page *) (* There are 30 buttons for 30 devices (though EF200 can have 32) *) B_DEVICES = 102 B_DEV1 = 103 B_DEV2 = 104 B_DEV3 = 105 B_DEV4 = 106 B_DEV5 = 107 B_DEV6 = 108 B_DEV7 = 109 B_DEV8 = 110 B_DEV9 = 111 B_DEV10 = 112 B_DEV11 = 113 B_DEV12 = 114 B_DEV13 = 115 B_DEV14 = 116 B_DEV15 = 117 B_DEV16 = 118 B_DEV17 = 119 B_DEV18 = 120 B_DEV19 = 121 B_DEV20 = 122 B_DEV21 = 123 B_DEV22 = 124 B_DEV23 = 125 B_DEV24 = 126 B_DEV25 = 127 B_DEV26 = 128 B_DEV27 = 129 B_DEV28 = 130 B_DEV29 = 131 B_DEV30 = 132 B_DEVINFO = 150 (* To display current device on pages *) MAX_CMD_SIZE = 42 MAX_NUM_DEV = 30 NDEVICES = 2 (* Call progress tones *) CP_REORDER = 1 CP_BUSY = 2 CP_RING = 3 CP_DIALTONE = 4 MAX_CODE_LEN = 7 PASSWORD = '2774' (* Passcode length is password plus one more character for the '#' *) PASSCODE_LEN = 5 (* RAMP REPEATS *) GAINA_REP = 3 GAINP_REP = 3 GAINP_DELAY = 10 PONG_WAIT = 10 (* 5 SECONDS TO GET ALL PONGS *) FORCE_UPDATE = 255 (*******************************************************************) (* Global Variable Definitions *) (*******************************************************************) DEFINE_VARIABLE DEBUG MASTER_MSG_BUFFER[100] (* MASTER MESSAGE BUFFER *) SERIAL_PORT_BUFFER[255] EF_BUFFER[255] WAITING_FOR_PONGS DEVID DEV_STRING[3] DEV_INFO[3] NUMDEV DEVNUM DEVS[ NDEVICES ][3] DEV_IDX (* Index of device whose response last came through SP *) CDEV_IDX (* Index of current device *) (* Command arrays *) AA_ARY[ NDEVICES ] AGC_ARY[ NDEVICES ] AH_ARY[ NDEVICES ] CALLP_ARY[ NDEVICES ] CALLP_STAT_ARY[ NDEVICES ] CID_ARY[ NDEVICES ] DTMF_ARY[ NDEVICES ] DTMFC_ARY[ NDEVICES ] ERROR_ARY[ NDEVICES ] GAINA_LEV_ARY[ NDEVICES] (* 0 = -6dB, 18 = +12dB, 6 = 0dB *) RAMP_GAINAUP RAMP_GAINADN GAINP_LEV_ARY[ NDEVICES] (* 0 = -99dB, 99= 0dB *) RAMP_GAINPUP RAMP_GAINPDN RAMP_GAINP_DELAY HOLD_ARY[ NDEVICES ] LEC_ARY[ NDEVICES ] LOCKFP_ARY[ NDEVICES ] MUTEP_ARY[ NDEVICES ] MUTER_ARY[ NDEVICES ] NS_ARY[ NDEVICES ] NSL_ARY[ NDEVICES ] PHONE_ARY[ NDEVICES ] PRIVACY_ARY[ NDEVICES ] REMCON_ARY[ NDEVICES ] RING_ARY[ NDEVICES ] SWVER_ARY[ NDEVICES ][8] TONEE_ARY[ NDEVICES ] TONER_ARY[ NDEVICES ] TEMP_GAINA (* Stores previous GAINA value when AGC is on *) GAINA_LEVEL (* Level from EF200 *) GAINP_LEVEL INITIALIZING CP_RESET RING_TIMER DIAL_STRING[32] DTMF_STRING[39] DTMF_TONE DTMFCODE[MAX_CODE_LEN] DTMFCODE_IDX ENTER_PW PASSCODE[PASSCODE_LEN] PASSCODE_IDX TIMER_STAT (* Initialization variables *) DEVICE_INIT (* Which device is being initialized *) INIT_STEP (* Which command is being sent *) (* TRACK PREVIOUS VALS *) PREV_CDEV_IDX PREV_GAINA_LVL PREV_GAINP_LVL CP_STAT PREV_CP_STAT PREV_CALLP TEMP (*******************************************************************) (* Latching Definitions *) (*******************************************************************) DEFINE_LATCHING (*******************************************************************) (* Mutually Exclusive Definitions *) (*******************************************************************) DEFINE_MUTUALLY_EXCLUSIVE (*******************************************************************) (* Subroutine Definitions *) (*******************************************************************) (* These 'HANDLE' subroutines are just handling the EF200 return messages, *) (* the incoming data from the device (EF200). *) (*-----------------------------------------------------------------*) (* Subroutine: HANDLE AA *) (* *) (* This subroutine is called when the master receives a AA *) (* message from the EF200. It gets the AA state from the message *) (* and then sets the AA_STATE variable appropriately. *) (*-----------------------------------------------------------------*) DEFINE_CALL 'HANDLE AA' { AA_ARY[DEV_IDX] = ATOI(EF_BUFFER) (* Store AA of all devices *) } (*-----------------------------------------------------------------*) (* Subroutine: HANDLE AGC *) (* *) (* This subroutine is called when the master receives a AGC *) (* message from the EF200. It gets the AGC state from the message *) (* and then sets the AGC_STATE variable appropriately. *) (*-----------------------------------------------------------------*) DEFINE_CALL 'HANDLE AGC' { (* Turn the AGC button on or off *) AGC_ARY[DEV_IDX] = ATOI(EF_BUFFER) (* User tones for DTMF detection *) IF (DTMF_TONE) { IF (AGC_ARY[DEV_IDX]) SEND_STRING SP, "DEV_STRING, 'SOUNDP04', 13" ELSE SEND_STRING SP, "DEV_STRING, 'SOUNDP05', 13" DTMF_TONE = 0 } (* If AGC is on, Phone Input Gain is set to 3 dB and disabled *) IF (AGC_ARY[DEV_IDX]) { SEND_STRING SP, "DEV_STRING, 'GAINA3', 13" GAINA_LEV_ARY[DEV_IDX] = 9 (* +3dB *) } (* When AGC is off, previous GAINA value is restored *) (* GAINA_LEV_ARY holds the scaled value of GAINA, 0 to 18 *) (** How does this save previous value of GAINA?? **) ELSE { IF (GAINA_LEV_ARY[DEV_IDX] < 6) SEND_STRING SP, "DEV_STRING, 'GAINA-',ITOA(6-GAINA_LEV_ARY[DEV_IDX]), 13" ELSE SEND_STRING SP, "DEV_STRING, 'GAINA',ITOA(GAINA_LEV_ARY[DEV_IDX]-6), 13" } } (*-----------------------------------------------------------------*) (* Subroutine: HANDLE AH *) (* *) (* This subroutine is called when the master receives a AH *) (* message from the EF200. It gets the AH state from the *) (* message and then sets the AH_STATE variable appropriately. *) (*-----------------------------------------------------------------*) DEFINE_CALL 'HANDLE AH' { AH_ARY[DEV_IDX] = ATOI(EF_BUFFER) } (*-----------------------------------------------------------------*) (* Subroutine: HANDLE CALLP *) (* *) (* This subroutine is called when the master receives a CALLP *) (* message from the EF200. It gets the CALLP state from the *) (* message and then sets the CALLP_STATE variable appropriately. *) (*-----------------------------------------------------------------*) DEFINE_CALL 'HANDLE CALLP' LOCAL_VAR CP_CMD { CP_CMD = FIND_STRING(EF_BUFFER, '#', 1 ) IF ( CP_CMD = 0 ) { CALLP_ARY[DEV_IDX] = ATOI(EF_BUFFER) } ELSE IF ((CP_CMD > 0) && (DEV_IDX = CDEV_IDX)) { CALLP_STAT_ARY[DEV_IDX] = ATOI(EF_BUFFER) } } (*-----------------------------------------------------------------*) (* Subroutine: HANDLE CID *) (* *) (* This subroutine is called when the master receives a Caller ID *) (* message from the EF200. It gets the Caller ID state from the *) (* message, then sets the caller ID variable appropriately. *) (*-----------------------------------------------------------------*) DEFINE_CALL 'HANDLE CID' LOCAL_VAR LEN { IF ( EF_BUFFER[4] = 'T' ) { (* This contains the Caller ID timestamp *) SEND_COMMAND TP, "'TEXT', ITOA(B_CID_DATE), '-', MID_STRING(EF_BUFFER,2,2), '-', MID_STRING(EF_BUFFER,4,2), ' ', MID_STRING(EF_BUFFER,6,2), ':', RIGHT_STRING(EF_BUFFER,2)" } ELSE IF ( EF_BUFFER[4] = 'N' ) { (* The buffer contains the caller ID name information *) LEN = LENGTH_STRING(EF_BUFFER)-1 SEND_COMMAND TP, "'TEXT', ITOA(B_CID_NAME), '-', RIGHT_STRING(EF_BUFFER, LEN)" } ELSE IF ( EF_BUFFER[4] = '#' ) { LEN = LENGTH_STRING(EF_BUFFER) - 1 SEND_COMMAND TP, "'TEXT', ITOA(B_CID_NUMBER), '-', RIGHT_STRING(EF_BUFFER, LEN)" } ELSE IF ( EF_BUFFER[4] = 'X' ) { SEND_COMMAND TP, "'TEXT', ITOA(B_CID_NUMBER), '-', ' '" SEND_COMMAND TP, "'TEXT', ITOA(B_CID_NAME), '-', ' '" SEND_COMMAND TP, "'TEXT', ITOA(B_CID_DATE), '-', ' '" } ELSE { CID_ARY[DEV_IDX] = ATOI(EF_BUFFER) } } (*----------------------------------------------------------------*) (* Subroutine: INTERPRET COMMAND *) (* *) (* This subroutine is called by HANDLE DTMFCODE. It interprets *) (* the DTMF command code sent by the caller and sends the command *) (* to the EF200. *) (*----------------------------------------------------------------*) DEFINE_CALL 'INTERPRET COMMAND' LOCAL_VAR STAT[3] DTMF_CMD[3] { DTMF_CMD = LEFT_STRING( DTMFCODE, 3) STAT = "" IF ((DTMF_CMD = '047') || (DTMF_CMD = '065')) { (* The range for GAINP is -99 to 0 dB *) IF (FIND_STRING( DTMFCODE, '*', 1)) { (* If level is -1 to -9 *) IF (LENGTH_STRING(DTMFCODE) = (MAX_CODE_LEN-1)) STAT = "'-', MID_STRING(DTMFCODE, 5, 1)" (* If level is -10 to -99 *) ELSE IF (LENGTH_STRING(DTMFCODE) = MAX_CODE_LEN) STAT = "'-', MID_STRING(DTMFCODE, 5, 2)" } (* For GAINP level 0 dB, and NSL6 *) ELSE IF ((MID_STRING( DTMFCODE, 4, 1 ) = '0') || (MID_STRING( DTMFCODE, 4, 1 ) = '6')) STAT = MID_STRING( DTMFCODE, 4, 1 ) (* For NSL10 *) ELSE IF (MID_STRING( DTMFCODE, 4, 1) = '1') STAT = MID_STRING( DTMFCODE, 4, 2) } ELSE STAT = MID_STRING( DTMFCODE, 4, 1 ) DTMFCODE = "" SELECT { ACTIVE(DTMF_CMD = '024'): { SEND_STRING SP, "DEV_STRING, 'AGC',STAT, 13" DTMF_TONE = 1 } ACTIVE(DTMF_CMD = '047'):SEND_STRING SP, "DEV_STRING, 'GAINP',STAT, 13" ACTIVE(DTMF_CMD = '053'): { SEND_STRING SP, "DEV_STRING, 'LEC',STAT, 13" DTMF_TONE = 1 } ACTIVE(DTMF_CMD = '074'): { SEND_STRING SP, "DEV_STRING, 'MUTEP',STAT, 13" DTMF_TONE = 1 } ACTIVE(DTMF_CMD = '076'): { SEND_STRING SP, "DEV_STRING, 'MUTER',STAT, 13" DTMF_TONE = 1 } ACTIVE(DTMF_CMD = '067'): { SEND_STRING SP, "DEV_STRING, 'NS',STAT, 13" DTMF_TONE = 1 } ACTIVE(DTMF_CMD = '065'):SEND_STRING SP, "DEV_STRING, 'NSL',STAT, 13" ACTIVE(DTMF_CMD = '077'): { SEND_STRING SP, "DEV_STRING, 'PRIVACY',STAT, 13" DTMF_TONE = 1 } ACTIVE(DTMF_CMD = '072'): { SEND_STRING SP, "DEV_STRING, 'REMCON',STAT, 13" DTMF_TONE = 1 } } DTMF_STRING = "" SEND_COMMAND TP, "'TEXT', ITOA(B_DTMF), '-', DTMF_STRING" } (*-----------------------------------------------------------------*) (* Subroutine: INTERPRET QUERY *) (* *) (* This subroutine is called by HANDLE DTMFCODE. It interprets *) (* the DTMF query code sent by the caller and sends the command to *) (* the EF200. *) (*-----------------------------------------------------------------*) (* DEFINE_CALL 'INTERPRET QUERY' LOCAL_VAR QUERY_CMD[3] { DTMFCODE = REMOVE_STRING( DTMFCODE, '#', 4) QUERY_CMD = LEFT_STRING( DTMFCODE,3 ) SELECT { ACTIVE(QUERY_CMD = '024'): { SEND_STRING SP, "DEV_STRING, 'AGC?', 13" DTMF_TONE = 1 } ACTIVE(QUERY_CMD = '053'): { SEND_STRING SP, "DEV_STRING, 'LEC?', 13" DTMF_TONE = 1 } ACTIVE(QUERY_CMD = '074'): { SEND_STRING SP, "DEV_STRING, 'MUTEP?', 13" DTMF_TONE = 1 } ACTIVE(QUERY_CMD = '076'): { SEND_STRING SP, "DEV_STRING, 'MUTER?', 13" DTMF_TONE = 1 } ACTIVE(QUERY_CMD = '067'): { SEND_STRING SP, "DEV_STRING, 'NS?', 13" DTMF_TONE = 1 } ACTIVE(QUERY_CMD = '077'): { SEND_STRING SP, "DEV_STRING, 'PRIVACY?', 13" DTMF_TONE = 1 } ACTIVE(QUERY_CMD = '072'): { SEND_STRING SP, "DEV_STRING, 'REMCON?', 13" DTMF_TONE = 1 } } } *) (*----------------------------------------------------------------*) (* Subroutine: HANDLE DTMFCODE *) (* *) (* This subroutine is called when the master receives a DTMF# *) (* message from the EF200. It resets a timer and stores each *) (* digit in a string until there are CodeLength number of digits. *) (* Then it calls the subroutine InterpretCode. *) (*----------------------------------------------------------------*) DEFINE_CALL 'HANDLE DTMFCODE' { (* Timer is in increments of a tenth of a second *) IF ( (GET_TIMER - TIMER_STAT) >= 50 ) { DTMFCODE_IDX = 0 DTMFCODE = DTMF_STRING DTMF_STRING = "" DTMF_STRING = RIGHT_STRING(DTMFCODE, 1) SEND_COMMAND TP, "'TEXT', ITOA(B_DTMF), '-', DTMF_STRING" } TIMER_STAT = GET_TIMER DTMFCODE_IDX = DTMFCODE_IDX + 1 IF (RIGHT_STRING(DTMF_STRING, 1) = '#') { IF (DTMFCODE_IDX > 4) { DTMFCODE = "" DTMFCODE = DTMF_STRING CALL 'INTERPRET COMMAND' } (* ELSE IF (DTMFCODE_IDX = 4) CALL 'INTERPRET QUERY' *) } } (*-----------------------------------------------------------------*) (* Subroutine: HANDLE PASSCODE *) (* *) (* This subroutine is called when the master receives a PASSCODE *) (* message from the EF200. *) (*-----------------------------------------------------------------*) DEFINE_CALL 'HANDLE PASSCODE' { IF ((GET_TIMER - TIMER_STAT) < 200) { PASSCODE_IDX = PASSCODE_IDX + 1 IF (RIGHT_STRING(DTMF_STRING,1) = '#') { PASSCODE = DTMF_STRING ENTER_PW = 0 SEND_STRING SP, "DEV_STRING, 'HOLD0', 13" DTMF_STRING = "" SEND_COMMAND TP, "'TEXT', ITOA(B_DTMF), '-', DTMF_STRING" IF (!LEFT_STRING(PASSCODE, (PASSCODE_LEN-1)) = PASSWORD) { SEND_STRING SP, "DEV_STRING, 'PHONE0', 13" } (* Send user tone to phone to indicate entrance into conference *) (* Sound is 'ascending chorus' *) SEND_STRING SP, "DEV_STRING, 'SOUNDP02', 13" } } (* If more than 10 seconds passes or password is incorrect, hang up *) ELSE IF ((GET_TIMER - TIMER_STAT) >= 200) { SEND_STRING SP, "DEV_STRING, 'PHONE0', 13" SEND_STRING SP, "DEV_STRING, 'HOLD0', 13" } } (*-----------------------------------------------------------------*) (* Subroutine: HANDLE DTMF *) (* *) (* This subroutine is called when the master receives a DTMF *) (* message from the EF200. It gets the DTMF state from the message*) (* then sets the status of the DTMF decoding button appropriately. *) (*-----------------------------------------------------------------*) DEFINE_CALL 'HANDLE DTMF' LOCAL_VAR POS LEN { IF ( FIND_STRING(EF_BUFFER, 'DTMFC', 1 ) ) { DTMFC_ARY[DEV_IDX] = ATOI(EF_BUFFER) } ELSE IF ( FIND_STRING( EF_BUFFER, '#', 1) ) { POS = FIND_STRING( EF_BUFFER, '#', 1 ) LEN = LENGTH_STRING(DTMF_STRING) IF ( LEN >= 29 ) DTMF_STRING = "RIGHT_STRING(DTMF_STRING, 28 )" DTMF_STRING = "DTMF_STRING, MID_STRING(EF_BUFFER, POS+1, 1)" SEND_COMMAND TP, "'TEXT', ITOA(B_DTMF), '-', DTMF_STRING" IF (ENTER_PW) CALL 'HANDLE PASSCODE' ELSE CALL 'HANDLE DTMFCODE' } ELSE { DTMF_ARY[DEV_IDX] = ATOI(EF_BUFFER) } } (*-----------------------------------------------------------------*) (* Subroutine: HANDLE ERROR *) (* *) (* This subroutine is called when the master receives an ERROR *) (* message from the EF200. It gets the Error number in the message*) (* then sends the appropriate text to the Error text button. *) (*-----------------------------------------------------------------*) DEFINE_CALL 'HANDLE ERROR' LOCAL_VAR ERR_NUM { IF ( FIND_STRING(EF_BUFFER,'#',1 )) { ERR_NUM = ATOI(EF_BUFFER) SELECT { ACTIVE(ERR_NUM = 1):SEND_COMMAND TP, "'TEXT', ITOA(B_ERROR), '-', 'Error: Unknown command.'" ACTIVE(ERR_NUM = 2):SEND_COMMAND TP, "'TEXT', ITOA(B_ERROR), '-', 'Error: Invalid command data.'" ACTIVE(1):SEND_COMMAND TP, "'TEXT', ITOA(B_ERROR), '-', 'Error number: ', ERR_NUM" } } ELSE { ERROR_ARY[DEV_IDX] = ATOI(EF_BUFFER) } IF ( NOT [TP, B_ERROR] ) SEND_COMMAND TP, "'TEXT', ITOA(B_ERROR), '-', ''" } (*-----------------------------------------------------------------*) (* Subroutine: HANDLE GAINA *) (* *) (* This subroutine is called when the master receives a GAINA *) (* message from the EF200. It gets the phone input gain level *) (* from the message, then sets the GAINA_LEVEL variable *) (* appropriately. *) (* When AGC is turned on, this option is disabled. *) (*-----------------------------------------------------------------*) DEFINE_CALL 'HANDLE GAINA' { (* Even though this level comes back from EF200 as negative, *) (* the number read out is positive. Range in an integer is 0 to 65535 *) GAINA_LEVEL = ATOI(EF_BUFFER) (* Update level and numeric display. *) (* If the number is negative *) IF (MID_STRING(EF_BUFFER,6, 1) = '-') GAINA_LEV_ARY[DEV_IDX] = 6 - GAINA_LEVEL (* -6 dB=0, -1 dB=5 *) ELSE GAINA_LEV_ARY[DEV_IDX] = 6 + GAINA_LEVEL (* 0 dB=6, 12 dB=18 *) } (*-----------------------------------------------------------------*) (* Subroutine: HANDLE GAINP *) (* *) (* This subroutine is called when the master receives a GAINP *) (* message from the EF200. It gets the phone output gain level *) (* from the message, and stores it as a positive number between 0 *) (* and 100, then sets the GAINP_LEVEL variable appropriately. *) (*-----------------------------------------------------------------*) DEFINE_CALL 'HANDLE GAINP' { (* GAINP_LEVEL is the level returned by the EF device *) (* GAINP_LEVEL is negative, but AXCESS only handles pos. numbers *) GAINP_LEVEL = ATOI(EF_BUFFER) (* Update level and numeric display. *) GAINP_LEV_ARY[DEV_IDX] = 99 - GAINP_LEVEL (* -99 dB=0, 0 dB=99 *) } (*-----------------------------------------------------------------*) (* Subroutine: HANDLE HOLD *) (* *) (* This subroutine is called when the master receives a HOLD *) (* message from the EF200. It gets the HOLD state from the *) (* message and then sets the HOLD button state appropriately. *) (*-----------------------------------------------------------------*) DEFINE_CALL 'HANDLE HOLD' { HOLD_ARY[DEV_IDX] = ATOI(EF_BUFFER) } (*-----------------------------------------------------------------*) (* Subroutine: HANDLE LEC *) (* *) (* This subroutine is called when the master receives an LEC *) (* message from the EF200. It gets the LEC state from the message *) (* and then sets the LEC button state appropriately. *) (*-----------------------------------------------------------------*) DEFINE_CALL 'HANDLE LEC' { LEC_ARY[DEV_IDX] = ATOI(EF_BUFFER) (* User tones for DTMF detection *) IF (DTMF_TONE) { IF (LEC_ARY[DEV_IDX]) SEND_STRING SP, "DEV_STRING, 'SOUNDP04', 13" ELSE SEND_STRING SP, "DEV_STRING, 'SOUNDP05', 13" DTMF_TONE = 0 } } (*-----------------------------------------------------------------*) (* Subroutine: HANDLE LOCKFP *) (* *) (* This subroutine is called when the master receives a LOCKFP *) (* message from the EF200. It gets the LOCKFP state from the *) (* message and then sets the LOCKFP_STATE appropriately. *) (*-----------------------------------------------------------------*) DEFINE_CALL 'HANDLE LOCKFP' { LOCKFP_ARY[DEV_IDX] = ATOI(EF_BUFFER) } (*-----------------------------------------------------------------*) (* Subroutine: HANDLE MUTE *) (* *) (* This subroutine is called when the master receives a MUTEx *) (* message from the EF200. It gets the Mute state from the message*) (* and then sets the MUTE_ variables appropriately. *) (*-----------------------------------------------------------------*) DEFINE_CALL 'HANDLE MUTE' LOCAL_VAR STAT { STAT = ATOI(EF_BUFFER) SELECT { ACTIVE (EF_BUFFER[5] = 'P'): { MUTEP_ARY[DEV_IDX] = STAT (* User tones for DTMF detection *) IF (DTMF_TONE) { IF (MUTEP_ARY[DEV_IDX]) SEND_STRING SP, "DEV_STRING, 'SOUNDP04', 13" ELSE SEND_STRING SP, "DEV_STRING, 'SOUNDP05', 13" DTMF_TONE = 0 } } ACTIVE (EF_BUFFER[5] = 'R'): { MUTER_ARY[DEV_IDX] = STAT (* User tones for DTMF detection *) IF (DTMF_TONE) { IF (MUTER_ARY[DEV_IDX]) SEND_STRING SP, "DEV_STRING, 'SOUNDP04', 13" ELSE SEND_STRING SP, "DEV_STRING, 'SOUNDP05', 13" DTMF_TONE = 0 } } } } (*-----------------------------------------------------------------*) (* Subroutine: HANDLE NS *) (* *) (* This subroutine is called when the master receives a NS *) (* message from the EF200. It gets the NS state from the *) (* message and then sets the NS_STATE variable appropriately. *) (*-----------------------------------------------------------------*) DEFINE_CALL 'HANDLE NS' { IF ( FIND_STRING( EF_BUFFER, 'NSL', 1) ) { IF ( ATOI(EF_BUFFER) = 6) NSL_ARY[DEV_IDX] = 0 ELSE NSL_ARY[DEV_IDX] = 1 } ELSE { NS_ARY[DEV_IDX] = ATOI(EF_BUFFER) (* User tones for DTMF detection *) IF (DTMF_TONE) { IF (NS_ARY[DEV_IDX]) SEND_STRING SP, "DEV_STRING, 'SOUNDP04', 13" ELSE SEND_STRING SP, "DEV_STRING, 'SOUNDP05', 13" DTMF_TONE = 0 } } } (*-----------------------------------------------------------------*) (* Subroutine: HANDLE PHONE *) (* *) (* This subroutine is called when the master receives a PHONE *) (* message from the EF200. It gets the PHONE state from the *) (* message and then sets the PHONE_STATE variable appropriately. *) (*-----------------------------------------------------------------*) DEFINE_CALL 'HANDLE PHONE' { PHONE_ARY[DEV_IDX] = ATOI(EF_BUFFER) IF ([TP,B_PHONE]) { DIAL_STRING = "" DTMF_STRING = "" SEND_COMMAND TP, "'TEXT', ITOA(B_DIAL_STAT), '-', DIAL_STRING" SEND_COMMAND TP, "'TEXT', ITOA(B_DTMF), '-', DTMF_STRING" SEND_COMMAND TP, "'TEXT', ITOA(B_ERROR), '-', ''" TIMER_STAT = GET_TIMER IF ([TP, B_PASSCODE]) { ENTER_PW = 1 PASSCODE = "" PASSCODE_IDX = 0 SEND_STRING SP, "DEV_STRING, 'HOLD1', 13" } } ELSE OFF[TP, B_FLASH] } (*-----------------------------------------------------------------*) (* Subroutine: ADD DEVICE *) (* *) (* This subroutine is called from HANDLE PONG to build the device *) (* list each time a PONG is received from the device. *) (*-----------------------------------------------------------------*) DEFINE_CALL 'ADD DEVICE' LOCAL_VAR J, INSERT, TEMP_DEV_INFO1[10], TEMP_DEV_INFO2[10] { (* DEVS[NUMDEV] = DEV_INFO *) (* (* SORT THE DATA! *) J = 1 WHILE (ATOI(DEV_INFO) > ATOI(DEVS[J])) || (J < NUMDEV) J = J + 1 (* When other devs. are added, need to check dev type too *) (* Make space for new device ID *) K = NUMDEV WHILE (K > J) { DEVS[K] = DEVS[K-1] K = K - 1 } DEVS[J] = DEV_INFO*) J = 1 INSERT = 0 WHILE (J <= NUMDEV) { SELECT { (* IF WE INSERTED ALREAYD, KEEP SHUFFLING DATA *) ACTIVE (INSERT): { TEMP_DEV_INFO2 = DEVS[J] DEVS[J] = TEMP_DEV_INFO1 TEMP_DEV_INFO1 = TEMP_DEV_INFO2 IF (DEBUG) SEND_STRING 0,"'ADD DEV: MOVING ELEMENT:',ITOA(J),13,10" } (* WE FOUND A HOLE! *) ACTIVE (LENGTH_STRING(DEVS[J]) = 0): { DEVS[J] = DEV_INFO INSERT = 1 IF (DEBUG) SEND_STRING 0,"'ADD DEV: INSERT ELEMENT AT END: ',ITOA(J),13,10" IF (J <> NUMDEV) SEND_STRING 0,"'ADD DEVICE: BIG PROBLEM. WE FOUND AHOLE IN THE TABLE!',13,10" } (* LOOK FOR START OF OUR DEVICE TYPES! *) ACTIVE (DEV_INFO[1] > DEVS[J][1]): { (* JUST KEEP GOING UNTIL WE START OUR DEVICE CLASS *) } (* ELSE, LOOK FOR THE INSERTION POINT *) ACTIVE (ATOI(DEV_INFO) < ATOI(DEVS[J])) || (DEV_INFO[1] < DEVS[J][1]): { TEMP_DEV_INFO1 = DEVS[J] DEVS[J] = DEV_INFO INSERT = 1 IF (DEBUG) { SEND_STRING 0,"'ADD DEV: INSERTING NEW DEVICE ',DEV_INFO" SEND_STRING 0,"' AT ',ITOA(J),'; MAX IS ',ITOA(NUMDEV),13,10" } } } J = J + 1 } } (*-----------------------------------------------------------------*) (* Subroutine: HANDLE PONG *) (* *) (* This subroutine is called when the master receives a PONG *) (* message from the EF200. It reads the software version and *) (* writes it to the DEVID variable. *) (*-----------------------------------------------------------------*) DEFINE_CALL 'HANDLE PONG' { (* If device is not a duplicate, increment NUMDEV and add device *) IF (!(DEV_IDX)) { NUMDEV = NUMDEV + 1 CALL 'ADD DEVICE' } } (*-----------------------------------------------------------------*) (* Subroutine: HANDLE PRIVACY *) (* *) (* This subroutine is called when the master receives a PRIVACY *) (* message from the EF200. It gets the PRIVACY state from the *) (* message and sets the PRIVACY button appropriately. *) (*-----------------------------------------------------------------*) DEFINE_CALL 'HANDLE PRIVACY' { PRIVACY_ARY[DEV_IDX] = ATOI(EF_BUFFER) (* User tones for DTMF detection *) IF (DTMF_TONE) { IF (PRIVACY_ARY[DEV_IDX]) SEND_STRING SP, "DEV_STRING, 'SOUNDP04', 13" ELSE SEND_STRING SP, "DEV_STRING, 'SOUNDP05', 13" DTMF_TONE = 0 } } (*-----------------------------------------------------------------*) (* Subroutine: HANDLE REMCON' *) (* *) (* This subroutine is called when the master receives an REMCON *) (* message from the EF200. It gets the state of the remote *) (* connection in the message, then sets the Remote connection *) (* button state appropriately. *) (*-----------------------------------------------------------------*) DEFINE_CALL 'HANDLE REMCON' { REMCON_ARY[DEV_IDX] = ATOI(EF_BUFFER) (* User tones for DTMF detection *) IF (DTMF_TONE) { IF (REMCON_ARY[DEV_IDX]) SEND_STRING SP, "DEV_STRING, 'SOUNDP04', 13" ELSE SEND_STRING SP, "DEV_STRING, 'SOUNDP05', 13" DTMF_TONE = 0 } } (*-----------------------------------------------------------------*) (* Subroutine: HANDLE RESTNV *) (* *) (* This subroutine is called when the master receives a RESTNV *) (* message from the EF200. This means that the EF200 has finished *) (* restoring defaults and the RESTNV button lights briefly to *) (* reflect this. *) (*-----------------------------------------------------------------*) DEFINE_CALL 'HANDLE RESTNV' { PULSE [TP, B_RESTNV] } (*-----------------------------------------------------------------*) (* Subroutine: HANDLE RING *) (* *) (* This subroutine is called when the master receives a RING *) (* message from the EF200. It gets the LEC state from the message *) (* and then sets the RING button state appropriately. *) (*-----------------------------------------------------------------*) DEFINE_CALL 'HANDLE RING' { IF ( EF_BUFFER[5] = '!' ) { SEND_COMMAND TP, "'TEXT', ITOA(B_DIAL_STAT), '-', 'Ring! on DEV ', DEVS[DEV_IDX]" SET_TIMER(0) ON[RING_TIMER] } ELSE { RING_ARY[DEV_IDX] = ATOI(EF_BUFFER) } } (*-----------------------------------------------------------------*) (* Subroutine: HANDLE SAVENV *) (* *) (* This subroutine is called when the master receives a SAVENV *) (* message from the EF200. This means the EF200 has finished *) (* saving the settings and the SAVENV button lights briefly to *) (* reflect this. *) (*-----------------------------------------------------------------*) DEFINE_CALL 'HANDLE SAVENV' { PULSE [TP, B_SAVENV] } (*-----------------------------------------------------------------*) (* Subroutine: HANDLE SWVER *) (* *) (* This subroutine is called when the master receives an SWVER *) (* message from the EF200. It reads the software version and *) (* writes it to the B_EF200REV button on the touch panel. *) (* swVER is the last message to be received from the initialization*) (* process. When we receive SWVER, we know initialization is done *) (*-----------------------------------------------------------------*) DEFINE_CALL 'HANDLE SWVER' { SWVER_ARY[DEV_IDX] = MID_STRING(EF_BUFFER, 6, 8) } (*-----------------------------------------------------------------*) (* Subroutine: HANDLE TONEE *) (* *) (* This subroutine is called when the master receives an TONEE *) (* message from the EF200. It gets the TONEE state from the *) (* message, then sets the RING button state appropriately. *) (*-----------------------------------------------------------------*) DEFINE_CALL 'HANDLE TONEE' { TONEE_ARY[DEV_IDX] = ATOI(EF_BUFFER) } (*-----------------------------------------------------------------*) (* Subroutine: HANDLE TONER *) (* *) (* This subroutine is called when the master receives an TONER *) (* message from the EF200. It gets the TONER state from the *) (* message and then sets the TONER button state appropriately. *) (*-----------------------------------------------------------------*) DEFINE_CALL 'HANDLE TONER' { TONER_ARY[DEV_IDX] = ATOI(EF_BUFFER) } (*-----------------------------------------------------------------*) (* Subroutine: PROCESS MESSAGE *) (* *) (* This subroutine is called when there is a complete message in *) (* the serial port buffer. This subroutine processes the message *) (* and takes any required actions. *) (*-----------------------------------------------------------------*) DEFINE_CALL 'PROCESS MESSAGE' LOCAL_VAR J, TRASH[10], DEV_TYPE, DEV_NUM[2] { (* DEVICE_INIT counts the number of responses per query. It should *) (* get as many responses as there are number of devices in chain. *) DEVICE_INIT = DEVICE_INIT + 1 IF (DEVICE_INIT > NDEVICES) DEVICE_INIT = NDEVICES (*** DEBUGGING ***) IF (DEBUG) SEND_STRING 0,"'FROM SP: ',EF_BUFFER,13,10" (* GET DEV TYPE *) DEV_TYPE = 0 WHILE (!DEV_TYPE) { DEV_TYPE = GET_BUFFER_CHAR(EF_BUFFER) IF (DEV_TYPE <> 'A') (* || DEV_TYPE <> 'C') *) DEV_TYPE = 0 } (* GET/CHECK DEV NUMBER *) DEV_NUM = LEFT_STRING(EF_BUFFER,2) TRASH = REMOVE_STRING(EF_BUFFER,"DEV_NUM",1) (* Save device type and ID information for PONG response *) DEV_INFO = "DEV_TYPE,DEV_NUM" J = 1 DEV_IDX = 0 WHILE (J <= NDEVICES) { IF (FIND_STRING(DEVS[J],"DEV_INFO",1)) { DEV_IDX = J J = NDEVICES } J = J + 1 } (*** DEBUGGING ***) IF (DEBUG) SEND_STRING 0,"'PROC SP: DEV_IDX=',ITOA(DEV_IDX),13,10" SELECT { ACTIVE (FIND_STRING(EF_BUFFER, 'AA', 1)=1) : CALL 'HANDLE AA' ACTIVE (FIND_STRING(EF_BUFFER, 'AGC', 1)=1) : CALL 'HANDLE AGC' ACTIVE (FIND_STRING(EF_BUFFER, 'AH', 1)=1) : CALL 'HANDLE AH' ACTIVE (FIND_STRING(EF_BUFFER, 'CALLP', 1)=1) : CALL 'HANDLE CALLP' ACTIVE (FIND_STRING(EF_BUFFER, 'CID', 1)=1) : CALL 'HANDLE CID' ACTIVE (FIND_STRING(EF_BUFFER, 'DTMF', 1)=1) : CALL 'HANDLE DTMF' ACTIVE (FIND_STRING(EF_BUFFER, 'ERROR', 1)=1) : CALL 'HANDLE ERROR' ACTIVE (FIND_STRING(EF_BUFFER, 'GAINA', 1)=1) : CALL 'HANDLE GAINA' ACTIVE (FIND_STRING(EF_BUFFER, 'GAINP', 1)=1) : CALL 'HANDLE GAINP' ACTIVE (FIND_STRING(EF_BUFFER, 'HOLD', 1)=1) : CALL 'HANDLE HOLD' ACTIVE (FIND_STRING(EF_BUFFER, 'LEC', 1)=1) : CALL 'HANDLE LEC' ACTIVE (FIND_STRING(EF_BUFFER, 'LOCKFP', 1)=1): CALL 'HANDLE LOCKFP' ACTIVE (FIND_STRING(EF_BUFFER, 'MUTE', 1)=1) : CALL 'HANDLE MUTE' ACTIVE (FIND_STRING(EF_BUFFER, 'NS', 1)=1) : CALL 'HANDLE NS' ACTIVE (FIND_STRING(EF_BUFFER, 'PHONE', 1)=1) : CALL 'HANDLE PHONE' ACTIVE (FIND_STRING(EF_BUFFER, 'PONG', 1)=1) : CALL 'HANDLE PONG' ACTIVE (FIND_STRING(EF_BUFFER, 'PRIVACY', 1)=1): CALL 'HANDLE PRIVACY' ACTIVE (FIND_STRING(EF_BUFFER, 'REMCON', 1)=1): CALL 'HANDLE REMCON' ACTIVE (FIND_STRING(EF_BUFFER, 'RESTNV', 1)=1): CALL 'HANDLE RESTNV' ACTIVE (FIND_STRING(EF_BUFFER, 'RING', 1)=1) : CALL 'HANDLE RING' ACTIVE (FIND_STRING(EF_BUFFER, 'SAVENV', 1)=1): CALL 'HANDLE SAVENV' ACTIVE (FIND_STRING(EF_BUFFER, 'SWVER', 1)=1) : CALL 'HANDLE SWVER' ACTIVE (FIND_STRING(EF_BUFFER, 'TONEE', 1)=1) : CALL 'HANDLE TONEE' ACTIVE (FIND_STRING(EF_BUFFER, 'TONER', 1)=1) : CALL 'HANDLE TONER' (* ACTIVE (1): SEND_COMMAND TP, "'TEXT', ITOA(B_CALLP_STAT), '-', EF_BUFFER" *) } } (*-----------------------------------------------------------------*) (* Subroutine: PROCESS BUFFER *) (* *) (* This subroutine is called from the MAIN program. Each time it *) (* is called, it gets a character from the serial port buffer and *) (* places it in the EF_BUFFER buffer. If it gets an ASCII(13) *) (* character, then it knows it has a complete command, so it calls *) (* the PROCESS MESSAGE subroutine to handle the command. *) (*-----------------------------------------------------------------*) (*-----------------------------------------------------------------*) (* Subroutine: DIAL *) (* *) (* This subroutine is called each time the user pushes a 'phone' *) (* button on the keypad. It generates the dial string and updates *) (* the display so the user can see what numbers he is dialing. *) (*-----------------------------------------------------------------*) DEFINE_CALL 'DIAL' (DIGIT) LOCAL_VAR STR[2] LEN { (* If dialing out and passcode is enabled, turn off HOLD *) IF ([TP, B_PASSCODE]) SEND_STRING SP, "DEV_STRING, 'HOLD0', 13" IF ( DIGIT = 20 ) STR = "'*'" ELSE IF ( DIGIT = 21) STR = "'#'" ELSE STR = ITOA(DIGIT) SEND_STRING SP, "DEV_STRING, 'DIAL', STR, 13" IF ( LENGTH_STRING(DIAL_STRING) = 0) DIAL_STRING = "'Calling: '" DIAL_STRING = "DIAL_STRING, STR" LEN = LENGTH_STRING(DIAL_STRING) IF ( LEN > 20 ) DIAL_STRING = "RIGHT_STRING(DIAL_STRING, 20 )" SEND_COMMAND TP, "'TEXT', ITOA(B_DIAL_STAT), '-', DIAL_STRING" } (*-----------------------------------------------------------------*) (* Subroutine: RESET DEVICE *) (* *) (* This subroutine resets the initialization variables used to *) (* check if commands were queried correctly. *) (*-----------------------------------------------------------------*) DEFINE_CALL 'RESET DEVICE' { (* Clear serial port and buffer *) SEND_STRING SP, "13, 13, 13" SERIAL_PORT_BUFFER = "" (* Reset flag to choose new device *) DEVID = 200 TEMP_GAINA = 3 DTMF_TONE = 0 SEND_COMMAND TP, "'Page-Main Page'" } (*-----------------------------------------------------------------*) (* Subroutine: DISPLAY DEVS *) (* *) (* This subroutine clears all the buttons on the Devices page *) (* before devices are displayed and displays the devices on the *) (* buttons. *) (*-----------------------------------------------------------------*) DEFINE_CALL 'DISPLAY DEVS' LOCAL_VAR Y, Z, B_DEV, B_CURRENTDEV { (* Initialize buttons on Devices page *) Z = 0 WHILE (Z <= (NDEVICES-1)) { B_DEV = B_DEV1 + Z SEND_COMMAND TP, "'TEXT', ITOA(B_DEV), '-', ''" Z = Z + 1 } (* Display devices *) Y = 1 B_CURRENTDEV = 0 WHILE (Y <= NDEVICES) { B_CURRENTDEV = B_DEV1 + Y - 1 IF (Y = CDEV_IDX) SEND_COMMAND TP, "'TEXT', ITOA(B_CURRENTDEV), '-', 'Selected ID: ',DEVS[Y]" ELSE SEND_COMMAND TP, "'TEXT', ITOA(B_CURRENTDEV), '-', DEVS[Y]" Y = Y + 1 } } (*-----------------------------------------------------------------*) (* Subroutine: INIT DEV_LIST *) (* *) (* This subroutine will build the device list by sending a PING to *) (* the EF200 and building the dev. list using the PONG responses. *) (*-----------------------------------------------------------------*) DEFINE_CALL 'INIT DEV_LIST' LOCAL_VAR X { NUMDEV = 0 (* Clear serial port and buffer *) SEND_STRING SP, "13, 13, 13" SERIAL_PORT_BUFFER = "" X = 1 WHILE (X <= NDEVICES) { DEVS[X] = '' X = X + 1 } SEND_STRING SP,"'A**PING',13" DEVICE_INIT = 0 ON[WAITING_FOR_PONGS] WAIT PONG_WAIT 'DONE WITH PONG' OFF[WAITING_FOR_PONGS] } (*******************************************************************) (* Startup Code *) (*******************************************************************) DEFINE_START DEBUG = 1 CREATE_BUFFER SP, SERIAL_PORT_BUFFER CREATE_BUFFER 0, MASTER_MSG_BUFFER SEND_COMMAND TP,"'TEXT', ITOA(B_MASTERPROG), '-',__FILE__,', ',__DATE__,', '__TIME__" SEND_COMMAND TP,"'TEXT', ITOA(B_COMPREV), '-','3.05'" CLEAR_BUFFER SERIAL_PORT_BUFFER (* Initialize Button States *) OFF[TP, B_PRIVACY] ON[INITIALIZING] SEND_COMMAND TP, "'PAGE-InitPage'" (*CALL 'RESET DEVICE' *) INIT_STEP = 0 WAITING_FOR_PONGS = 0 DEVICE_INIT = NDEVICES (***********************************************************) (* THE ACTUAL PROGRAM GOES BELOW *) (***********************************************************) DEFINE_PROGRAM (* Initialization *) SELECT { ACTIVE (WAITING_FOR_PONGS): {} ACTIVE (DEVICE_INIT <> NDEVICES): { WAIT 50 'SP TO' DEVICE_INIT = NDEVICES } ACTIVE (INIT_STEP = 0): { CALL 'INIT DEV_LIST' INIT_STEP = INIT_STEP + 1 DEVICE_INIT = 0 } ACTIVE (INIT_STEP = 1): { DEV_STRING = DEVS[1] CDEV_IDX = 1 SEND_STRING SP,"'A**AA?',13" INIT_STEP = INIT_STEP + 1 DEVICE_INIT = 0 } ACTIVE (INIT_STEP = 2): { SEND_STRING SP,"'A**AGC?',13" INIT_STEP = INIT_STEP + 1 DEVICE_INIT = 0 } ACTIVE (INIT_STEP = 3): { SEND_STRING SP,"'A**AH?',13" INIT_STEP = INIT_STEP + 1 DEVICE_INIT = 0 } ACTIVE (INIT_STEP = 4): { SEND_STRING SP,"'A**PHONE?',13" INIT_STEP = INIT_STEP + 1 DEVICE_INIT = 0 } ACTIVE (INIT_STEP = 5): { SEND_STRING SP,"'A**NS?',13" INIT_STEP = INIT_STEP + 1 DEVICE_INIT = 0 } ACTIVE (INIT_STEP = 6): { SEND_STRING SP,"'A**NSL?',13" INIT_STEP = INIT_STEP + 1 DEVICE_INIT = 0 } ACTIVE (INIT_STEP = 7): { SEND_STRING SP,"'A**CALLP?',13" INIT_STEP = INIT_STEP + 1 DEVICE_INIT = 0 } ACTIVE (INIT_STEP = 8): { SEND_STRING SP,"'A**CID?',13" INIT_STEP = INIT_STEP + 1 DEVICE_INIT = 0 } ACTIVE (INIT_STEP = 9): { SEND_STRING SP,"'A**DTMF?',13" INIT_STEP = INIT_STEP + 1 DEVICE_INIT = 0 } ACTIVE (INIT_STEP = 10): { SEND_STRING SP,"'A**DTMFC?',13" INIT_STEP = INIT_STEP + 1 DEVICE_INIT = 0 } ACTIVE (INIT_STEP = 11): { SEND_STRING SP,"'A**ERROR?',13" INIT_STEP = INIT_STEP + 1 DEVICE_INIT = 0 } ACTIVE (INIT_STEP = 12): { SEND_STRING SP,"'A**GAINA3',13" SEND_LEVEL TP, LEVEL_GAINA, 3 (* Initialize variable that holds previous GAINA when AGC is on *) TEMP_GAINA = 3 ON[TP, B_GAINADN] ON[TP, B_GAINAUP] INIT_STEP = INIT_STEP + 1 DEVICE_INIT = 0 } ACTIVE (INIT_STEP = 13): { SEND_STRING SP,"'A**GAINP0',13" SEND_LEVEL TP, LEVEL_GAINP, 0 ON[TP, B_GAINPDN] OFF[TP, B_GAINPUP] INIT_STEP = INIT_STEP + 1 DEVICE_INIT = 0 } ACTIVE (INIT_STEP = 14): { SEND_STRING SP,"'A**HOLD?',13" INIT_STEP = INIT_STEP + 1 DEVICE_INIT = 0 } ACTIVE (INIT_STEP = 15): { SEND_STRING SP,"'A**LEC?',13" INIT_STEP = INIT_STEP + 1 DEVICE_INIT = 0 } ACTIVE (INIT_STEP = 16): { SEND_STRING SP,"'A**LOCKFP?',13" INIT_STEP = INIT_STEP + 1 DEVICE_INIT = 0 } ACTIVE (INIT_STEP = 17): { SEND_STRING SP,"'A**PRIVACY?',13" INIT_STEP = INIT_STEP + 1 DEVICE_INIT = 0 } ACTIVE (INIT_STEP = 18): { SEND_STRING SP,"'A**MUTEP?',13" INIT_STEP = INIT_STEP + 1 DEVICE_INIT = 0 } ACTIVE (INIT_STEP = 19): { SEND_STRING SP,"'A**MUTER?',13" INIT_STEP = INIT_STEP + 1 DEVICE_INIT = 0 } ACTIVE (INIT_STEP = 20): { SEND_STRING SP,"'A**REMCON?',13" INIT_STEP = INIT_STEP + 1 DEVICE_INIT = 0 } ACTIVE (INIT_STEP = 21): { SEND_STRING SP,"'A**RING?',13" INIT_STEP = INIT_STEP + 1 DEVICE_INIT = 0 } ACTIVE (INIT_STEP = 22): { SEND_STRING SP,"'A**TONEE?',13" INIT_STEP = INIT_STEP + 1 DEVICE_INIT = 0 } ACTIVE (INIT_STEP = 23): { SEND_STRING SP,"'A**TONER?',13" INIT_STEP = INIT_STEP + 1 DEVICE_INIT = 0 } ACTIVE (INIT_STEP = 24): { SEND_STRING SP,"'A**SWVER?',13" INIT_STEP = INIT_STEP + 1 (* Initialization finished *) CALL 'DISPLAY DEVS' DEVID = ATOI(DEVS[CDEV_IDX]) SEND_COMMAND TP, "'TEXT', ITOA(B_EF200ID), '-', ITOA(DEVID)" WAIT_UNTIL (ATOI(SWVER_ARY[1])) SEND_COMMAND TP, "'TEXT', ITOA(B_EF200REV), '-', SWVER_ARY[CDEV_IDX]" DEV_STRING = DEVS[1] (* Default set to first device *) (* Added B_DEVINFO button to show current device *) SEND_COMMAND TP, "'TEXT', ITOA(B_DEVINFO), '-', DEV_STRING" SEND_COMMAND TP, "'Page-Devices'" } } (* MAIN PAGE *) PUSH[TP, B_PHONE] SEND_STRING SP, "DEV_STRING, 'PHONE2', 13" PUSH[TP, B_DIAL1] CALL 'DIAL' (1) PUSH[TP, B_DIAL2] CALL 'DIAL' (2) PUSH[TP, B_DIAL3] CALL 'DIAL' (3) PUSH[TP, B_DIAL4] CALL 'DIAL' (4) PUSH[TP, B_DIAL5] CALL 'DIAL' (5) PUSH[TP, B_DIAL6] CALL 'DIAL' (6) PUSH[TP, B_DIAL7] CALL 'DIAL' (7) PUSH[TP, B_DIAL8] CALL 'DIAL' (8) PUSH[TP, B_DIAL9] CALL 'DIAL' (9) PUSH[TP, B_DIALS] CALL 'DIAL' (20) PUSH[TP, B_DIAL0] CALL 'DIAL' (0) PUSH[TP, B_DIALP] CALL 'DIAL' (21) PUSH[TP, B_PRIVACY] { SEND_STRING SP, "DEV_STRING, 'PRIVACY2', 13" } IF ( GET_TIMER >= 18 ) { IF ( NOT CP_RESET ) { SEND_COMMAND TP, "'TEXT', ITOA(B_CALLP_STAT), '-',''" ON[CP_RESET] } IF ( RING_TIMER ) (* then clear the Ring! message *) { OFF[RING_TIMER] SEND_COMMAND TP, "'TEXT', ITOA(B_DIAL_STAT), '-', ''" } } PUSH[TP, B_HOLD] SEND_STRING SP, "DEV_STRING, 'HOLD2', 13" PUSH[TP, B_FLASH] { IF ([TP, B_PHONE]) { SEND_STRING SP, "DEV_STRING, 'FLASH', 13" ON[TP, B_FLASH] } } PUSH[TP, B_REMCON] SEND_STRING SP, "DEV_STRING, 'REMCON2', 13" (* OPTIONS PAGE *) PUSH[TP, B_AA] SEND_STRING SP, "DEV_STRING, 'AA2', 13" PUSH[TP, B_AH] SEND_STRING SP, "DEV_STRING, 'AH2', 13" PUSH[TP, B_AGC] SEND_STRING SP, "DEV_STRING, 'AGC2', 13" (* GAINA RAMPING *) PUSH[TP, B_GAINAUP] { IF (!AGC_ARY[CDEV_IDX]) { OFF[RAMP_GAINADN] ON[RAMP_GAINAUP] GAINA_LEV_ARY[CDEV_IDX] = GAINA_LEV_ARY[CDEV_IDX] + 1 IF (GAINA_LEV_ARY[CDEV_IDX] >= 18) { GAINA_LEV_ARY[CDEV_IDX] = 18 OFF[RAMP_GAINAUP] } IF (GAINA_LEV_ARY[CDEV_IDX] < 6) SEND_STRING SP, "DEV_STRING, 'GAINA-',ITOA(6-GAINA_LEV_ARY[CDEV_IDX]), 13" ELSE SEND_STRING SP, "DEV_STRING, 'GAINA',ITOA(GAINA_LEV_ARY[CDEV_IDX]-6), 13" } } [TP, B_GAINAUP] = (RAMP_GAINAUP) RELEASE[TP, B_GAINAUP] { OFF[RAMP_GAINAUP] CANCEL_WAIT 'GAINA REP' } PUSH[TP, B_GAINADN] { IF (!AGC_ARY[CDEV_IDX]) { ON[RAMP_GAINADN] OFF[RAMP_GAINAUP] GAINA_LEV_ARY[CDEV_IDX] = GAINA_LEV_ARY[CDEV_IDX] - 1 IF (GAINA_LEV_ARY[CDEV_IDX] > 18) { GAINA_LEV_ARY[CDEV_IDX] = 0 OFF[RAMP_GAINADN] } IF (GAINA_LEV_ARY[CDEV_IDX] < 6) SEND_STRING SP, "DEV_STRING, 'GAINA-',ITOA(6-GAINA_LEV_ARY[CDEV_IDX]), 13" ELSE SEND_STRING SP, "DEV_STRING, 'GAINA',ITOA(GAINA_LEV_ARY[CDEV_IDX]-6), 13" } } [TP, B_GAINADN] = (RAMP_GAINADN) RELEASE[TP, B_GAINADN] { OFF[RAMP_GAINADN] CANCEL_WAIT 'GAINA REP' } (* GAINA REPEATS *) IF (RAMP_GAINAUP) { WAIT GAINA_REP 'GAINA REP' { GAINA_LEV_ARY[CDEV_IDX] = GAINA_LEV_ARY[CDEV_IDX] + 1 IF (GAINA_LEV_ARY[CDEV_IDX] >= 18) { GAINA_LEV_ARY[CDEV_IDX] = 18 OFF[RAMP_GAINAUP] } IF (GAINA_LEV_ARY[CDEV_IDX] < 6) SEND_STRING SP, "DEV_STRING, 'GAINA-',ITOA(6-GAINA_LEV_ARY[CDEV_IDX]), 13" ELSE SEND_STRING SP, "DEV_STRING, 'GAINA',ITOA(GAINA_LEV_ARY[CDEV_IDX]-6), 13" } } ELSE IF (RAMP_GAINADN) { WAIT GAINA_REP 'GAINA REP' { GAINA_LEV_ARY[CDEV_IDX] = GAINA_LEV_ARY[CDEV_IDX] - 5 IF (GAINA_LEV_ARY[CDEV_IDX] > 18) { GAINA_LEV_ARY[CDEV_IDX] = 0 OFF[RAMP_GAINADN] } IF (GAINA_LEV_ARY[CDEV_IDX] < 6) SEND_STRING SP, "DEV_STRING, 'GAINA-',ITOA(6-GAINA_LEV_ARY[CDEV_IDX]), 13" ELSE SEND_STRING SP, "DEV_STRING, 'GAINA',ITOA(GAINA_LEV_ARY[CDEV_IDX]-6), 13" } } (* GAINP RAMPING *) PUSH[TP, B_GAINPUP] { OFF[RAMP_GAINPDN] ON[RAMP_GAINPUP] ON[RAMP_GAINP_DELAY] WAIT GAINP_DELAY 'GAINP DELAY' OFF[RAMP_GAINP_DELAY] GAINP_LEV_ARY[CDEV_IDX] = GAINP_LEV_ARY[CDEV_IDX] + 1 IF (GAINP_LEV_ARY[CDEV_IDX] >= 99) { GAINP_LEV_ARY[CDEV_IDX] = 99 OFF[RAMP_GAINPUP] } IF (GAINP_LEV_ARY[CDEV_IDX] = 99) SEND_STRING SP, "DEV_STRING, 'GAINP0', 13" ELSE SEND_STRING SP, "DEV_STRING, 'GAINP-',ITOA(99-GAINP_LEV_ARY[CDEV_IDX]), 13" } [TP, B_GAINPUP] = (RAMP_GAINPUP) RELEASE[TP, B_GAINPUP] { OFF[RAMP_GAINPUP] CANCEL_WAIT 'GAINP REP' CANCEL_WAIT 'GAINP DELAY' } PUSH[TP, B_GAINPDN] { ON[RAMP_GAINPDN] OFF[RAMP_GAINPUP] ON[RAMP_GAINP_DELAY] WAIT GAINP_DELAY 'GAINP DELAY' OFF[RAMP_GAINP_DELAY] GAINP_LEV_ARY[CDEV_IDX] = GAINP_LEV_ARY[CDEV_IDX] - 1 IF (GAINP_LEV_ARY[CDEV_IDX] > 99) { GAINP_LEV_ARY[CDEV_IDX] = 0 OFF[RAMP_GAINPDN] } IF (GAINP_LEV_ARY[CDEV_IDX] = 99) SEND_STRING SP, "DEV_STRING, 'GAINP0', 13" ELSE SEND_STRING SP, "DEV_STRING, 'GAINP-',ITOA(99-GAINP_LEV_ARY[CDEV_IDX]), 13" } [TP, B_GAINPDN] = (RAMP_GAINPDN) RELEASE[TP, B_GAINPDN] { OFF[RAMP_GAINPDN] CANCEL_WAIT 'GAINP REP' CANCEL_WAIT 'GAINP DELAY' } (* GAINP REPEATS *) IF (RAMP_GAINPUP && (!RAMP_GAINP_DELAY)) { WAIT GAINP_REP 'GAINP REP' { GAINP_LEV_ARY[CDEV_IDX] = GAINP_LEV_ARY[CDEV_IDX] + 5 IF (GAINP_LEV_ARY[CDEV_IDX] >= 99) { GAINP_LEV_ARY[CDEV_IDX] = 99 OFF[RAMP_GAINPUP] } IF (GAINP_LEV_ARY[CDEV_IDX] = 99) SEND_STRING SP, "DEV_STRING, 'GAINP0', 13" ELSE SEND_STRING SP, "DEV_STRING, 'GAINP-',ITOA(99-GAINP_LEV_ARY[CDEV_IDX]), 13" } } ELSE IF (RAMP_GAINPDN && (!RAMP_GAINP_DELAY)) { WAIT GAINP_REP 'GAINP REP' { GAINP_LEV_ARY[CDEV_IDX] = GAINP_LEV_ARY[CDEV_IDX] - 5 IF (GAINP_LEV_ARY[CDEV_IDX] > 99) { GAINP_LEV_ARY[CDEV_IDX] = 0 OFF[RAMP_GAINPDN] } IF (GAINP_LEV_ARY[CDEV_IDX] = 99) SEND_STRING SP, "DEV_STRING, 'GAINP0', 13" ELSE SEND_STRING SP, "DEV_STRING, 'GAINP-',ITOA(99-GAINP_LEV_ARY[CDEV_IDX]), 13" } } PUSH[TP, B_MUTER] SEND_STRING SP, "DEV_STRING, 'MUTER2', 13" PUSH[TP, B_MUTEP] SEND_STRING SP, "DEV_STRING, 'MUTEP2', 13" PUSH [TP, B_PASSCODE] [TP, B_PASSCODE] = NOT[TP, B_PASSCODE] (* ADVANCED PAGE *) PUSH[TP, B_CALLP] SEND_STRING SP,"DEV_STRING, 'CALLP2', 13" PUSH[TP, B_CALLERID] SEND_STRING SP, "DEV_STRING, 'CID2', 13" PUSH[TP, B_DTMF] SEND_STRING SP, "DEV_STRING, 'DTMF2', 13" PUSH[TP, B_DTMFC] SEND_STRING SP, "DEV_STRING, 'DTMFC2', 13" PUSH[TP, B_ERROR] SEND_STRING SP, "DEV_STRING, 'ERROR2', 13" PUSH[TP, B_LEC] SEND_STRING SP, "DEV_STRING, 'LEC2', 13" PUSH[TP, B_LOCKFP] SEND_STRING SP, "DEV_STRING, 'LOCKFP2', 13" PUSH[TP, B_NS] SEND_STRING SP, "DEV_STRING, 'NS2', 13" PUSH[TP,B_NS_LEVEL] { IF ([TP,B_NS_LEVEL]) SEND_STRING SP, "DEV_STRING, 'NSL6', 13" ELSE SEND_STRING SP, "DEV_STRING, 'NSL10', 13" } PUSH[TP, B_RESTNV] SEND_STRING SP, "DEV_STRING, 'RESTNV', 13" PUSH[TP, B_RING] SEND_STRING SP, "DEV_STRING, 'RING2', 13" PUSH[TP, B_SAVENV] SEND_STRING SP, "DEV_STRING, 'SAVENV', 13" PUSH[TP, B_TONEE] SEND_STRING SP, "DEV_STRING, 'TONEE2', 13" PUSH[TP, B_TONER] SEND_STRING SP, "DEV_STRING, 'TONER2', 13" PUSH[TP, B_DEVICES] { CALL 'INIT DEV_LIST' (* Added this so DEVS array would be filled before displaying *) WAIT_UNTIL (!(WAITING_FOR_PONGS)) CALL 'DISPLAY DEVS' } (* DEVICES PAGE *) (* DEVNUM is the index in DEVS array. CHOOSE_NEWDEV is used as a flag *) PUSH[TP, B_DEV1] DEVNUM = 1 PUSH[TP, B_DEV2] DEVNUM = 2 PUSH[TP, B_DEV3] DEVNUM = 3 PUSH[TP, B_DEV4] DEVNUM = 4 PUSH[TP, B_DEV5] DEVNUM = 5 PUSH[TP, B_DEV6] DEVNUM = 6 PUSH[TP, B_DEV7] DEVNUM = 7 PUSH[TP, B_DEV8] DEVNUM = 8 PUSH[TP, B_DEV9] DEVNUM = 9 PUSH[TP, B_DEV10] DEVNUM = 10 PUSH[TP, B_DEV11] DEVNUM = 11 PUSH[TP, B_DEV12] DEVNUM = 12 PUSH[TP, B_DEV13] DEVNUM = 13 PUSH[TP, B_DEV14] DEVNUM = 14 PUSH[TP, B_DEV15] DEVNUM = 15 PUSH[TP, B_DEV16] DEVNUM = 16 PUSH[TP, B_DEV17] DEVNUM = 17 PUSH[TP, B_DEV18] DEVNUM = 18 PUSH[TP, B_DEV19] DEVNUM = 19 PUSH[TP, B_DEV20] DEVNUM = 20 PUSH[TP, B_DEV21] DEVNUM = 21 PUSH[TP, B_DEV22] DEVNUM = 22 PUSH[TP, B_DEV23] DEVNUM = 23 PUSH[TP, B_DEV24] DEVNUM = 24 PUSH[TP, B_DEV25] DEVNUM = 25 PUSH[TP, B_DEV26] DEVNUM = 26 PUSH[TP, B_DEV27] DEVNUM = 27 PUSH[TP, B_DEV28] DEVNUM = 28 PUSH[TP, B_DEV29] DEVNUM = 29 PUSH[TP, B_DEV30] DEVNUM = 30 (* If CHOOSE_NEWDEV is true AND there is device info in DEVS[DEVNUM] *) IF (CDEV_IDX <> DEVNUM) { IF (DEVS[DEVNUM] <> '') { (* Assign new device info to DEV_STRING *) DEV_STRING = DEVS[DEVNUM] CDEV_IDX = DEVNUM (* Initialize to new device *) SEND_COMMAND TP, "'PAGE-InitPage'" CALL 'RESET DEVICE' } ELSE (* Button selected didn't have a Device ID on it *) { DEVNUM = CDEV_IDX (* Give warning double beep *) SEND_COMMAND TP,'ADBEEP' } } (* Feedback on all pages *) [TP, B_AA] = AA_ARY[CDEV_IDX] [TP, B_AGC] = AGC_ARY[CDEV_IDX] [TP, B_AH] = AH_ARY[CDEV_IDX] [TP, B_CALLP] = CALLP_ARY[CDEV_IDX] [TP, B_CALLERID] = CID_ARY[CDEV_IDX] (* SEND_COMMAND TP, "'TEXT', ITOA(B_CID_NUMBER), '-', ' '" SEND_COMMAND TP, "'TEXT', ITOA(B_CID_NAME), '-', ' '" SEND_COMMAND TP, "'TEXT', ITOA(B_CID_DATE), '-', ' '" SEND_COMMAND TP, "'TEXT', ITOA(B_DIAL_STAT), '-',''" *) [TP, B_DTMF] = DTMF_ARY[CDEV_IDX] [TP, B_DTMFC] = DTMFC_ARY[CDEV_IDX] [TP, B_ERROR] = ERROR_ARY[CDEV_IDX] [TP, B_HOLD] = HOLD_ARY[CDEV_IDX] [TP, B_LEC] = LEC_ARY[CDEV_IDX] [TP, B_LOCKFP] = LOCKFP_ARY[CDEV_IDX] [TP, B_MUTEP] = MUTEP_ARY[CDEV_IDX] [TP, B_MUTER] = MUTER_ARY[CDEV_IDX] [TP, B_NS] = NS_ARY[CDEV_IDX] [TP, B_NS_LEVEL] = NSL_ARY[CDEV_IDX] [TP, B_PHONE] = PHONE_ARY[CDEV_IDX] [TP, B_PRIVACY] = PRIVACY_ARY[CDEV_IDX] [TP, B_REMCON] = REMCON_ARY[CDEV_IDX] [TP, B_RING] = RING_ARY[CDEV_IDX] [TP, B_TONEE] = TONEE_ARY[CDEV_IDX] [TP, B_TONER] = TONER_ARY[CDEV_IDX] (* WATCH FOR DEVICE CHANGE *) IF (PREV_CDEV_IDX <> CDEV_IDX) { DEVID = ATOI(DEVS[CDEV_IDX]) SEND_COMMAND TP, "'TEXT', ITOA(B_EF200ID), '-', ITOA(DEVID)" SEND_COMMAND TP, "'TEXT', ITOA(B_DEVINFO), '-', DEV_STRING" SEND_COMMAND TP, "'TEXT', ITOA(B_EF200REV), '-', SWVER_ARY[CDEV_IDX]" (* FORCE_UPDATE is a flag used for *) PREV_CP_STAT = FORCE_UPDATE PREV_CALLP = FORCE_UPDATE PREV_GAINA_LVL = FORCE_UPDATE PREV_GAINP_LVL = FORCE_UPDATE } PREV_CDEV_IDX = CDEV_IDX (* UPDATE CALL PROGRESS STATUS *) IF (PREV_CP_STAT <> CALLP_STAT_ARY[CDEV_IDX] || PREV_CALLP <> CALLP_ARY[CDEV_IDX]) { CP_STAT = CALLP_STAT_ARY[CDEV_IDX] SELECT { ACTIVE ( CP_STAT = CP_REORDER ):SEND_COMMAND TP, "'TEXT', ITOA(B_CALLP_STAT), '-', 'Reorder'" ACTIVE ( CP_STAT = CP_BUSY ): SEND_COMMAND TP, "'TEXT', ITOA(B_CALLP_STAT), '-', 'Busy'" ACTIVE ( CP_STAT = CP_RING ): SEND_COMMAND TP, "'TEXT', ITOA(B_CALLP_STAT), '-', 'Ringing'" ACTIVE ( CP_STAT = CP_DIALTONE ):SEND_COMMAND TP, "'TEXT', ITOA(B_CALLP_STAT), '-', 'Dialtone'" ACTIVE ( 1 ): SEND_COMMAND TP, "'TEXT', ITOA(B_CALLP_STAT), '-', ''" } CANCEL_WAIT 'CLEAR CL STAT' IF (CALLP_STAT_ARY[CDEV_IDX] <> 0) { WAIT 20 'CLEAR CL STAT' CALLP_STAT_ARY[CDEV_IDX] = 0 } } PREV_CP_STAT = CALLP_STAT_ARY[CDEV_IDX] PREV_CALLP = CALLP_ARY[CDEV_IDX] (* GAINA LEVEL *) IF (PREV_GAINA_LVL <> GAINA_LEV_ARY[CDEV_IDX]) { IF (GAINA_LEV_ARY[CDEV_IDX] < 6) SEND_COMMAND TP, "'TEXT', ITOA(B_GAINA_DISPLAY), '-','-', ITOA(6-GAINA_LEV_ARY[CDEV_IDX]), ' dB' " ELSE SEND_COMMAND TP, "'TEXT', ITOA(B_GAINA_DISPLAY), '-', ITOA(GAINA_LEV_ARY[CDEV_IDX]-6), ' dB' " } PREV_GAINA_LVL = GAINA_LEV_ARY[CDEV_IDX] (* Send level to display. There are 255 possible levels, with *) (* 18 increments from -6 dB to 12 dB *) TEMP = GAINA_LEV_ARY[CDEV_IDX] * 255 / 18 SEND_LEVEL TP, LEVEL_GAINA, TEMP (* GAINP LEVEL *) IF (PREV_GAINP_LVL <> GAINP_LEV_ARY[CDEV_IDX]) { IF (GAINP_LEV_ARY[CDEV_IDX] < 99) SEND_COMMAND TP, "'TEXT', ITOA(B_GAINP_DISPLAY), '-','-', ITOA(99-GAINP_LEV_ARY[CDEV_IDX]), ' dB' " ELSE SEND_COMMAND TP, "'TEXT', ITOA(B_GAINP_DISPLAY), '-', ITOA(GAINP_LEV_ARY[CDEV_IDX]-99), ' dB' " } PREV_GAINP_LVL = GAINP_LEV_ARY[CDEV_IDX] (* Send level to display. There are 255 possible levels, with *) (* 100 increments from -99 dB to 0 dB *) TEMP = GAINP_LEV_ARY[CDEV_IDX] * 255 / 99 SEND_LEVEL TP, LEVEL_GAINP, TEMP (* BUFFER PROCESSING *) IF (LENGTH_STRING (SERIAL_PORT_BUFFER) && FIND_STRING(SERIAL_PORT_BUFFER,"13",1)) { EF_BUFFER = REMOVE_STRING(SERIAL_PORT_BUFFER,"13",1) CALL 'PROCESS MESSAGE' } ELSE IF (LENGTH_STRING(SERIAL_PORT_BUFFER) > 50) CLEAR_BUFFER SERIAL_PORT_BUFFER (* SYSTEM_CALL 'MSG' (__FILE__,__DATE__,__TIME__,__NAME__,'3.05') *) (***********************************************************) (* END OF PROGRAM *) (* DO NOT PUT ANY CODE BELOW THIS COMMENT *) (***********************************************************)