atcmd.c

CML CMX868 modem

//---------------------------------------------------------------------------------------------------
//	Project:-	DE8681
//  	Filename:-	ATCMD.C
//	Description:-	Routines for AT Command Functions and Interpretation.
//	Programmer:-	D.T.F	
//	Version:-	2.0
//	Created:-	28th February 2002
//	Last modified:-
//---------------------------------------------------------------------------------------------------
//	(C) Consumer Microcircuits Ltd 2002
//
//	This firmware was designed by:-
//			Consumer Microcircuits Ltd,
//			Langford, Maldon,
//			ESSEX
//			CM9 6WG.
//	in the UK for use with CML evaluation kits only and is based on UK originated technology.
//	Please contact
//			[e-mail]
//			[phone]
//	for licensing details.
//---------------------------------------------------------------------------------------------------

#define ATCMD_C

#include	"ef8681.h"

unsigned char atcmd_interpret(void)
{
	unsigned char retval;

	ATBUFPTR = 0;

	while (ATBUF[ATBUFPTR] != NUL)				// Check if NULL encountered to indicate end of AT command.
	{	

		switch(ATBUF[ATBUFPTR])
		{
			case 'A': case 'a':
				retval = atacmd();		// Routine sets Answer flag in S register
								// AT Command Mode Flag cleared to indicate Handshaking
				break;
			case 'B': case 'b':
				retval = atbcmd();		// Routine to control communication standard
				break;
			case 'D': case 'd':
				retval = atdcmd();		// Routine to extract DTMF digits and set Call flag in S register
								// AT Command Mode Flag cleared to indicate Handshaking
				break;
			case 'E': case'e':
				retval = atecmd();		// Routine to control echo
				break;
			case 'H': case'h':
				retval = athcmd();		// Routine to control hook swicth
				break;
			case 'I': case'i':
				retval = aticmd();		// Routine to provide user product information
				break;
			case 'N': case'n':
				retval = atncmd();		// Routine to enable/disable modulation fallback
				break;
			case 'O': case'o':
				retval = atocmd();		// Routine to revert back to online mode
				break;
			case 'Q': case'q':
				retval = atqcmd();		// Routine to control Modem responses
				break;
			case 'S': case's':
				retval = atscmd();		// Routine to write or read S-Registers
				break;
			case 'V': case'v':
				retval = atvcmd();		// Routine to control result code format
				break;
			case 'X': case'x':
				retval = atxcmd();		// Routine to control calling characteristics
				break;
			case 'Z': case'z':
				retval = atzcmd();		// Routine to reset modem and restore factory profiles
				break;
			case '&':
				retval = xatcmd();		// Routine to excute extended AT Commands
				break;
			case '@':
				retval = cmlatcmd();		// Routine to excute CML specific AT Commands
				break;
			default:
				retval = ERROR;
				break;
		}

		// If an error occurs during interpretation
		// or Manual Answer or Dial has been requested
		// AT Command interpretation will be terminated

		if (retval != OK)
		{
			return (retval);
		}

		ATBUFPTR++;					// Increment AT Command Buffer pointer.
	}	
	return (OK);						// Intepretation has completed successfully or no commands had been entered.
}


unsigned char atacmd(void)
{
	ATCMDMODE = 0;
	ANSORIG = 0;						// Set to indicate answering

	return (NORESULT);
}

unsigned char atbcmd(void)					// Modify Call Characteristic bits located in S27 reg
{
	unsigned char tempreg;

	ATBUFPTR++;						// Increment AT Command Buffer pointer.

	switch(ATBUF[ATBUFPTR])
	{
		case '0':
			tempreg = PROTB0;
			break;
		case '1':
			tempreg = PROTB1;
			break;
		case '2':
			tempreg = PROTB2;
			break;
		case '3':
			tempreg = PROTB3;
			break;
		case '4':
			tempreg = PROTB4;
			break;
		case '5':
			tempreg = PROTB5;
			break;
		case '6':
			tempreg = PROTB6;
			break;
		case '7':
			tempreg = PROTB7;
			break;
		case '8':
			tempreg = PROTB8;
			break;
		case '9':
			tempreg = PROTB9;
			break;
		default:
			return (ERROR);				// Return ERROR to indicate invalid character
	}
	S27 &= 0b00001111;					// Clear existing Protocol settings 

	S27 ^= tempreg;						// Modify S27 to reflect new settings

	return (OK);						// Return OK to indicate success
}

unsigned char atdcmd(void)
{
	unsigned char	i, tmp;

	ATBUFPTR++;						// Increment AT Command Buffer pointer.

	tmp = ATBUF[ATBUFPTR];					// Load temporary character register

	if ((tmp == 'L') || (tmp == 'l'))
	{
		if (TELNUM[0] != NUL)
		{
			ATCMDMODE = 0;				// Clear AT Command Mode Flag
			ANSORIG = 1;				// Set to indicate originate
			return (NORESULT);			// Return NORESULT to indicate success without result code.
		}
		else
		{
			return (ERROR);				// Return ERROR to indicate no previous telephone number exists
		}
	}

	i = 0;

	while ((tmp <= '9' && tmp >= '0') || (tmp <= 'D' && tmp >= 'A')
		|| (tmp <= 'd' && tmp >= 'a') || tmp == '#' || tmp == '*' || tmp == ',')
	{
		TELNUM[i++] = tmp;				// Load character into telephone digit buffer

		if (i >= maxteldigits)
		{
			TELNUM[0] = NUL;			// Destroy previous loaded digits due to error
			return(ERROR);				// Return ERROR to indicate telephone digit buffer is full
		}

		ATBUFPTR++;					// Increment AT Command Buffer pointer.

		tmp = ATBUF[ATBUFPTR];				// Load temporary character register
	}

	if (i > 0)
	{
		ATBUFPTR--;					// Decrement AT Command Buffer pointer (not essential because interpreter will be terminated)
		TELNUM[i] = NUL;				// Null terminate telephone digit string
		ATCMDMODE = 0;					// Clear AT Command Mode Flag
		ANSORIG = 1;					// Set to indicate originate
		return(NORESULT);				// Return NORESULT to indicate success without result code.
	}
	else
	{
		return (ERROR);					// Return ERROR to indicate no previous telephone number exists
	}
}

