📄 cmxbug.c
字号:
#define CMXMODULE 1
#include <string.h>
#include <cxfuncs.h> /* get cmx include header file */
#include <cxextern.h> /* get cmx include header file */
#if _MODEL == 't' || _MODEL == 'T'
#define MAX_MEM_DECIMAL 0x05 /* max decimal size */
#define MAX_MEM_HEX 0x04 /* max hex size */
static byte *from_ptr;
static byte *thru_ptr;
#define mem_size_ptr byte *
#else
#define MAX_MEM_DECIMAL 0x08 /* max decimal size */
#define MAX_MEM_HEX 0x06 /* max hex size */
static byte huge *from_ptr;
static byte huge *thru_ptr;
#define mem_size_ptr byte huge *
#endif
#define MAX_FIELD_LENGTH 12 /* the maximum field length of any field */
#define SCROLL_SIZE 18
#define WHAT_FUNCTION 0
#define DUMP_TASK 1
#define DUMP_RESOURCES 2
#define DUMP_TIMERS 3
#define DUMP_QUEUES 4
#define DUMP_MAILBOXES 5
#define DUMP_RAM 6
#define DUMP_STACKS 7
#define CHANGE_RTC_SCALE 8
#define CHANGE_TSLICE_SCALE 9
#define ENABLE_TIME_SLICING 10
#define DELAY_TICK 11
#define QUICK_TICK 12
#define STATS 13
#define STATS_RESET 14
#define TASK_CTRL 15
#define EXIT_BUG 99
#define WHAT_FUNCTION_PROMPT 00 /* 1 */
#define DUMP_TASK_PROMPT WHAT_FUNCTION_PROMPT + 1 /* 1 */
#define DUMP_RESOURCE_PROMPT DUMP_TASK_PROMPT + 1 /* 1 */
#define DUMP_CYCLIC_PROMPT DUMP_RESOURCE_PROMPT + 1 /* 1 */
#define DUMP_QUEUES_PROMPT DUMP_CYCLIC_PROMPT + 1 /* 1 */
#define DUMP_MAILBOX_PROMPT DUMP_QUEUES_PROMPT + 1 /* 1 */
#define DUMP_RAM_PROMPT DUMP_MAILBOX_PROMPT + 1 /* 2 */
#define DUMP_STACK_PROMPT DUMP_RAM_PROMPT + 2 /* 1 */
#define RTC_SCALE_PROMPT DUMP_STACK_PROMPT + 1 /* 2 */
#define TSLICE_SCALE_PROMPT RTC_SCALE_PROMPT + 2 /* 2 */
#define ENABLE_SLICE_PROMPT TSLICE_SCALE_PROMPT + 2 /* 2 */
#define DELAY_TICK_PROMPT ENABLE_SLICE_PROMPT + 2 /* 1 */
#define STATS_RESET_PROMPT DELAY_TICK_PROMPT + 1 /* 1 */
#define TASK_CTRL_PROMPT STATS_RESET_PROMPT + 1 /* 6 */
struct prompt {
char *word;
byte in_length;
/* we could possibly do the following
struct prompt *next_prompt; point to next message
struct prompt *pevious_prompt; point to next message
*/
};
/* prompt char., length of field */
const struct prompt prpt_array [] = {
/* what function prompt */
{ " Enter Function? \n",0x02},
/* task dump entry */
{ "\r\nTASK dump",0x03},
{ "\r\nRESOURCE dump",0x03},
{ "\r\nCYCLIC TIMERS dump",0x03},
{ "\r\nQUEUE dump",0x03},
{ "\r\nMAILBOX dump",0x03},
{ "\r\nRAM dump\r\nEnter beginning ADDRESS of memory or <return> to exit? ",MAX_MEM_DECIMAL},
{ "\r\n\r\nEnter ending ADDRESS of memory? ",MAX_MEM_DECIMAL},
{ "\r\nSTACK dump",0x03},
{ "\r\nCurrent SYSTEM TICK SCALE = ",0x00},
{ "\r\nEnter new SYSTEM TICK SCALE or <return> to leave as is ",0x03},
{ "\r\nCurrent TIME SLICE SCALE = ",0x00},
{ "\r\nEnter new TIME SLICE SCALE or <return> to leave as is ",0x03},
{ "\r\nCurrent TIME SLICING = ",0x00},
{ "\r\nEnter Y/y or N/n to enable/disable TIME SLICING or <return> to leave as is ",0x01},
{ "\r\nEnter the number of ticks to wait or <return> to leave? ",0x05},
{ "\r\nEnter Y/y to reset TIME ANALYSIS array or <return> to leave as is ",0x03},
{ "\r\n*** ADDITIONAL TASK functions ***",0x01},
{ "\r\nEnter 1 to START TASK",0x01},
{ "\r\nEnter 2 to STOP TASK",0x01},
{ "\r\nEnter 3 to WAKE TASK",0x01},
{ "\r\nEnter 9 to EXIT",0x01},
{ "\r\nYour choice? ",0x01},
{ "\r\nTASK START",0x03},
{ "\r\nTASK STOP",0x03},
{ "\r\nTASK WAKE",0x03}
};
/* keyboard flags */
struct keyflag { /* bit structure */
bit_word16 buff_wait:1;
bit_word16 f_key:1;
bit_word16 e_key:1;
bit_word16 max_in_needed:1;
bit_word16 non_zero:1;
bit_word16 cont:1;
bit_word16 e_jmp:1;
bit_word16 input_func:1;
bit_word16 allow_hex:1;
bit_word16 echo_off:1;
bit_word16 loop:1;
bit_word16 scroll:1;
bit_word16 string:1;
bit_word16 string_allowed:1;
};
static struct keyflag keyflags;
static byte key_pressed; /* byte for scan code of keypad 0x00 thru 0x0f */
static byte num_chars_in;
static byte *in_char_ptr;
static byte max_chars_in;
static byte current_func;
static byte keys_in_buff[MAX_FIELD_LENGTH];
static byte prompt_index;
static byte hex_byte;
static long hex_long;
static byte func_offset;
static byte input_index;
static const struct prompt *prpt_ptr;
static long total_ticks;
static void prompt_out(void);
static void dump_task(void);
static void dump_resource(void);
static void dump_cyclic(void);
static void dump_queue(void);
static void dump_mailbox(void);
static void dump_memory_ram(void);
static void dump_stack(void);
static void change_rtc_scale(void);
static void change_tslice_scale(void);
static void enable_tslice(void);
static void delay_tick(void);
static void quick_tick(void);
static void stat_display(void);
static void stat_reset(void);
static void task_ctrl_func(void);
static void display_char(char);
static void zerofill(byte *);
static void clear_chars_in(void);
static void conv_hex(void);
static void putbyte(byte); /* output a number (decimal) */
static void putpercent(byte,byte); /* output a number (decimal) */
static void putword(word16); /* output a number (decimal) */
static void putlong(long);
static void common_prompt(void);
static void com1_prompt(void);
static void putstg(char *);
static void putname(char *s);
static void putspaces(byte);
static void putcrlf(void);
static void puthexbyte(byte);
static void puthexword(word16);
static void puthexlong(long);
static void showstate(word16);
static const char nibs[] = "0123456789ABCDEF";
static RESHDR res_dummy[1];
/* non-statics */
byte cmxbug_slot;
extern long stat_array[];
extern byte CMXBUG_ACTIVE;
extern byte BUG_WAIT_TICKS;
extern char *task_name[];
extern byte K_Bug_Getchr(byte *ptr);
extern void K_Bug_Putchr(char);
void cmxbug(void);
void cmxbug(void)
{
byte status;
/* process */
CMXBUG_ACTIVE = 0;
while(1)
{
if (!keyflags.cont) {
while(1)
{
status = K_Bug_Getchr(&key_pressed);
if (status)
break;
if (!CMXBUG_ACTIVE)
K_Task_Wait(BUG_WAIT_TICKS);
}
if (!keyflags.string)
{
switch (key_pressed) {
case '+':
locked_out = 1;
CMXBUG_ACTIVE = 1;
keyflags.f_key = TRUE;
break;
case '"':
if (!keyflags.non_zero && keyflags.string_allowed)
{
display_char(key_pressed);
max_chars_in = 12;
keyflags.string = TRUE;
}
break;
case 'p':
case 'P':
if (keyflags.echo_off)
keyflags.echo_off = FALSE;
else
keyflags.echo_off = TRUE;
break;
case '\r':
if (keyflags.scroll)
{
func_offset |= 0x80;
keyflags.e_key = TRUE;
keyflags.e_jmp = TRUE;
break;
}
if ((current_func == TASK_CTRL) && !keyflags.non_zero)
{
func_offset = 0x00;
keyflags.e_key = TRUE;
keyflags.e_jmp = TRUE;
break;
}
if (!keyflags.non_zero)
{
keyflags.f_key = TRUE;
break;
}
if (!keyflags.max_in_needed)
{
if (num_chars_in > 0 || keyflags.input_func)
{
keyflags.e_key = TRUE;
}
}
else
{
if (num_chars_in == max_chars_in)
{
keyflags.e_key = TRUE;
keyflags.max_in_needed = FALSE;
}
}
break;
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
if (num_chars_in < max_chars_in && !keyflags.input_func)
{
keyflags.non_zero = TRUE;
display_char(key_pressed);
*in_char_ptr++ = key_pressed & 0x0f;
num_chars_in++;
}
break;
case '*':
if (num_chars_in < max_chars_in &&!keyflags.input_func)
{
keyflags.non_zero = TRUE;
display_char(key_pressed);
hex_byte = key_pressed;
keyflags.e_jmp = TRUE;
func_offset |= 0x80; /* set done entry flag */
num_chars_in++;
}
break;
case 'a':
case 'A':
case 'b':
case 'B':
case 'c':
case 'C':
case 'd':
case 'D':
case 'e':
case 'E':
case 'f':
case 'F':
if (!keyflags.allow_hex)
break;
if (num_chars_in < max_chars_in &&!keyflags.input_func)
{
keyflags.non_zero = TRUE;
display_char(key_pressed);
*in_char_ptr++ = ((key_pressed & 0x0f) + 0x09);
num_chars_in++;
}
break;
case 'X':
case 'x':
if (!keyflags.non_zero)
{
display_char('x');
keyflags.allow_hex = TRUE;
if (max_chars_in == MAX_MEM_DECIMAL)
max_chars_in = MAX_MEM_HEX;
}
break;
case 'Y':
case 'y':
hex_byte = 1;
keyflags.e_jmp = TRUE;
keyflags.e_key = TRUE;
K_Bug_Putchr('Y');
func_offset |= 0x80; /* set done entry flag */
break;
case 'N':
case 'n':
hex_byte = 0;
keyflags.e_jmp = TRUE;
keyflags.e_key = TRUE;
K_Bug_Putchr('N');
func_offset |= 0x80; /* set done entry flag */
break;
default:
break;
} /* end of switch */
}
else
{
if (key_pressed != '\r')
{
if (num_chars_in < max_chars_in)
{
keyflags.non_zero = TRUE;
display_char(key_pressed);
*in_char_ptr++ = key_pressed;
num_chars_in++;
}
}
else
{
func_offset |= 0x80;
keyflags.e_key = TRUE;
keyflags.e_jmp = TRUE;
}
}
} /* END OF KEYBOARD.CONT IF */
if (keyflags.cont)
{
keyflags.cont = FALSE;
keyflags.e_key = TRUE;
keyflags.e_jmp = TRUE;
func_offset = 0;
}
if (keyflags.f_key)
{
keyflags.f_key = FALSE;
keyflags.e_key = FALSE;
keyflags.e_jmp = FALSE;
keyflags.string = FALSE;
keyflags.string_allowed = FALSE;
keyflags.allow_hex = FALSE;
keyflags.scroll = FALSE;
keyflags.cont = FALSE;
keyflags.loop = FALSE;
keyflags.input_func = FALSE;
func_offset = 0;
current_func = WHAT_FUNCTION;
prompt_index = WHAT_FUNCTION_PROMPT;
keyflags.max_in_needed = FALSE; /* must have 2 characters in */
/* clear all normal flags, etc. */
clear_chars_in();
max_chars_in = 2;
putstg("\r\nEnter 1 TASKS\r\n");
putstg("Enter 2 RESOURCES\r\n");
putstg("Enter 3 CYCLIC_TIMERS\r\n");
putstg("Enter 4 QUEUES\r\n");
putstg("Enter 5 MAILBOXES\r\n");
putstg("Enter 6 RAM display\r\n");
putstg("Enter 7 STACK information\r\n");
putstg("Enter 8 SYSTEM TICK SCALE\r\n");
putstg("Enter 9 TIME SLICE SCALE\r\n");
putstg("Enter 10 TIME SLICING select\r\n");
putstg("Enter 11 GO and RESUME CMXBug\r\n");
putstg("Enter 12 Quick GO and RESUME CMXBug\r\n");
putstg("Enter 13 TIME ANALYSIS\r\n");
putstg("Enter 14 TIME ANALYSIS reset\r\n");
putstg("Enter 15 ADDITIONAL TASK functions\r\n");
putstg("Enter 99 EXIT CMXBug\r\n");
putstg("Enter P/p to toggle ECHO mode, currently ");
if (!keyflags.echo_off)
{
putstg("ON");
}
else
{
putstg("OFF");
}
putstg("\r\nYour choice? ");
}
if (keyflags.e_key && CMXBUG_ACTIVE)
{
keyflags.e_key = FALSE;
if (!keyflags.e_jmp)
{
zerofill(&keys_in_buff[max_chars_in]); /* go zero fill, for proper entry */
conv_hex(); /* go put characters into hex form, just 2 lsd */
func_offset |= 0x80; /* set done entry flag */
}
else
keyflags.e_jmp = FALSE;
if (current_func == WHAT_FUNCTION)
{
func_offset = 0;
current_func = hex_byte;
switch(current_func) {
case WHAT_FUNCTION:
break;
case DUMP_TASK:
break;
case DUMP_RESOURCES:
break;
case DUMP_TIMERS:
break;
case DUMP_QUEUES:
break;
case DUMP_MAILBOXES:
break;
case DUMP_RAM:
break;
case DUMP_STACKS:
break;
case CHANGE_RTC_SCALE:
break;
case CHANGE_TSLICE_SCALE:
break;
case ENABLE_TIME_SLICING:
break;
case QUICK_TICK:
break;
case DELAY_TICK:
break;
case STATS:
break;
case STATS_RESET:
break;
case TASK_CTRL:
break;
case EXIT_BUG:
break;
default:
current_func = WHAT_FUNCTION;
keyflags.f_key = TRUE;
putstg("\r\n\r\nInvalid entry, press any key to continue\r\n");
break;
}
}
switch(current_func) {
case DUMP_TASK:
dump_task();
break;
case DUMP_RESOURCES:
dump_resource();
break;
case DUMP_TIMERS:
dump_cyclic();
break;
case DUMP_QUEUES:
dump_queue();
break;
case DUMP_MAILBOXES:
dump_mailbox();
break;
case DUMP_RAM:
dump_memory_ram();
break;
case DUMP_STACKS:
dump_stack();
break;
case CHANGE_RTC_SCALE:
change_rtc_scale();
break;
case CHANGE_TSLICE_SCALE:
change_tslice_scale();
break;
case ENABLE_TIME_SLICING:
enable_tslice();
break;
case QUICK_TICK:
quick_tick();
break;
case DELAY_TICK:
delay_tick();
break;
case STATS:
stat_display();
break;
case STATS_RESET:
stat_reset();
break;
case TASK_CTRL:
task_ctrl_func();
break;
case EXIT_BUG:
locked_out = 0;
CMXBUG_ACTIVE = 0;
putstg("\r\n\r\n You have exited CMXBug(TM), press <+> (plus key) to enter CMXBug again!\r\n");
break;
default:
break;
} /* end of switch */
} /* end of e key brace */
} /* end of endless while loop */
}
static void common_prompt(void)
{
putstg(", enter number, '*' for all, <return> to exit. Choice? ");
}
static void com1_prompt(void)
{
putstg(", enter SLOT #, \"TASK name, <return> to exit. Choice? ");
}
static void prompt_out(void)
{
prpt_ptr = &prpt_array[prompt_index + func_offset];
/* chars_in(); */
keyflags.non_zero = FALSE;
max_chars_in = prpt_ptr->in_length;
clear_chars_in();
putstg(prpt_ptr->word);
}
/* bit 7 of count will dictate whether we should increment/decrement
the source pointer */
static void zerofill(byte *mov_char_ptr)
{
byte count;
byte *copy_in_char_ptr;
if (num_chars_in != max_chars_in)
{
copy_in_char_ptr = in_char_ptr;
for (count = 0; count < num_chars_in; count++)
{
*(--mov_char_ptr) = *(--in_char_ptr);
}
for (count = num_chars_in; count < max_chars_in; count++)
{
*(--mov_char_ptr) = 0x00;
}
in_char_ptr = copy_in_char_ptr;
}
}
static void conv_hex(void)
{
byte *hex_char_ptr;
long multiplier;
multiplier = 1;
hex_long = 0;
if (max_chars_in == 1)
{
hex_char_ptr = keys_in_buff;
hex_byte = *hex_char_ptr;
hex_long = (long)hex_byte;
}
else
{
hex_char_ptr = &keys_in_buff[max_chars_in-2];
if (keyflags.allow_hex)
{
hex_byte = *hex_char_ptr * 16;
hex_char_ptr++;
hex_byte += *hex_char_ptr;
}
else
{
hex_byte = *hex_char_ptr * 10;
hex_char_ptr++;
hex_byte += *hex_char_ptr;
}
for (hex_char_ptr = &keys_in_buff[max_chars_in - 1];
hex_char_ptr >= keys_in_buff; --hex_char_ptr)
{
hex_long += *hex_char_ptr * multiplier;
if (keyflags.allow_hex)
multiplier *= 16;
else
multiplier *= 10;
}
}
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -