The CMXBug Manual. The CMXBug Manual

Transcription

1 The CMX CMXBug TM debugger provides the ability to view and modify different aspects of the CMX multitasking operating system environment, while application code is running. CMXBug runs as a task, usually the highest priority task. In most cases, one of the target processor UART channel(s) is used as the input/output device. A simple terminal or CPU with a keyboard is all that is needed to use CMXBug. When the CMXBug task is enabled it will send a menu to the screen. One of many prompts may be selected, allowing the user to view and possibly change many aspects of the CMX RTOS environment. When the CMXBug task is running, it prohibits other tasks from running and also freezes the task timers and cyclic timers, to get an accurate picture of the "current state" of the CMX RTOS environment. CMXBug has the capability to "single step" one system TICK, allowing normal activity to occur for one system TICK, with CMXBug resuming after this "single step". Also the number of system TICKS that CMXBug will wait, allowing normal activity before it resumes, can be selected. This is a very powerful and helpful feature. CMXBug allows access to most of the CMX RTOS features, such as: Tasks, Cyclic Timers, Resources, Mailboxes, Queues, Stacks, the system TICK, TIME SLICE scales, etc. For example, you may view a task, which shows its current state (ready, waiting on what, the time remaining, etc.), its current priority, its starting address, the events associated with the task, the task's stack address and maximum usage. Also you may start a task, wake a task that was waiting on some entity and stop a task. CMXBug displays each task s percentage of RUNNING time to the total. This presents an accurate picture of each task in relation to all tasks. It also shows the amount of time that the processor is "IDLE" with no task running. This gives a very powerful insight how the processor time is being spent. A terminal that will send and receive characters using its serial port, or any PC that has a serial port and a communication package such as Procomm, Mirror, etc., should be connected to the target processor s serial port. For a communications package you may also use the CMX CMXBugio.exe program described below. The communication package selected should be fast enough to receive and display characters (without losing them) at a BAUD rate of CMX has a PC based program, CMXBugio.exe, which allows a PC to send and receive characters from either communication serial port 1 or 2. This is an interrupt driven program which allows characters to be received and transmitted without losing received characters. This will happen, in a normal polled environment, at a high BAUD rate. To use CMXBugio.exe the target processor UART must be configured for 9600 Baud, 8 data bits, one stop bit and No parity (9600 N81). Please notify us if you did not receive CMXBugio.exe and you would like one. 1

2 This manual will NOT go into great details about the CMX RTOS and its function calls. It is assumed that the user has read the CMX manual, is familiar with the CMX function calls and their parameters, and has a basic insight on how the CMX RTOS works. The CMX RTOS must be used in the application for CMXBug to work. Also, CMXBug.obj must be included in the link script, and CMXBUG_ENABLE must be defined as 1 in the "cxconfig.h" configuration file. To enter the CMXBug debugger, press the + (plus) key from the console input device. Once this is done the CMXBug debugger task will take control of the CMX RTOS system and present a menu to the user. The menu looks as follows. Select the desired function: Enter 1 TASKS Enter 2 RESOURCES Enter 3 CYCLIC TIMERS Enter 4 QUEUES Enter 5 MAILBOXES Enter 6 RAM display Enter 7 STACK information Enter 8 SYSTEM TICK SCALE Enter 9 TIME SLICE SCALE Enter 10 TIME SLICING select Enter 11 GO and RESUME CMXBug Enter 12 QUICK GO and RESUME CMXBug Enter 13 TIME ANALYSIS Enter 14 TIME ANALYSIS reset Enter 15 ADDITIONAL TASK functions Enter 99 EXIT CMXBug Enter P/p to toggle ECHO mode Your choice? The following pages will describe each of the above choices in detail. First we will explain some of the data entry prompts you will see. Because CMXBug will usually talk (UART I/O) to a terminal or CPU, normal data entry is somewhat limited. Also to keep the code size of the CMXBug task down to a minimum, the data entered is not parsed until the <Return/Enter> key has been pressed. Here are some of the prompts that will be encountered. One of the most frequent prompts is as follows. "Function" dump, enter number, * for all, <return> to exit. Choice? 2