unsigned char atecmd(void)					// Modify Echo Character bit located in S14 reg
{
	ATBUFPTR++;						// Increment AT Command Buffer pointer.

	switch(ATBUF[ATBUFPTR])
	{
		case '0':
			ECHO = OFF;				// Disable Echoing
			break;
		case '1':
			ECHO = ON;				// Enable Echoing
			break;
		default:
			return (ERROR);				// Return ERROR to indicate invalid character
	}
	return (OK);						// Return OK to indicate success
}

unsigned char athcmd(void)					// Hook switch control
{
	ATBUFPTR++;						// Increment AT Command Buffer pointer.

	switch(ATBUF[ATBUFPTR])
	{
		case '0':
			hook(0);				// On-Hook
			break;
		case '1':
			hook(1);				// Off-Hook
			break;
		default:
			return (ERROR);				// Return ERROR to indicate invalid character
	}
	return (OK);						// Return OK to indicate success
}

unsigned char aticmd(void)					// Send information to terminal
{
	ATBUFPTR++;						// Increment AT Command Buffer pointer.

	switch(ATBUF[ATBUFPTR])
	{
		case '0':
			genmsgtopc(idmsg);			// Send id message to terminal
			break;
		case '1':
			genmsgtopc(prodmsg);			// Send product message to terminal
			break;
		case '2':
			genmsgtopc(cmlukmsg);			// Send CML UK message to terminal
			genmsgtopc(cmlukwwwmsg);		// Send CML UK Web address message to terminal
			genmsgtopc(cmlukemmsg);			// Send CML UK Email address message to terminal
			genmsgtopc(cmluktelmsg);		// Send CML UK Telephone message to terminal
			break;
		case '3':
			genmsgtopc(cmlsgmsg);			// Send CML Singapore message to terminal
			genmsgtopc(cmlsgemmsg);			// Send CML Singapore Email address message to terminal
			break;
		case '4':
			genmsgtopc(mxcommsg);			// Send MX-COM message to terminal
			genmsgtopc(mxcomemmsg);			// Send MXCOM Email address message to terminal
			break;
		default:
			return (ERROR);				// Return ERROR to indicate invalid character
	}
	return (OK);						// Return OK to indicate success
}

unsigned char atncmd(void)
{
	ATBUFPTR++;						// Increment AT Command Buffer pointer.

	switch(ATBUF[ATBUFPTR])
	{
		case '0':
			FALLBACK = OFF;				// Disable Modulation Fallback
			break;
		case '1':
			FALLBACK = ON;				// Enable Modulation Fallback
			break;
		default:
			return (ERROR);				// Return ERROR to indicate invalid character
	}
	return (OK);						// Return OK to indicate success
}

unsigned char atocmd(void)
{
	DATAXFER = 1;						// Revert back to online data transfer mode
	ATCMDMODE = 0;
	return (NORESULT);
}

unsigned char atqcmd(void)					// Modify Response bit located in S14 reg
{
	ATBUFPTR++;						// Increment AT Command Buffer pointer.

	switch(ATBUF[ATBUFPTR])
	{
		case '0':
			RESOFF = FALSE;				// Enable result code responses
			break;
		case '1':
			RESOFF = TRUE;				// Disable result code responses
			break;
		default:
			return (ERROR);				// Return ERROR to indicate invalid character
	}
	return (OK);						// Return OK to indicate success
}

unsigned char atscmd(void)
{
	unsigned long i;

	unsigned char k=0;

	char tempbuf[3];

	volatile unsigned char bank2 * sregptr;

	unsigned char sreg_offset;

	ATBUFPTR++;						// Increment AT Command Buffer pointer.

	if ((ATBUF[ATBUFPTR] > '9') || (ATBUF[ATBUFPTR] < '0'))
	{
		return(ERROR);
	}

	tempbuf[k++] = ATBUF[ATBUFPTR++];

	if ((ATBUF[ATBUFPTR] <= '9') && (ATBUF[ATBUFPTR] >= '0'))
	{
		tempbuf[k++] = ATBUF[ATBUFPTR++];
	}
	tempbuf[k] = NUL;

	sreg_offset = (atoi(tempbuf)) & 0xFF;			// Convert ASCII decimal to integer
	
	if (sreg_offset >= numsregs)				// Return ERROR if offset exceeds max value
	{							// specified in header file
		return(ERROR);
	}

	sregptr = &S0;
	sregptr += sreg_offset;

	if (ATBUF[ATBUFPTR] == '=')
	{
		ATBUFPTR++;					// Increment AT Command Buffer pointer.

		i = ascregtolong();
		if (i > 255)					// If 8-bit register exceeds 255 return error.
		{
			return (ERROR);
		}
		*sregptr = i;
	}
	else if (ATBUF[ATBUFPTR] == '?')
	{
		if (HEXOP)
		{
			hexnum2scrn(*sregptr,2,WORDRES);	// Send LF char if word results enabled
		}
		else
		{
			decnum2scrn(*sregptr,3,WORDRES);	// Send LF char if word results enabled
		}
	}
	else
	{
		return (ERROR);					// Return ERROR to indicate invalid character
	}
	return (OK);						// Return OK to indicate success
}