AVR Freaks

However, could you please elaborate on the circular buffer for receiving the command part? I have read about the idea elsewhere too but I couldn't really understand the advantage over a simple character array.

write_index = (write_index + 1) & (BUFFER_LENGTH - 1);

.cseg
_AND:
;this is the code for the AND command
ret

_DIV:
;this is the code for the AND command
ret

_EOR:
;this is the code for the AND command
ret


.dseg
TOKENS:
.db	"AND",0,"DIV",0,"EOR",
ACTION_ADDRESS:
.dw	_AND, _DIV, _EOR

typedef void (*fptr_t)(void);

typedef struct {
  fptr_t fptr;
  char * str;
} cmd_t;

void and(void) {
  // do and function
}

void divide(void) {
  // do div function
}

void eor(void) {
  // do eor function
}

cmd_t cmd_table[] = {
  { and, "AND" },
  { divide, "DIV" },
  { eor, "EOR" }
};

.global	cmd_table
	.data
.LC0:
	.string	"AND"
.LC1:
	.string	"DIV"
.LC2:
	.string	"EOR"
	.type	cmd_table, @object
	.size	cmd_table, 12
cmd_table:
 ;  fptr:
	.word	gs(and)
 ;  str:
	.word	.LC0
 ;  fptr:
	.word	gs(divide)
 ;  str:
	.word	.LC1
 ;  fptr:
	.word	gs(eor)
 ;  str:
	.word	.LC2

I'd create a structure that holds a string (the command) and a function pointer. Then I'd declare an array of these, in flash, and populate it with the initial values.

Also, the calculation I use for the ijmp address is actually:

(Jump table base address-token offset)+token value

for (i=0; i

/////////////////////////////////////////////////
// Base for a command line handler
// To be used with a terminal program of some kind
//
// Echoes all characters to the serial port
// Handles backspace for editing
// TAB will run the last command
// UP ARROW will load the last command into the command buffer and echo it to the serial port
// Can handle up to 5 parametere in HEX or DEC

typedef struct command {
	char	cmd[10];
	void	(*func)	(void);
};

#define MAX_PARMS 5
char *parms[MAX_PARMS];
command commands[] = {
	{"rd",		Cmd_RD},
	{"rdw",		Cmd_RDW},
	{"wr",		Cmd_WR},
	{"l",		Cmd_L},
	{"p",		Cmd_P},
	{"regs",	Cmd_REGS},
	{"io",		Cmd_IO},
	{"f",		Cmd_F},
	{"sp",		Cmd_SP},
	{"per",		Cmd_PER},
	{"watch",	Cmd_WATCH},
	{"rst",		Cmd_RST},
	{"ipc",		Cmd_IPC},
	{"set",		Cmd_SET},
	{"dig",		Cmd_DIG},
	{"an",		Cmd_AN},
	{"pin",		Cmd_PIN},
	{"pc",		Cmd_PC},
	{"info",	Cmd_INFO},
	{"/",		Cmd_HELP}
};
const int N_COMMANDS = sizeof (commands)/ sizeof (command);

static 	int		n_parms; // number of parameters entered after the command
static	int		last_address = 0;
static	int		cmd_buffer_index = 0;
static	char	cmd_buffer[50];
static	char	last_cmd[50];

////////////////////////////////////////////////////
// example command, reads the first parm (address) and the second parm (value)
// and calls a function to do something with the values
void	Cmd_WR () {
	/////////////////////////////////////////////////////////
	// write a value to target RAM
	int addr = GetParm(0, HEX);
	byte val = GetParm(1, HEX);
	do_something_with (addr, val);
	
}

unsigned int htoi (const char *ptr) {
	unsigned int value = 0;
	char ch = *ptr;
	
    while (ch == ' ' || ch == '\t')
        ch = *(++ptr);

    for (;;) {

        if (ch >= '0' && ch <= '9')
            value = (value << 4) + (ch - '0');
        else if (ch >= 'A' && ch <= 'F')
            value = (value << 4) + (ch - 'A' + 10);
        else if (ch >= 'a' && ch <= 'f')
            value = (value << 4) + (ch - 'a' + 10);
        else
            return value;
        ch = *(++ptr);
    }
}

int		GetParm (byte parm, byte base) {
	switch (base) {
		case HEX:
		return ( htoi(parms[parm]));

		case DEC:
		return ( atoi(parms[parm]));
	}
}

void	SplitCommand() {
	/////////////////////////////////////////////////////
	// split the command line by replacing all ' ' with 
	// '\0' and saving pointers to all the parm strings
	int i, p;

	/////////////////////////////////////////////////////
	// clear the pointer array
	n_parms = 0;
	for (i = 0; i < MAX_PARMS; i++)
		parms[i] = NULL;

	/////////////////////////////////////////////////////
	// scan the command line, dork any spaces with null chars
	// and save the location of the first char after the null
	for (i = 0, p = 0; cmd_buffer[i] != NULLCHAR; i++) {
		if (cmd_buffer[i] == SPACE) {
			cmd_buffer[i] = NULLCHAR;
			parms[p++] = &cmd_buffer[i] + 1;
			n_parms++;
		}
	}
}
void	ProcessCommand () {
	int cmd;
	
	Serial.println("");

	/////////////////////////////////////////////////////
	// trap just a CRLF
	if (cmd_buffer[0] == NULLCHAR) {
		Serial.print("QM> ");
		return;
	}
	
	/////////////////////////////////////////////////////
	// save this command for later use with TAB or UP arrow
	memcpy(last_cmd, cmd_buffer, sizeof(last_cmd));
	
	/////////////////////////////////////////////////////
	// Chop the command line into substrings by
	// replacing ' ' with '\0' 
	// Also adds pointers to the substrings 
	SplitCommand(); 
	
	/////////////////////////////////////////////////////
	// Scan the command table looking for a match
	for (cmd = 0; cmd < N_COMMANDS; cmd++) {
		if (strcmp (commands[cmd].cmd, (char *)cmd_buffer) == 0) {
			commands[cmd].func();  // command found, run its function
			goto done;
		}
	}

	/////////////////////////////////////////////////////
	// if we get here no valid command was found
	Serial << "wtf?" << endl;

	done:
	cmd_buffer_index = 0;
	cmd_buffer[0] = NULLCHAR;
	Serial << "QM> ";
}

void	command_handling_loop() {
	char c;
	
	if (Serial.peek() > 0) {
		c = Serial.read();
		if (ESC == c) {
			while (Serial.available() < 2) {};
			c = Serial.read();
			c = Serial.read();	
			switch (c) {
				case 'A':  // up arrow
					// copy the last command into the command buffer
					// then echo it to the terminal and set the 
					// the buffer's index pointer to the end 
					memcpy(cmd_buffer, last_cmd, sizeof(last_cmd));
					cmd_buffer_index = strlen (cmd_buffer);
					Serial << cmd_buffer;
					break;
			}
		} else {
			c = tolower(c);
			switch (c) {
				
				case TAB:  // TAB runs the last command
					memcpy(cmd_buffer, last_cmd, sizeof(cmd_buffer));
					ProcessCommand ();
					break;

				case BACKSPACE:
					if (cmd_buffer_index > 0) {
						cmd_buffer[--cmd_buffer_index] = NULLCHAR;
						Serial << _BYTE(BACKSPACE) << SPACE << _BYTE(BACKSPACE);
					}
					break;

				case LF:
					ProcessCommand ();
					Serial.flush();		// remove any following CR
					break;
				
				case CR:
					ProcessCommand ();
					Serial.flush();		// remove any following LF
					break;

				default:  // just put the char in the buffer
					cmd_buffer[cmd_buffer_index++] = c;
					cmd_buffer[cmd_buffer_index] = NULLCHAR;
					Serial.print (c);
			}
		}
	}
}