Add task names and 'T' command to show task status.

The T command shows the current wchan and PC for each task in the system.

diff --git a/ao.h b/ao.h
index 853738b29171358967c0a80b931bcefa6d529b66..20c2458cd87fc72766117784c25967120d3f409f 100644 (file)
--- a/ao.h
+++ b/ao.h
@@ -29,7 +29,7 @@
 /* Stack runs from above the allocated __data space to 0xfe, which avoids
  * writing to 0xff as that triggers the stack overflow indicator
  */
-#define AO_STACK_START 0x6f
+#define AO_STACK_START 0x62
 #define AO_STACK_END   0xfe
 #define AO_STACK_SIZE  (AO_STACK_END - AO_STACK_START + 1)
 
@@ -38,6 +38,7 @@ struct ao_task {
        __xdata void *wchan;            /* current wait channel (NULL if running) */
        uint8_t stack_count;            /* amount of saved stack */
        uint8_t task_id;                /* index in the task array */
+       __code char *name;              /* task name */
        uint8_t stack[AO_STACK_SIZE];   /* saved stack */
 };
 
@@ -64,7 +65,11 @@ ao_yield(void) _naked;
 
 /* Add a task to the run queue */
 void
-ao_add_task(__xdata struct ao_task * task, void (*start)(void));
+ao_add_task(__xdata struct ao_task * task, void (*start)(void), __code char *name);
+
+/* Dump task info to console */
+void
+ao_task_info(void);
 
 /* Start the scheduler. This will not return */
 void

diff --git a/ao_cmd.c b/ao_cmd.c
index 49efb05e7cae26e192de529d54c34eb65e5958dc..575ed69aec8c3b301b4d36e4bfd2bf104b3ab7c3 100644 (file)
--- a/ao_cmd.c
+++ b/ao_cmd.c
@@ -494,6 +494,7 @@ static const uint8_t help_txt[] =
        "l                                  Dump last flight log\n"
        "E <0 off, 1 on>                    Set command echo mode\n"
        "S<data>                            Send data to serial line\n"
+       "T                                  Show task states\n"
         "\n"
         "Target debug commands:\n"
        "D                                  Enable debug mode\n"
@@ -554,6 +555,9 @@ ao_cmd(void *parameters)
                case 'l':
                        dump_log();
                        break;
+               case 'T':
+                       ao_task_info();
+                       break;
                case 'S':
                        send_serial();
                        break;
@@ -595,5 +599,5 @@ __xdata struct ao_task ao_cmd_task;
 void
 ao_cmd_init(void)
 {
-       ao_add_task(&ao_cmd_task, ao_cmd);
+       ao_add_task(&ao_cmd_task, ao_cmd, "cmd");
 }

diff --git a/ao_flight.c b/ao_flight.c
index bf20f3570e4691f57d08a786fa5262c0c35ffe39..dac110aab9f0c9953b9db25561a8821a9d0f5b46 100644 (file)
--- a/ao_flight.c
+++ b/ao_flight.c
@@ -20,29 +20,29 @@
 /* Main flight thread. */
 
 __xdata struct ao_adc          ao_flight_data;         /* last acquired data */
-__data enum flight_state       ao_flight_state;        /* current flight state */
-__data uint16_t                        ao_flight_tick;         /* time of last data */
-__data int16_t                 ao_flight_accel;        /* filtered acceleration */
-__data int16_t                 ao_flight_pres;         /* filtered pressure */
-__data int16_t                 ao_ground_pres;         /* startup pressure */
-__data int16_t                 ao_ground_accel;        /* startup acceleration */
-__data int16_t                 ao_min_pres;            /* minimum recorded pressure */
-__data uint16_t                        ao_launch_time;         /* time of launch detect */
-__data int16_t                 ao_main_pres;           /* pressure to eject main */
+__pdata enum flight_state      ao_flight_state;        /* current flight state */
+__pdata uint16_t               ao_flight_tick;         /* time of last data */
+__pdata int16_t                        ao_flight_accel;        /* filtered acceleration */
+__pdata int16_t                        ao_flight_pres;         /* filtered pressure */
+__pdata int16_t                        ao_ground_pres;         /* startup pressure */
+__pdata int16_t                        ao_ground_accel;        /* startup acceleration */
+__pdata int16_t                        ao_min_pres;            /* minimum recorded pressure */
+__pdata uint16_t               ao_launch_time;         /* time of launch detect */
+__pdata int16_t                        ao_main_pres;           /* pressure to eject main */
 
 /*
  * track min/max data over a long interval to detect
  * resting
  */
-__data uint16_t                        ao_interval_end;
-__data int16_t                 ao_interval_cur_min_accel;
-__data int16_t                 ao_interval_cur_max_accel;
-__data int16_t                 ao_interval_cur_min_pres;
-__data int16_t                 ao_interval_cur_max_pres;
-__data int16_t                 ao_interval_min_accel;
-__data int16_t                 ao_interval_max_accel;
-__data int16_t                 ao_interval_min_pres;
-__data int16_t                 ao_interval_max_pres;
+__pdata uint16_t               ao_interval_end;
+__pdata int16_t                        ao_interval_cur_min_accel;
+__pdata int16_t                        ao_interval_cur_max_accel;
+__pdata int16_t                        ao_interval_cur_min_pres;
+__pdata int16_t                        ao_interval_cur_max_pres;
+__pdata int16_t                        ao_interval_min_accel;
+__pdata int16_t                        ao_interval_max_accel;
+__pdata int16_t                        ao_interval_min_pres;
+__pdata int16_t                        ao_interval_max_pres;
 
 #define AO_INTERVAL_TICKS      AO_SEC_TO_TICKS(5)
 
@@ -101,7 +101,7 @@ __data int16_t                      ao_interval_max_pres;
 void
 ao_flight(void)
 {
-       __data static uint8_t   nsamples = 0;
+       __pdata static uint8_t  nsamples = 0;
        
        for (;;) {
                ao_sleep(&ao_adc_ring);
@@ -212,6 +212,6 @@ ao_flight_init(void)
        ao_interval_max_pres = 0x7fff;
        ao_interval_end = AO_INTERVAL_TICKS;
 
-       ao_add_task(&flight_task, ao_flight);
+       ao_add_task(&flight_task, ao_flight, "flight");
 }
 

diff --git a/ao_log.c b/ao_log.c
index fedd9850e7b0f852e5f7aed87a4c7909c2d84f0a..3bb2f84562f4de8a74c669ee8c676b392b5815a3 100644 (file)
--- a/ao_log.c
+++ b/ao_log.c
@@ -17,10 +17,10 @@
 
 #include "ao.h"
 
-__data uint32_t                ao_log_current_pos;
-__data uint32_t                ao_log_start_pos;
-__xdata uint8_t                ao_log_running;
-__xdata uint8_t                ao_log_mutex;
+static __pdata uint32_t        ao_log_current_pos;
+static __pdata uint32_t        ao_log_start_pos;
+static __xdata uint8_t ao_log_running;
+static __xdata uint8_t ao_log_mutex;
 
 static uint8_t
 ao_log_csum(uint8_t *b)
@@ -191,5 +191,5 @@ ao_log_init(void)
        ao_log_state = ao_flight_invalid;
 
        /* Create a task to log events to eeprom */
-       ao_add_task(&ao_log_task, ao_log);
+       ao_add_task(&ao_log_task, ao_log, "log");
 }

diff --git a/ao_task.c b/ao_task.c
index 4fb8405595c5b4a1ffc0fc68e1844f243bb07be2..043b3df2d8c9032c044561447b475b33c494ea38 100644 (file)
--- a/ao_task.c
+++ b/ao_task.c
@@ -25,13 +25,14 @@ __data uint8_t ao_cur_task_index;
 __xdata struct ao_task *__data ao_cur_task;
 
 void
-ao_add_task(__xdata struct ao_task * task, void (*start)(void))
+ao_add_task(__xdata struct ao_task * task, void (*start)(void), __code char *name)
 {
        uint8_t __xdata *stack;
        if (ao_num_tasks == AO_NUM_TASKS)
                ao_panic(AO_PANIC_NO_TASK);
        ao_tasks[ao_num_tasks++] = task;
        task->task_id = ao_num_tasks;
+       task->name = name;
        /*
         * Construct a stack frame so that it will 'return'
         * to the start of the task
@@ -94,9 +95,9 @@ ao_yield(void) _naked
        
        if (ao_cur_task_index != AO_NO_TASK_INDEX)
        {
-       uint8_t stack_len;
-       __data uint8_t *  stack_ptr;
-       __xdata uint8_t * save_ptr;
+               uint8_t stack_len;
+               __data uint8_t *stack_ptr;
+               __xdata uint8_t *save_ptr;
                /* Save the current stack */
                stack_len = SP - (AO_STACK_START - 1);
                ao_cur_task->stack_count = stack_len;
@@ -124,8 +125,8 @@ ao_yield(void) _naked
 
        {
                uint8_t stack_len;
-               __data uint8_t *  stack_ptr;
-               __xdata uint8_t * save_ptr;
+               __data uint8_t *stack_ptr;
+               __xdata uint8_t *save_ptr;
 
                /* Restore the old stack */
                stack_len = ao_cur_task->stack_count;
@@ -188,9 +189,23 @@ ao_wakeup(__xdata void *wchan)
 }
 
 void
-ao_start_scheduler(void)
+ao_task_info(void)
 {
+       uint8_t i;
+       uint8_t pc_loc;
 
+       for (i = 0; i < ao_num_tasks; i++) {
+               pc_loc = ao_tasks[i]->stack_count - 17;
+               printf("%-8s: wchan %04x pc %04x\n",
+                      ao_tasks[i]->name,
+                      (int16_t) ao_tasks[i]->wchan,
+                      (ao_tasks[i]->stack[pc_loc]) | (ao_tasks[i]->stack[pc_loc+1] << 8));
+       }
+}
+
+void
+ao_start_scheduler(void)
+{
        ao_cur_task_index = AO_NO_TASK_INDEX;
        ao_cur_task = NULL;
        ao_yield();

diff --git a/ao_usb.c b/ao_usb.c
index a7462ed55009eb6545fcdbfc3ebebfba528c37bf..83fd798f46ac8c612ad814bf366e0881bcfb800f 100644 (file)
--- a/ao_usb.c
+++ b/ao_usb.c
@@ -537,5 +537,5 @@ ao_usb_init(void)
        USBOIF = 0;
        USBIIF = 0;
        
-       ao_add_task(&ao_usb_task, ao_usb_ep0);
+       ao_add_task(&ao_usb_task, ao_usb_ep0, "usb");
 }