3 "Function" is the selected function from the menu screen. "enter number" is the number of the particular entity to be viewed or changed. A decimal number or a hexadecimal number may be entered. To enter a hexadecimal number the x/x key must be pressed first. The normal hexadecimal nomenclature, 0x, should not be used. Usually a number ranges from 0 (zero) to the MAXIMUM number less 1, configured for that function. An example would be CYCLIC TIMERS. Lets say that the maximum number of CYCLIC TIMERS in the application is 5. In this example valid numbers would be 0 (zero) through 4. This is because the array of CYCLIC TIMER structures begins at 0 (zero) and goes up to 4. If the number entered is either too small or too big, then an error message will be displayed and the "entry prompt" will be shown again. Enter "*" to show ALL of the particular entity selected. If there are more than 18 items, then you will be prompted to press the <return> key to bring up the next page. Press the <return> key at the prompt to go back to the previous menu. The <return> key must be the first key entered to exit the current function. At ANY TIME, the + (plus) key may be pressed to return to the main menu. Another entry prompt that the user will encounter is as follows. "Function", enter SLOT #, "TASK name, <return> to exit. Choice? "Function" is the selected function from the menu screen. "enter SLOT #" is the TASK SLOT NUMBER that the CMX RTOS K_Task_Create function has returned for that particular task. This SLOT NUMBER is not necessarily the order in which the tasks were created. The SLOT NUMBER is the index number into the task array that CMX maintains. A decimal number or a hexadecimal number may be entered. To enter a hexadecimal number the x/x key must be pressed first. The normal hexadecimal nomenclature, 0x, should not be used. Usually a number ranges from 0 (zero) to the MAXIMUM number less 1, configured for that function. "TASK name" is the NAME of the supplied to the CMX K_Task_Name function for this task. To enter a task name the first key pressed MUST be the double quote key ("). This informs CMXBug a character string is being entered. The maximum number of characters used in a task name is 12. Note that task names are case sensitive and only the first 12 characters will be used, even if more than 12 characters are given to the K_Task_Name function. If the character string entered does not match any of the task names, then an error message will be displayed and the "entry prompt" will be shown again. Press the <return> key at the prompt to go back to the previous menu. The <return> key must be the first key entered to exit the current function. At ANY TIME, the + (plus) key may be pressed to return to the main menu. 3

4 The functions that allow viewing and changing the selected variable value have the following prompt. Current "variable" = Enter new "variable value" or <return> to leave as is Where "variable" is the variable selected by the chosen function. CMXBug will show the current value of this variable. "Enter new variable value or <return> to leave as is" allows the user to select a new value for this variable, or to leave it at its present value by entering the <return> key first. The functions that allow viewing and changing the selected variable STATE (enabled/ disabled), have the following prompt. Current "variable" is (enabled/disabled) Enter Y/y or N/n to enable/disable "variable" or <return> to leave as is Where "variable" is the variable selected by the chosen function. CMXBug will show the current state of this variable. The state can only be enabled or disabled. "Enter Y/y or N/n to enable/disable "variable" or <return> to leave as is" allows the user to enable this "variable" by entering the Y/y keys or to disable the variable by entering the N/n keys. The "variable" may be left in its current state by entering the <return> key first. There are a few more "entry prompts", that are basically the same as the above "entry prompts". These prompts are answered similarly. The following will show you the different menu prompt functions and the associated "picture" that is seen when the selected function is chosen. There may be slight differences, depending upon minor enhancements to the CMXBug code. 4

