atcmd.c

CML CMX868 modem

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

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

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

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

	switch(ATBUF[ATBUFPTR])
	{
		case '0':
			tempreg = X0CALLING;
			break;
		case '1':
			tempreg = X1CALLING;
			break;
		case '2':
			tempreg = X2CALLING;
			break;
		case '3':
			tempreg = X3CALLING;
			break;
		case '4':
			tempreg = X4CALLING;
			break;
		default:
			return (ERROR);				// Return ERROR to indicate invalid character
	}
	S22 &= 0b00011111;					// Clear existing calling characteristics 

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

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

unsigned char atzcmd(void)					// Reset Modem and recall factory profile
{
	ATBUFPTR++;						// Increment AT Command Buffer pointer.

	switch(ATBUF[ATBUFPTR])
	{
		case '0':
			init_sregs(0);				// Recall factory profile 0.
			break;
		case '1':
			init_sregs(1);				// Recall factory profile 1.
			break;
		default:
			return (ERROR);				// Return ERROR to indicate invalid character
	}
	reset_cbus();						// Perform CMX868 General reset and clear device write shadow registers
	return (OK);						// Return OK to indicate success
}

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

	switch(ATBUF[ATBUFPTR])
	{
		case 'F': case 'f':
			return (xatfcmd());
		case 'G': case 'g':
			return (xatgcmd());
		default:
			return (ERROR);
	}
}

unsigned char xatfcmd(void)					// Recall factory profile
{
	ATBUFPTR++;						// Increment AT Command Buffer pointer.

	switch(ATBUF[ATBUFPTR])
	{
		case '0':
			init_sregs(0);				// Recall factory profile 0.
			break;
		case '1':
			init_sregs(1);				// Recall factory profile 1.
			break;
		default:
			return (ERROR);				// Return ERROR to indicate invalid character
	}
	return (OK);						// Return OK to indicate success
}

unsigned char xatgcmd(void)					// Modify Guard Tone bits located in S23 reg
{
	unsigned char tempreg;

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

	switch(ATBUF[ATBUFPTR])
	{
		case '0':
			tempreg = NOGUARD;
			break;
		case '1':
			tempreg = GUARD550;
			break;
		case '2':
			tempreg = GUARD1800;
			break;
		default:
			return (ERROR);				// Return ERROR to indicate invalid character
	}
	S23 &= 0b00111111;					// Clear existing Guard tone settings 

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

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

unsigned char cmlatcmd(void)
{

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

	switch(ATBUF[ATBUFPTR])
	{
		case 'F': case 'f':				// CML Test Functions
			return (cmlatfcmd());
		case 'R': case 'r':
			return (cmlatrcmd());
		default:
			return (ERROR);
	}
}

unsigned char cmlatfcmd(void)					// CML Test Functions
{
	ATBUFPTR++;						// Increment AT Command Buffer pointer.

	switch(ATBUF[ATBUFPTR])
	{
		case '0':
			PORTA = 0b00010000;			// Turn off DCDIND LED
			PORTB |= 0b00000110;			// Ensure RIN and DCDN o/p's are set
			hook(0);				// On-Hook (Hook LED off)
			LED_OVERRIDE = 0;
			break;
		case '1':
			PORTA = 0b00001111;			// Turn on DCDIND, RXDIND, TXDIND, DTRIND and HOOK LEDs
			PORTB &= 0b11111001;			// Clear RIN and DCDN o/p's
			hook(1);				// Off-Hook (Hook LED on)
			LED_OVERRIDE = 1;
			break;
		case '2':
			DelayMs(100);				// Wait 100ms
			break;
		case '3':
			Delay1s(1);				// Wait 1s
			break;
		case '4':
			T0IE = 0;				// Initially disable Timer interrupt
			BERTEND = 0;				// BERT Rx End
			BERTFLAG = 1;				// Set BERT Flag
			break;
		case '5':
			T0IE = 0;				// Initially disable Timer interrupt
			BERTEND = 1;				// BERT Tx End
			BERTFLAG = 1;				// Set BERT Flag
			break;
		case '6':
			TESTFUNC1 = 1;				// Set Test Function One flag
			break;
		case '7':
			GPT6 = 30;				// Load GPT6 for 30 second

			while (PICIRQN != 0)
			{
				if (GPT6 == 0)
				{
					return (ERROR);		// Return ERROR to indicate invalid character
				}
			}
			CMXSTAT = rd16_cbus(CMXSTAT_ADDR);	// Update CMX868 Status Shadow register

			if (HEXOP)
			{
				hexnum2scrn(CMXSTAT,4,WORDRES);	// Send LF char if word results enabled
			}
			else
			{
				decnum2scrn(CMXSTAT,5,WORDRES);	// Send LF char if word results enabled
			}
			break;
		case '8':
			return (NYI);				// Return NYI to indicate function not implemented yet
		case '9':
			return (NYI);				// Return NYI to indicate function not implemented yet
		default:
			return (ERROR);				// Return ERROR to indicate invalid character
	}
	return (OK);						// Return OK to indicate success
}

unsigned char cmlatrcmd(void)
{
	unsigned int j;

	unsigned long i;

	volatile unsigned char bank3 * byteregptr;

	volatile unsigned int bank3 * wordregptr;

	unsigned char cbus_addr, reg16bit, writereg;

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

	switch(ATBUF[ATBUFPTR])
	{
		case 'E': case 'e':

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

			reg16bit = 1;				// Assume 16 bit word unless modified
			writereg = 1;				// Assume write register unless modified

			switch(ATBUF[ATBUFPTR])
			{
				case '0':
					cbus_addr = CMXGENCTRL_ADDR;
					wordregptr = &CMXGENCTRL;
					break;
				case '1':
					cbus_addr = CMXTXMODE_ADDR;
					wordregptr = &CMXTXMODE;
					break;
				case '2':
					cbus_addr = CMXRXMODE_ADDR;
					wordregptr = &CMXRXMODE;
					break;
				case '3':
					reg16bit = 0;
					cbus_addr = CMXTXDATA_ADDR;
					byteregptr = &CMXTXDATA;
					break;
				case '4':
					reg16bit = 0;
					cbus_addr = CMXTXDATAV14_ADDR;
					byteregptr = &CMXTXDATAV14;
					break;
				case '5':
					writereg = 0;
					reg16bit = 0;
					cbus_addr = CMXRXDATA_ADDR;
					byteregptr = &CMXRXDATA;
					break;
				case '6':
					writereg = 0;
					cbus_addr = CMXSTAT_ADDR;
					wordregptr = &CMXSTAT;
					break;
				case '8':
					cbus_addr = CMXPROG_ADDR;
					wordregptr = &CMXPROG;
					break;
				case '9':
					cbus_addr = CMXTESTADDR_ADDR;
					wordregptr = &CMXTESTADDR;
					break;
				case 'A': case 'a':
					cbus_addr = CMXTESTWR_ADDR;
					wordregptr = &CMXTESTWR;
					break;
				case 'B': case 'b':
					writereg = 0;
					cbus_addr = CMXTESTRD_ADDR;
					wordregptr = &CMXTESTRD;
					break;
				default:
					return (ERROR);
			}					

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

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

				i = ascregtolong();
				if ((i > 65535) || (!reg16bit && (i > 255)))	// If 8-bit register and value exceeds 255 return error.
				{
					return (ERROR);
				}

				if (reg16bit)
				{
					*wordregptr = i & 0xFFFF;
					wr16_cbus(cbus_addr,*wordregptr);
				}
				else
				{
					*byteregptr = i & 0xFF;					
					wr_cbus(cbus_addr,*byteregptr);
				}
				break;
			}
			else if ((ATBUF[ATBUFPTR] == '?'))
			{
				if (reg16bit)
				{
					if (!writereg)		// Read CBUS if 16 bit read register 
					{
						*wordregptr = rd16_cbus(cbus_addr);	// Place CBUS reply data into shadow register
					}
					j = *wordregptr & 0xFFFF;			// Copy 16 bit shadow register
				}
				else
				{
					if (!writereg)		// Read CBUS if 8 bit read register 
					{
						*byteregptr = rd_cbus(cbus_addr);	// Place CBUS reply data into shadow register
					}
					j = *byteregptr & 0xFF;	// Copy 8 bit shadow register
				}

				if (HEXOP)
				{
					hexnum2scrn(j,4,WORDRES);			// Send LF char if word results enabled
				}
				else
				{
					decnum2scrn(j,5,WORDRES);			// Send LF char if word results enabled
				}
				break;
			}
			else
			{
				return (ERROR);
			}
		case 'R': case 'r':
			reset_cbus();				// Perform CMX868 General Reset and clear device write shadow registers
			break;
		default:
			return (ERROR);
	}
	return (OK);						// Return OK to indicate success
}

unsigned long ascregtolong(void)
{
	unsigned char tempbuf[6];

	unsigned long tempnum=0;

	unsigned long j=1;

	signed char i,k;

	i=0;

	// Loop while characters are decimal digits  
	// and are no more than 5 digits long i.e. 65535

	while ((ATBUF[ATBUFPTR] <= '9') && (ATBUF[ATBUFPTR] >= '0') && (i < 6))
	{
		tempbuf[i++] = ATBUF[ATBUFPTR++];
	}

	ATBUFPTR--;

	i--;

	for (k=i;k>=0;k--)
	{
		tempnum += (tempbuf[k] - 0x30) * j;
		j *= 10;
	}

	return (tempnum);
}