5 TASKS function Slot Name State (time) Trig Pri TSK Addr E-Flags E-Match 1 CMXBug running 1 1 0x131C 0x0000 0x TASK1 ready++ ( TIME) 1 5 0x1665 0x8003 0x TASK2 mesg_send( 5) x19DD 0x0000 0x TASK3 wait x231F 0x0000 0x0000 <SLOT> is the slot number that was assigned to this task when the task was created using the CMX K_Task_Create function. This is actually the index number into the task structure array that is maintained by CMX. <NAME> is the name of the task that was selected using the CMX K_Task_Name function. The task's name may be more than 12 characters long, yet CMXBug will only use and display the first 12 of them. <State(time)> is the state of the task and possibly the remaining time, in SYSTEM TICKS, that the task will wait for the entity to occur. If the task called one of the CMX functions that allows a "time-out" period, and the function was called with a non-zero time-out value, then the remaining time will be shown. However, if the entity that the task was waiting on occurred, then no time value will be shown. If the time-out period expired before the entity the task was waiting on occurred, or either the CMX K_Task_Wake or CMX K_Task_Wake_Force function was used, then "TIME" will be displayed, indicating that the time-out period had elapsed. Make note that whenever the task calls the CMX K_Task_Wait function, mostly likely the "TIME" indicator will be shown. There are several possible states a task can be in, though a task can be in only one state at a time. They are as follows. The state "running" means that this task is the current RUNNING task. The CMXBug task will always be the "running" task when viewing this screen. The state "ready" signifies that the task has been created and triggered (started). This means the task is able to RUN when its priority is the highest priority of all tasks able to RUN. The state "ready++" indicates that this task is able to RESUME. This means that this task was running at one time and was preempted by a higher priority task, the entity that the task was waiting on has occurred or the time-out specified had expired. This task can be the RUNNING task when its priority is the highest priority among all tasks able to run. 5

6 The state "wait" denotes that the task called the CMX K_Task_Wait function, and is waiting for the time period to expire, or for the task to be woken up with either CMX K_Task_Wake or CMX K_Task_Wake_Force functions. The state "resource" means that the task is waiting for a resource which is currently owned by another task. The state "mesg_wait" indicates that the task is waiting for a message from a particular mailbox. The state "mesg_send" signifies that the task has sent a message to a mailbox and is waiting for another task to acknowledge receiving the message from the mailbox. The state "event" denotes that the task is waiting for one or more events to become set. The state "idle" means that the task has been created, but not triggered (started). This task can NEVER run until it is started by the CMX K_Task_Start function. A task may also be in the "idle" state if the task has finished its code (reached its end brace). A task that has ended may be restarted with additional calls to the CMX K_Task_Start function. The state "no create" indicates that the task has NOT been created or the task has been removed (killed), and therefore the task state does not exist. <Trig> is the number of triggers (starts) that the task has received so far. This value ranges from zero, indicating the task is in the IDLE state, up to 255. Each time a task finishes its code and calls the CMX K_Task_End function, identifying it has completed its code, the trigger value will be decremented by 1. If the new trigger value is zero the task will enter the idle state. If the new trigger value is greater than zero the task will be automatically placed into the ready state. <Pri> is the current priority of the task. The lower the number, the higher the priority. <TSK Addr> is the hexadecimal address where the task begins in ROM. <E-Flags> is the hexadecimal value of the task's events flag states. <E-Match> is the hexadecimal value of the task's events match states. 6

7 RESOURCES function RES # Owner Task(s) Waiting MAX. 3 shown 0 NONE NONE 1 TASK1 TASK2 2 TASK3 TASK4 TASK5 3 TASK6 NONE <RES #> is the RESOURCE number. This is actually the index number into the RESOURCE structure array maintained by CMX. <Owner> is the name of the task that currently "owns" this resource, or NONE if no task "owns" this resource. If you do not supply a task name this field will be blank. <Task(s) Waiting> is a list of tasks that are waiting to use this resource. The first three waiting tasks will be shown. CYCLIC TIMERS function TIMER # Started? Time left CYCLIC Time Mode task/pri EVENT 0 NO 0x0000 0x0000 Task number 0x YES 0x000A 0x000F Task number TASK2 0x YES 0x0003 0x0000 All tasks 2 0x0400 <TIMER #> is the CYCLIC TIMER number. This is actually the index number into the CYCLIC TIMER structure array maintained by CMX. <Started?> is the state of the cyclic timer, started or not started. <Time left> is the hexadecimal number of SYSTEM TICKS to go before the timer executes its associated parameters with the CMX K_Event_Signal function. <CYCLIC TIME> is the hexadecimal number that will be loaded into the CYCLIC Time parameter when the time left value reaches zero. A non-zero CYCLIC Time means that the cyclic timer will be a continuous duty timer. A value of zero for the CYCLIC Time indicates a "one shot" timer. <Mode> is the selected cyclic timer event setting mode. There are 7 different modes that a cyclic timer can perform. They are as follows. 7

8 The mode "task number", means that the specific task selected by the <task/pri> variable, will be the task to have its event flag(s) set, according to the <EVENT> parameter. The mode "Top Pri task", means that the highest priority task WITHOUT regard to the <task/pri> variable, will be the task to have its event flag(s) set, according to the <EVENT> parameter. The mode "Top pri task waiting", means that the highest priority task waiting on these event(s) WITHOUT regard to the <task/pri> variable, will be the task to have its event flag(s) set, according to the <EVENT> parameter. The mode "ALL tasks", means that all tasks will have their event flag(s) set, according to the <EVENT> parameter. The mode "All tasks waiting", means that all tasks waiting on these event(s) WITHOUT regard to their priority, will be the task(s) to have its event flag(s) set, according to the <EVENT> parameter. The mode "Same priority", means that all tasks with the same priority as the <task/pri> variable, will be the task(s) to have their event flag(s) set, according to the <EVENT> parameter. The mode "Same Pri waiting", means that all tasks waiting on these event(s) with the same priority as the <task/pri> variable, will be the task(s) to have their event flag(s) set, according to the <EVENT> parameter. <Task/pri.> depends upon the <mode> selected. Mode # Acts On Task slot # or priority 0 (zero) Specific task Task slot # 1 Highest priority task Not used 2 Highest priority task waiting on <EVENT> Not used 3 All tasks Not used 4 All tasks waiting on <EVENT> Not used 5 All tasks with same priority Priority 6 All tasks with same priority waiting on <EVENT> Priority <EVENT> is the event bit(s) to set for one or more tasks, depending upon the <mode> selected. 8

9 QUEUES function QUE # Status Max Slots Slots Used Slotsfree <QUEUE #> is the QUEUE number. This is actually the index number into the QUEUE structure array maintained by CMX. <Status> is the current status of the queue. There are 4 possible status messages. They are as follows. The status "EMPTY", means that the queue has NO slot that is currently being used, ALL slots are free. The status "FULL", means that ALL the queue slots are currently being used, NO slots are free. The status "PARTIAL", means that the queue has one or more slots currently being used. The status "NOT CREATED", means that the queue has not been created with the CMX K_Que_Create function. <Max Slots> is the total number of slots the queue has been created with. <Slots Used> is the number of slots currently being used. Slot size <Slots free> is the number of slots currently free to receive data. QUE.Addr 0 PARTIAL x EMPTY x15DD 2 FULL x18FD 3 NOT CREATED x0000 <Slot size> is the size of EACH slot within the queue. The size given is the number of BYTES (8 BITS). The size is fixed for all slots of a particular queue and is determined when the queue is created. <QUE. Addr> is the hexadecimal address where this queue resides in RAM. 9

10 MAILBOXES function MAILBOX # # of MESG TASK waiting TASK to Sig EVENT 0 0 NONE NONE TASK2 0x TASK1 0 0 <MAILBOX #> is the MAILBOX number. This is actually the index number into the MAILBOX structure array maintained by CMX. <# of MESG> is the number of messages that are currently available in this mailbox. <TASK waiting> is the task that is waiting for a message to arrive at this mailbox. <TASK to Sig> is the task that will have its event bit(s) set according to the <EVENT> parameter when messages are available at this mailbox. <EVENT> is the event bit(s) to set of the selected task according to the <TASK to Sig> parameter. RAM display function Etc A 0B 0C 0D 0E 0F 0000 FA 00 C F FF AA CC 00 AA DD 00 DD D0 F EE AA The RAM display puts the starting address on the left side of screen. It will be rounded down, if necessary, so the starting address low nibble will be zero. ALL bytes are displayed in hexadecimal format. The starting and ending address must be entered in either decimal or hexadecimal notation. The ending address MUST be equal to or greater than the starting address. 10

11 STACK INFO function SLOT NAME STACK Addr MAX. bytes used SO FAR 1 CMXBug 0x TASK1 0x TASK2 0x TASK3 0x <SLOT> is the slot number assigned to this task when the task was created using the CMX K_Task_Create function. This is actually the index number into the task structure array maintained by CMX. <NAME> is the name selected when the CMX K_Task_Name function was used to "NAME" the task. The task's name may be more than 12 characters long, yet CMXBug will only use and display the first 12 of them. <STACK Addr> is the address in RAM where this task s stack begins. The following is not implemented in this version. <MAX. bytes used SO FAR> is the maximum number of bytes used by the task to save return addresses of function calls, pass parameters, hold the task context, etc. WARNING: This may NOT show the true depth of the task s stack, for this is ONLY computed when the task has its context saved during the CMX SYSTEM TICK K_OS_Tick_Update function. This will present a fairly accurate insight to the task s stack usage requirements though. SYSTEM TICK SCALE function Current SYSTEM TICK SCALE = 2 Enter new SYSTEM TICK SCALE or <return> to leave as is This function allows the user to view and possibly modify the current value of the CMX "RTC_SCALE" variable. This variable was defined in the "cxconfig.h" file and is the number of times that the K_OS_Tick_Update function must be called by the interrupt that is generating the CMX timing, before producing what is called the CMX SYSTEM TICK, which all CMX task timers and cyclic timer timers are based on. At each SYSTEM TICK, CMX decides whether there are task timers and/or cyclic timers that need servicing, and if so, will service them. 11

12 TIME SLICE SCALE function Current TIME SLICE SCALE = 4 Enter new TIME SLICE SCALE or <return> to leave as is This allows the user to view and possibly modify the current value of the CMX "TSLICE_SCALE" variable. This variable was defined in the "cxconfig.h" file and is the number of times that the K_OS_Tick_Update function must be called by the interrupt that is generating the CMX timing, before producing what is called the TIME SLICE TICK, which all time slicing is based on. This value is meaningful only if TIME SLICING is enabled. TIME SLICING function Current TIME SLICING = Disabled Enter Y/y or N/n to enable/disable TIME SLICING or <return> to leave as is This allows the user to view and possibly modify the current state of the TIME SLICING variable. This allows the user to either disable or enable TIME SLICING. If disabled, then TIME SLICING is not active and the CMX RTOS will NOT do any TIME SLICING. If enabled, the TIME SLICING is active and the CMX RTOS will do TIME SLICING. GO and RESUME CMXBug function Enter the number of ticks to wait or <return> to leave This function allows CMXBug to release control of the CMX RTOS for the number of SYSTEM TICKS selected. When the number of SYSTEM TICKS specified has expired, CMXBug will automatically resume control of the CMX RTOS and freeze all other tasks. This is a very powerful feature, for it allows the user to "multiple step" the desired number of SYSTEM TICKS and see the CMX RTOS environment change, aiding in debugging and verifying the application. When this is performed CMXBug cannot be "woken" sooner by entering a key stroke. QUICK GO and RESUME CMXBug function This function allows CMXBug to release control of the CMX RTOS for one SYSTEM TICK. When the NEXT SYSTEM TICK has expired, CMXBug will resume control of the CMX RTOS and freeze all other tasks. 12

13 This is a very powerful feature, for it allows the user to "single step" one SYSTEM TICK at a time and see the CMX RTOS environment change, aiding in debugging and verifying the application. This function is the same as the GO and RESUME function above with a selected value of 1. TIME ANALYSIS This function displays the number of SYSTEM TICKS that each task was RUNNING, and the approximate percentage of the CPU processing time devoted to that task in relation to the total for all tasks. Also shown is the IDLE time, when the CPU was not processing a task. SLOT # NAME Number of Ticks % of TICKS 1 CMXBug < 1 % TASK1 20 % TASK2 35 % TASK3 3 % TASK4 < 1 %00.00 IDLE 31 %41.57 <SLOT> is the slot number assigned to this task when the task was created using the CMX K_Task_Create function. This is actually the index number into the task structure array maintained by CMX. <NAME> is the name selected when the CMX K_Task_Name function was used to "NAME" the task. The task's name may be more than 12 characters long, yet CMXBug will only use and display the first 12 of them. <Number of Ticks> is the number of SYSTEM TICKS that have occurred while that particular task was RUNNING (owned the CPU). A task that has RUN for less than a FULL SYSTEM TICK worth of time will show a value of "< 1". Note that the TOTAL number of times that the task was RUNNING, could be more than indicated, for the task's SYSTEM TICK count is only incremented when the task has control of the CPU and a SYSTEM TICK occurs. <% of TICKS> is the percentage of the task s total accumulated SYSTEM TICK count to the TOTAL number of SYSTEM TICKS that have occurred so far. The above function presents a relatively accurate "picture" of how the CPU processing time has been spent. Remember that the smaller the SYSTEM TICK time, the more accurate this picture becomes. It is possible that a task could have used a fair amount of the CPU processing time, yet never long enough for a SYSTEM TICK to have occurred. There is also a possibility that a task had executed for LESS than a SYSTEM 13

14 TICK, yet will show a total count of zero. This is a very unique situation and will not be explained here. When CMXBug is RUNNING TIME ANALYSIS counting is suspended. TIME ANALYSIS reset This function allows the reset of the TIME ANALYSIS array. This will set all tasks total accumulated counts to zero and also zeros out the count of the number of SYSTEM TICKS so far. TIME ANALYSIS will begin from this state when CMXBug releases control of the CMX RTOS, either by exiting CMXBug or by the GO and RESUME CMXBug functions. ADDITIONAL TASK functions *** ADDITIONAL TASK functions *** Enter 1 START TASK Enter 2 STOP TASK Enter 3 WAKE TASK Enter 9 EXIT Your choice? The ADDITIONAL TASK functions menu appears as above. The functions will be explained below. START TASK function TASK START, enter SLOT #, "TASK_name, <return> to exit. Choice? <TASK START> indicates you are going to trigger (start) a task using the CMX K_Task_Start function. <enter SLOT #> allows the entry of the slot number of a particular task to trigger. The task's name may be used instead of the slot number, as described below. If the slot number is out of range, an error message will be displayed. If the slot number is valid, the task will be triggered. <"TASK_name> allows the entry of the task's NAME. To select a "task name" the double quote key (") must be pressed as the first key, to inform CMXBug that a string of characters is being entered. A maximum number of 12 characters is allowed and names are case sensitive. When the return key is pressed CMXBug will search for that task name. If the "TASK_name" is not found, an error message will be displayed. If the "TASK_name" is found, and the task has been created and not removed, then the task will be triggered. <return to exit> will exit this function and move up to the previous menu (ADDITIONAL TASK functions menu). 14

15 STOP TASK function TASK STOP, enter SLOT #, "TASK_name, <return> to exit. Choice? <TASK STOP> indicates you are going to stop the task by using the CMX K_Task_Wait function with a time-out period of zero. The task will be SUSPENDED indefinitely, until woken by either the CMX K_Task_Wake or CMX K_Task_Wake_Force functions. If the task is already waiting on some entity, then the task will NOT be stopped. <enter SLOT #> allows the entry of the slot number of a particular task to stop. The task's name may be used instead of the slot number, as described below. If the slot number is out of range, an error message will be displayed. If the slot number is valid, the task will be stopped (SUSPENDED). <"TASK_name> allows the entry of the task's NAME. To select a "task name" the double quote key (") must be pressed as the first key, to inform CMXBug that a string of characters is being entered. A maximum number of 12 characters is allowed and names are case sensitive. When the return key is pressed CMXBug will search for that task name. If the "TASK_name" is not found, an error message will be displayed. If the "TASK_name" is found, the task has been created and not removed, and is not already waiting on an entity, then the task will be stopped (SUSPENDED). <return to exit> will exit this function and move up to the previous menu (ADDITIONAL TASK functions menu). WAKE TASK function TASK WAKE, enter SLOT #, "TASK_name, <return> to exit. Choice? <TASK WAKE> indicates you are going to use the CMX K_Task_Wake_Force function to forcefully wake a task that is currently waiting (SUSPENDED) for an entity to happen. If the task is not waiting, then this function will not be performed and an error message will be displayed. Also, if this function IS successful, and the task was waiting for a message, and the MAILBOXES are viewed again, it will still show the task is waiting. This will change as soon as CMXBug has released control to the CMX RTOS. <enter SLOT #> allows the entry of the slot number of a particular task to wake. The task's name may be used instead of the slot number, as described below. If the slot number is out of range, an error message will be displayed. If the slot number is valid and the task is waiting, the task will be woken (Ready++). <"TASK_name> allows the entry of the task's NAME. To select a "task name" the double quote key (") must be pressed as the first key, to inform CMXBug that a string of characters is being entered. A maximum number of 12 characters is allowed and names are case sensitive. When the return key is pressed CMXBug will search for that 15

16 task name. If the "TASK_name" is not found, an error message will be displayed. If the "TASK_name" is found, the task has been created and not removed, and is not waiting on an entity, the task will be woken (Ready++ state). <return to exit> will exit this function and move up to the previous menu (ADDITIONAL TASK functions menu). EXIT CMXBug function This function will allow the CMXBug task to PERMANENTLY release control of the CPU back to the CMX RTOS and the running application. The only way to reenter the CMXBug task is by pressing the "+" (plus) key. Enter P/p to toggle ECHO mode This function allows CMXBug task to enable or disable the ECHO mode. The default is to ECHO (send back) all valid characters received to the terminal or PC. If disabled, no received characters will ECHO back. If a valid key is pressed and two characters are displayed, then the CMXBug ECHO mode can be disabled or the terminal or PC prevented from echoing characters. Setting up CMXBug You may need to modify CMXBug to meet your specific needs. The "CMX_INIT.C" file contains 3 functions that may need to be modified and one "define" that might need to be changed. CMXBug uses a POLLED method of testing the selected serial port of the processor to see if a character is present. The CMXBug task defaults to waiting 10 SYSTEM TICKS, before waking up to see if the + (plus) key has been pressed. If not pressed, the CMXBug task goes to sleep for another 10 SYSTEM TICKS. This is repeated until the + (plus) key is detected. The "wait" time may be increased or decreased if desired. This is a variable within the K_OS_Init function called BUG_WAIT_TICKS. BUG_WAIT_TICKS = 10; The setup_bug function may have to be modified to select the desired serial port. This function sets up the serial port by configuring the BAUD rate, data bits, parity, etc. It also enables any register flags that must be cleared and/or set to get the serial port alive. If using CMXBugio.exe the target processor UART must be configured for 9600 Baud, 8 data bits, one stop bit and No parity (9600 N81). This serial port MUST be configured for a POLLING type of operation and NOT interrupt driven. The K_Bug_Getchr function uses the serial port configured by the setup_bug function to receive characters for the CMXBUG TASK. It may or may not clear/set any necessary receiver flags, depending upon the processor. You are free to change the 16

17 desired serial port, but you must ensure that the processor has this serial port and that any receiver flags that must be cleared or set, are done, according to the processor you are using. The K_Bug_Putchr function uses the serial port configured by the setup_bug function to transmit characters for the CMXBUG TASK. It may or may not clear/set any necessary transmitter flags, depending upon the processor. You are free to change the desired serial port, but you must ensure that the processor has this serial port and that any transmitter flags that must be cleared or set, are done, according to the processor you are using. Try not to use the SAME serial port that is used by a MONITOR program, YOUR program, etc. If so, you will most likely run into a conflict problem. You are free to change the CMXBug "C" code if you like, but CMX will not be responsible for your results if you do. Please do not call us about modifying the CMXBug code specifically to meet your particular needs. All suggestions are of course welcome. CMX will try to add your desired additions and our own enhancements over time, however we do NOT want this code to be either processor or compiler specific. 17