added patch for chibios to implement shutdown and reboot

added shutdown and reboot to the CDC shell git-svn-id: https://svn.spreadspace.org/mur.sat@847 7de4ea59-55d0-425e-a1af-a3118ea81d4c
author: Christian Pointner <equinox@mur.at> 2013-10-01 11:54:58 +0000
committer: Christian Pointner <equinox@mur.at> 2013-10-01 11:54:58 +0000
commit: 6a4d1de2083f6412da45b485a51f769726b32202 (patch)
tree: e1ba49306cd9b7a573e4a37cad283575b7ffadaf
parent: implemented system shutdown and reboot (not yet finished) (diff)
3 files changed, 1849 insertions, 16 deletions
diff --git a/contrib/patches/chibios-2.6.1-shell.patch b/contrib/patches/chibios-2.6.1-shell.patch
new file mode 100644
index 0000000..595ee59
--- /dev/null
+++ b/contrib/patches/chibios-2.6.1-shell.patch
@@ -0,0 +1,1822 @@
+Index: testhal/STM32F30x/USB_CDC/main.c
+===================================================================
+--- testhal/STM32F30x/USB_CDC/main.c	(Revision 6305)
++++ testhal/STM32F30x/USB_CDC/main.c	(Arbeitskopie)
+@@ -342,28 +342,30 @@
+ #define SHELL_WA_SIZE   THD_WA_SIZE(2048)
+ #define TEST_WA_SIZE    THD_WA_SIZE(256)
+ 
+-static void cmd_mem(BaseSequentialStream *chp, int argc, char *argv[]) {
++static int8_t cmd_mem(BaseSequentialStream *chp, int argc, char *argv[]) {
+   size_t n, size;
+ 
+   (void)argv;
+   if (argc > 0) {
+     chprintf(chp, "Usage: mem\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   n = chHeapStatus(NULL, &size);
+   chprintf(chp, "core free memory : %u bytes\r\n", chCoreStatus());
+   chprintf(chp, "heap fragments   : %u\r\n", n);
+   chprintf(chp, "heap free total  : %u bytes\r\n", size);
++
++  return SHELL_CMD_CONTINUE;
+ }
+ 
+-static void cmd_threads(BaseSequentialStream *chp, int argc, char *argv[]) {
++static int8_t cmd_threads(BaseSequentialStream *chp, int argc, char *argv[]) {
+   static const char *states[] = {THD_STATE_NAMES};
+   Thread *tp;
+ 
+   (void)argv;
+   if (argc > 0) {
+     chprintf(chp, "Usage: threads\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   chprintf(chp, "    addr    stack prio refs     state time\r\n");
+   tp = chRegFirstThread();
+@@ -374,26 +376,30 @@
+             states[tp->p_state], (uint32_t)tp->p_time);
+     tp = chRegNextThread(tp);
+   } while (tp != NULL);
++
++  return SHELL_CMD_CONTINUE;
+ }
+ 
+-static void cmd_test(BaseSequentialStream *chp, int argc, char *argv[]) {
++static int8_t cmd_test(BaseSequentialStream *chp, int argc, char *argv[]) {
+   Thread *tp;
+ 
+   (void)argv;
+   if (argc > 0) {
+     chprintf(chp, "Usage: test\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   tp = chThdCreateFromHeap(NULL, TEST_WA_SIZE, chThdGetPriority(),
+                            TestThread, chp);
+   if (tp == NULL) {
+     chprintf(chp, "out of memory\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   chThdWait(tp);
++
++  return SHELL_CMD_CONTINUE;
+ }
+ 
+-static void cmd_write(BaseSequentialStream *chp, int argc, char *argv[]) {
++static int8_t cmd_write(BaseSequentialStream *chp, int argc, char *argv[]) {
+   static uint8_t buf[] =
+       "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"
+       "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"
+@@ -415,13 +421,15 @@
+   (void)argv;
+   if (argc > 0) {
+     chprintf(chp, "Usage: write\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+ 
+   while (chnGetTimeout((BaseChannel *)chp, TIME_IMMEDIATE) == Q_TIMEOUT) {
+     chSequentialStreamWrite(&SDU1, buf, sizeof buf - 1);
+   }
+   chprintf(chp, "\r\n\nstopped\r\n");
++
++  return SHELL_CMD_CONTINUE;
+ }
+ 
+ static const ShellCommand commands[] = {
+Index: testhal/STM32F1xx/USB_CDC_F107/main.c
+===================================================================
+--- testhal/STM32F1xx/USB_CDC_F107/main.c	(Revision 6305)
++++ testhal/STM32F1xx/USB_CDC_F107/main.c	(Arbeitskopie)
+@@ -335,28 +335,30 @@
+ #define SHELL_WA_SIZE   THD_WA_SIZE(2048)
+ #define TEST_WA_SIZE    THD_WA_SIZE(256)
+ 
+-static void cmd_mem(BaseSequentialStream *chp, int argc, char *argv[]) {
++static int8_t cmd_mem(BaseSequentialStream *chp, int argc, char *argv[]) {
+   size_t n, size;
+ 
+   (void)argv;
+   if (argc > 0) {
+     chprintf(chp, "Usage: mem\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   n = chHeapStatus(NULL, &size);
+   chprintf(chp, "core free memory : %u bytes\r\n", chCoreStatus());
+   chprintf(chp, "heap fragments   : %u\r\n", n);
+   chprintf(chp, "heap free total  : %u bytes\r\n", size);
++
++  return SHELL_CMD_CONTINUE;
+ }
+ 
+-static void cmd_threads(BaseSequentialStream *chp, int argc, char *argv[]) {
++static int8_t cmd_threads(BaseSequentialStream *chp, int argc, char *argv[]) {
+   static const char *states[] = {THD_STATE_NAMES};
+   Thread *tp;
+ 
+   (void)argv;
+   if (argc > 0) {
+     chprintf(chp, "Usage: threads\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   chprintf(chp, "    addr    stack prio refs     state time\r\n");
+   tp = chRegFirstThread();
+@@ -367,26 +369,30 @@
+             states[tp->p_state], (uint32_t)tp->p_time);
+     tp = chRegNextThread(tp);
+   } while (tp != NULL);
++
++  return SHELL_CMD_CONTINUE;
+ }
+ 
+-static void cmd_test(BaseSequentialStream *chp, int argc, char *argv[]) {
++static int8_t cmd_test(BaseSequentialStream *chp, int argc, char *argv[]) {
+   Thread *tp;
+ 
+   (void)argv;
+   if (argc > 0) {
+     chprintf(chp, "Usage: test\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   tp = chThdCreateFromHeap(NULL, TEST_WA_SIZE, chThdGetPriority(),
+                            TestThread, chp);
+   if (tp == NULL) {
+     chprintf(chp, "out of memory\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   chThdWait(tp);
++
++  return SHELL_CMD_CONTINUE;
+ }
+ 
+-static void cmd_write(BaseSequentialStream *chp, int argc, char *argv[]) {
++static int8_t cmd_write(BaseSequentialStream *chp, int argc, char *argv[]) {
+   static uint8_t buf[] =
+       "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"
+       "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"
+@@ -408,13 +414,15 @@
+   (void)argv;
+   if (argc > 0) {
+     chprintf(chp, "Usage: write\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+ 
+   while (chnGetTimeout((BaseChannel *)chp, TIME_IMMEDIATE) == Q_TIMEOUT) {
+     chSequentialStreamWrite(&SDU1, buf, sizeof buf - 1);
+   }
+   chprintf(chp, "\r\n\nstopped\r\n");
++
++  return SHELL_CMD_CONTINUE;
+ }
+ 
+ static const ShellCommand commands[] = {
+Index: testhal/STM32F1xx/RTC_FATTIME/main.c
+===================================================================
+--- testhal/STM32F1xx/RTC_FATTIME/main.c	(Revision 6305)
++++ testhal/STM32F1xx/RTC_FATTIME/main.c	(Arbeitskopie)
+@@ -373,7 +373,7 @@
+ /**
+  *
+  */
+-void cmd_sdiotest(BaseSequentialStream *chp, int argc, char *argv[]){
++int8_t cmd_sdiotest(BaseSequentialStream *chp, int argc, char *argv[]){
+   (void)argc;
+   (void)argv;
+   FRESULT err;
+@@ -391,7 +391,7 @@
+   chprintf(chp, "ERROR! Chibios compiled without RTC support.");
+   chprintf(chp, "Enable HAL_USE_RCT in you halconf.h");
+   chThdSleepMilliseconds(100);
+-  return;
++  return SHELL_CMD_CONTINUE;
+ #endif
+ 
+   chprintf(chp, "Trying to connect SDIO... ");
+@@ -487,6 +487,8 @@
+   else{
+     chSysHalt();
+   }
++
++  return SHELL_CMD_CONTINUE;
+ }
+ 
+ /*===========================================================================*/
+Index: testhal/STM32F1xx/USB_CDC/main.c
+===================================================================
+--- testhal/STM32F1xx/USB_CDC/main.c	(Revision 6305)
++++ testhal/STM32F1xx/USB_CDC/main.c	(Arbeitskopie)
+@@ -335,28 +335,30 @@
+ #define SHELL_WA_SIZE   THD_WA_SIZE(2048)
+ #define TEST_WA_SIZE    THD_WA_SIZE(256)
+ 
+-static void cmd_mem(BaseSequentialStream *chp, int argc, char *argv[]) {
++static int8_t cmd_mem(BaseSequentialStream *chp, int argc, char *argv[]) {
+   size_t n, size;
+ 
+   (void)argv;
+   if (argc > 0) {
+     chprintf(chp, "Usage: mem\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   n = chHeapStatus(NULL, &size);
+   chprintf(chp, "core free memory : %u bytes\r\n", chCoreStatus());
+   chprintf(chp, "heap fragments   : %u\r\n", n);
+   chprintf(chp, "heap free total  : %u bytes\r\n", size);
++
++  return SHELL_CMD_CONTINUE;
+ }
+ 
+-static void cmd_threads(BaseSequentialStream *chp, int argc, char *argv[]) {
++static int8_t cmd_threads(BaseSequentialStream *chp, int argc, char *argv[]) {
+   static const char *states[] = {THD_STATE_NAMES};
+   Thread *tp;
+ 
+   (void)argv;
+   if (argc > 0) {
+     chprintf(chp, "Usage: threads\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   chprintf(chp, "    addr    stack prio refs     state time\r\n");
+   tp = chRegFirstThread();
+@@ -367,26 +369,30 @@
+             states[tp->p_state], (uint32_t)tp->p_time);
+     tp = chRegNextThread(tp);
+   } while (tp != NULL);
++
++  return SHELL_CMD_CONTINUE;
+ }
+ 
+-static void cmd_test(BaseSequentialStream *chp, int argc, char *argv[]) {
++static int8_t cmd_test(BaseSequentialStream *chp, int argc, char *argv[]) {
+   Thread *tp;
+ 
+   (void)argv;
+   if (argc > 0) {
+     chprintf(chp, "Usage: test\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   tp = chThdCreateFromHeap(NULL, TEST_WA_SIZE, chThdGetPriority(),
+                            TestThread, chp);
+   if (tp == NULL) {
+     chprintf(chp, "out of memory\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   chThdWait(tp);
++
++  return SHELL_CMD_CONTINUE;
+ }
+ 
+-static void cmd_write(BaseSequentialStream *chp, int argc, char *argv[]) {
++static int8_t cmd_write(BaseSequentialStream *chp, int argc, char *argv[]) {
+   static uint8_t buf[] =
+       "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"
+       "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"
+@@ -408,13 +414,15 @@
+   (void)argv;
+   if (argc > 0) {
+     chprintf(chp, "Usage: write\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+ 
+   while (chnGetTimeout((BaseChannel *)chp, TIME_IMMEDIATE) == Q_TIMEOUT) {
+     chSequentialStreamWrite(&SDU1, buf, sizeof buf - 1);
+   }
+   chprintf(chp, "\r\n\nstopped\r\n");
++
++  return SHELL_CMD_CONTINUE;
+ }
+ 
+ static const ShellCommand commands[] = {
+Index: testhal/STM32F37x/USB_CDC/main.c
+===================================================================
+--- testhal/STM32F37x/USB_CDC/main.c	(Revision 6305)
++++ testhal/STM32F37x/USB_CDC/main.c	(Arbeitskopie)
+@@ -341,28 +341,30 @@
+ #define SHELL_WA_SIZE   THD_WA_SIZE(2048)
+ #define TEST_WA_SIZE    THD_WA_SIZE(256)
+ 
+-static void cmd_mem(BaseSequentialStream *chp, int argc, char *argv[]) {
++static int8_t cmd_mem(BaseSequentialStream *chp, int argc, char *argv[]) {
+   size_t n, size;
+ 
+   (void)argv;
+   if (argc > 0) {
+     chprintf(chp, "Usage: mem\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   n = chHeapStatus(NULL, &size);
+   chprintf(chp, "core free memory : %u bytes\r\n", chCoreStatus());
+   chprintf(chp, "heap fragments   : %u\r\n", n);
+   chprintf(chp, "heap free total  : %u bytes\r\n", size);
++
++  return SHELL_CMD_CONTINUE;
+ }
+ 
+-static void cmd_threads(BaseSequentialStream *chp, int argc, char *argv[]) {
++static int8_t cmd_threads(BaseSequentialStream *chp, int argc, char *argv[]) {
+   static const char *states[] = {THD_STATE_NAMES};
+   Thread *tp;
+ 
+   (void)argv;
+   if (argc > 0) {
+     chprintf(chp, "Usage: threads\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   chprintf(chp, "    addr    stack prio refs     state time\r\n");
+   tp = chRegFirstThread();
+@@ -373,26 +375,30 @@
+             states[tp->p_state], (uint32_t)tp->p_time);
+     tp = chRegNextThread(tp);
+   } while (tp != NULL);
++
++  return SHELL_CMD_CONTINUE;
+ }
+ 
+-static void cmd_test(BaseSequentialStream *chp, int argc, char *argv[]) {
++static int8_t cmd_test(BaseSequentialStream *chp, int argc, char *argv[]) {
+   Thread *tp;
+ 
+   (void)argv;
+   if (argc > 0) {
+     chprintf(chp, "Usage: test\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   tp = chThdCreateFromHeap(NULL, TEST_WA_SIZE, chThdGetPriority(),
+                            TestThread, chp);
+   if (tp == NULL) {
+     chprintf(chp, "out of memory\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   chThdWait(tp);
++
++  return SHELL_CMD_CONTINUE;
+ }
+ 
+-static void cmd_write(BaseSequentialStream *chp, int argc, char *argv[]) {
++static int8_t cmd_write(BaseSequentialStream *chp, int argc, char *argv[]) {
+   static uint8_t buf[] =
+       "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"
+       "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"
+@@ -414,13 +420,15 @@
+   (void)argv;
+   if (argc > 0) {
+     chprintf(chp, "Usage: write\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+ 
+   while (chnGetTimeout((BaseChannel *)chp, TIME_IMMEDIATE) == Q_TIMEOUT) {
+     chSequentialStreamWrite(&SDU1, buf, sizeof buf - 1);
+   }
+   chprintf(chp, "\r\n\nstopped\r\n");
++
++  return SHELL_CMD_CONTINUE;
+ }
+ 
+ static const ShellCommand commands[] = {
+Index: testhal/STM32F4xx/RTC/main.c
+===================================================================
+--- testhal/STM32F4xx/RTC/main.c	(Revision 6305)
++++ testhal/STM32F4xx/RTC/main.c	(Arbeitskopie)
+@@ -83,11 +83,11 @@
+   __WFI();
+ }
+ 
+-static void cmd_sleep(BaseSequentialStream *chp, int argc, char *argv[]){
++static int8_t cmd_sleep(BaseSequentialStream *chp, int argc, char *argv[]){
+   (void)argv;
+   if (argc > 0) {
+     chprintf(chp, "Usage: sleep\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   chprintf(chp, "Going to sleep.\r\n");
+ 
+@@ -95,12 +95,14 @@
+ 
+   /* going to anabiosis */
+   func_sleep();
++
++  return SHELL_CMD_CONTINUE;
+ }
+ 
+ /*
+  *
+  */
+-static void cmd_alarm(BaseSequentialStream *chp, int argc, char *argv[]){
++static int8_t cmd_alarm(BaseSequentialStream *chp, int argc, char *argv[]){
+   int i = 0;
+ 
+   (void)argv;
+@@ -111,7 +113,7 @@
+   if ((argc == 1) && (strcmp(argv[0], "get") == 0)){
+     rtcGetAlarm(&RTCD1, 0, &alarmspec);
+     chprintf(chp, "%D%s",alarmspec," - alarm in STM internal format\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+ 
+   if ((argc == 2) && (strcmp(argv[0], "set") == 0)){
+@@ -119,7 +121,7 @@
+     alarmspec.tv_datetime = ((i / 10) & 7 << 4) | (i % 10) | RTC_ALRMAR_MSK4 |
+                             RTC_ALRMAR_MSK3 | RTC_ALRMAR_MSK2;
+     rtcSetAlarm(&RTCD1, 0, &alarmspec);
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   else{
+     goto ERROR;
+@@ -129,12 +131,14 @@
+   chprintf(chp, "Usage: alarm get\r\n");
+   chprintf(chp, "       alarm set N\r\n");
+   chprintf(chp, "where N is alarm time in seconds\r\n");
++
++  return SHELL_CMD_CONTINUE;
+ }
+ 
+ /*
+  *
+  */
+-static void cmd_date(BaseSequentialStream *chp, int argc, char *argv[]){
++static int8_t cmd_date(BaseSequentialStream *chp, int argc, char *argv[]){
+   (void)argv;
+   struct tm timp;
+ 
+@@ -153,14 +157,14 @@
+       rtcGetTimeTm(&RTCD1, &timp);
+       chprintf(chp, "%s%s",asctime(&timp)," - formatted time string\r\n");
+     }
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+ 
+   if ((argc == 2) && (strcmp(argv[0], "set") == 0)){
+     unix_time = atol(argv[1]);
+     if (unix_time > 0){
+       rtcSetTimeUnixSec(&RTCD1, unix_time);
+-      return;
++      return SHELL_CMD_CONTINUE;
+     }
+     else{
+       goto ERROR;
+@@ -176,7 +180,8 @@
+   chprintf(chp, "where N is time in seconds sins Unix epoch\r\n");
+   chprintf(chp, "you can get current N value from unix console by the command\r\n");
+   chprintf(chp, "%s", "date +\%s\r\n");
+-  return;
++
++  return SHELL_CMD_CONTINUE;
+ }
+ 
+ static SerialConfig ser_cfg = {
+Index: testhal/STM32F4xx/RTC_FATTIME/main.c
+===================================================================
+--- testhal/STM32F4xx/RTC_FATTIME/main.c	(Revision 6305)
++++ testhal/STM32F4xx/RTC_FATTIME/main.c	(Arbeitskopie)
+@@ -51,7 +51,7 @@
+ /**
+  *
+  */
+-void cmd_sdiotest(BaseSequentialStream *chp, int argc, char *argv[]){
++int8_t cmd_sdiotest(BaseSequentialStream *chp, int argc, char *argv[]){
+   (void)argc;
+   (void)argv;
+   FRESULT err;
+@@ -66,7 +66,7 @@
+   chprintf(chp, "ERROR! Chibios compiled without RTC support.");
+   chprintf(chp, "Enable HAL_USE_RCT in you halconf.h");
+   chThdSleepMilliseconds(100);
+-  return;
++  return SHELL_CMD_CONTINUE;
+ #endif
+ 
+   chprintf(chp, "Trying to connect SDIO... ");
+@@ -162,6 +162,8 @@
+   else{
+     chSysHalt();
+   }
++
++  return SHELL_CMD_CONTINUE;
+ }
+ 
+ /*
+Index: testhal/STM32F4xx/USB_CDC/main.c
+===================================================================
+--- testhal/STM32F4xx/USB_CDC/main.c	(Revision 6305)
++++ testhal/STM32F4xx/USB_CDC/main.c	(Arbeitskopie)
+@@ -335,28 +335,30 @@
+ #define SHELL_WA_SIZE   THD_WA_SIZE(2048)
+ #define TEST_WA_SIZE    THD_WA_SIZE(256)
+ 
+-static void cmd_mem(BaseSequentialStream *chp, int argc, char *argv[]) {
++static int8_t cmd_mem(BaseSequentialStream *chp, int argc, char *argv[]) {
+   size_t n, size;
+ 
+   (void)argv;
+   if (argc > 0) {
+     chprintf(chp, "Usage: mem\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   n = chHeapStatus(NULL, &size);
+   chprintf(chp, "core free memory : %u bytes\r\n", chCoreStatus());
+   chprintf(chp, "heap fragments   : %u\r\n", n);
+   chprintf(chp, "heap free total  : %u bytes\r\n", size);
++
++  return SHELL_CMD_CONTINUE;
+ }
+ 
+-static void cmd_threads(BaseSequentialStream *chp, int argc, char *argv[]) {
++static int8_t cmd_threads(BaseSequentialStream *chp, int argc, char *argv[]) {
+   static const char *states[] = {THD_STATE_NAMES};
+   Thread *tp;
+ 
+   (void)argv;
+   if (argc > 0) {
+     chprintf(chp, "Usage: threads\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   chprintf(chp, "    addr    stack prio refs     state time\r\n");
+   tp = chRegFirstThread();
+@@ -367,26 +369,30 @@
+             states[tp->p_state], (uint32_t)tp->p_time);
+     tp = chRegNextThread(tp);
+   } while (tp != NULL);
++
++  return SHELL_CMD_CONTINUE;
+ }
+ 
+-static void cmd_test(BaseSequentialStream *chp, int argc, char *argv[]) {
++static int8_t cmd_test(BaseSequentialStream *chp, int argc, char *argv[]) {
+   Thread *tp;
+ 
+   (void)argv;
+   if (argc > 0) {
+     chprintf(chp, "Usage: test\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   tp = chThdCreateFromHeap(NULL, TEST_WA_SIZE, chThdGetPriority(),
+                            TestThread, chp);
+   if (tp == NULL) {
+     chprintf(chp, "out of memory\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   chThdWait(tp);
++
++  return SHELL_CMD_CONTINUE;
+ }
+ 
+-static void cmd_write(BaseSequentialStream *chp, int argc, char *argv[]) {
++static int8_t cmd_write(BaseSequentialStream *chp, int argc, char *argv[]) {
+   static uint8_t buf[] =
+       "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"
+       "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"
+@@ -408,13 +414,15 @@
+   (void)argv;
+   if (argc > 0) {
+     chprintf(chp, "Usage: write\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+ 
+   while (chnGetTimeout((BaseChannel *)chp, TIME_IMMEDIATE) == Q_TIMEOUT) {
+     chSequentialStreamWrite(&SDU2, buf, sizeof buf - 1);
+   }
+   chprintf(chp, "\r\n\nstopped\r\n");
++
++  return SHELL_CMD_CONTINUE;
+ }
+ 
+ static const ShellCommand commands[] = {
+Index: testhal/STM32F4xx/SDC/main.c
+===================================================================
+--- testhal/STM32F4xx/SDC/main.c	(Revision 6305)
++++ testhal/STM32F4xx/SDC/main.c	(Arbeitskopie)
+@@ -101,7 +101,7 @@
+ /**
+  *
+  */
+-void cmd_sdiotest(BaseSequentialStream *chp, int argc, char *argv[]){
++int8_t cmd_sdiotest(BaseSequentialStream *chp, int argc, char *argv[]){
+   (void)argc;
+   (void)argv;
+   uint32_t i = 0;
+@@ -325,6 +325,8 @@
+   else{
+     chSysHalt();
+   }
++
++  return SHELL_CMD_CONTINUE;
+ }
+ 
+ 
+Index: demos/ARMCM4-STM32F407-LWIP-FATFS-USB/main.c
+===================================================================
+--- demos/ARMCM4-STM32F407-LWIP-FATFS-USB/main.c	(Revision 6305)
++++ demos/ARMCM4-STM32F407-LWIP-FATFS-USB/main.c	(Arbeitskopie)
+@@ -461,28 +461,30 @@
+ #define SHELL_WA_SIZE   THD_WA_SIZE(2048)
+ #define TEST_WA_SIZE    THD_WA_SIZE(256)
+ 
+-static void cmd_mem(BaseSequentialStream *chp, int argc, char *argv[]) {
++static int8_t cmd_mem(BaseSequentialStream *chp, int argc, char *argv[]) {
+   size_t n, size;
+ 
+   (void)argv;
+   if (argc > 0) {
+     chprintf(chp, "Usage: mem\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   n = chHeapStatus(NULL, &size);
+   chprintf(chp, "core free memory : %u bytes\r\n", chCoreStatus());
+   chprintf(chp, "heap fragments   : %u\r\n", n);
+   chprintf(chp, "heap free total  : %u bytes\r\n", size);
++
++  return SHELL_CMD_CONTINUE;
+ }
+ 
+-static void cmd_threads(BaseSequentialStream *chp, int argc, char *argv[]) {
++static int8_t cmd_threads(BaseSequentialStream *chp, int argc, char *argv[]) {
+   static const char *states[] = {THD_STATE_NAMES};
+   Thread *tp;
+ 
+   (void)argv;
+   if (argc > 0) {
+     chprintf(chp, "Usage: threads\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   chprintf(chp, "    addr    stack prio refs     state time\r\n");
+   tp = chRegFirstThread();
+@@ -493,26 +495,30 @@
+             states[tp->p_state], (uint32_t)tp->p_time);
+     tp = chRegNextThread(tp);
+   } while (tp != NULL);
++
++  return SHELL_CMD_CONTINUE;
+ }
+ 
+-static void cmd_test(BaseSequentialStream *chp, int argc, char *argv[]) {
++static int8_t cmd_test(BaseSequentialStream *chp, int argc, char *argv[]) {
+   Thread *tp;
+ 
+   (void)argv;
+   if (argc > 0) {
+     chprintf(chp, "Usage: test\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   tp = chThdCreateFromHeap(NULL, TEST_WA_SIZE, chThdGetPriority(),
+                            TestThread, chp);
+   if (tp == NULL) {
+     chprintf(chp, "out of memory\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   chThdWait(tp);
++
++  return SHELL_CMD_CONTINUE;
+ }
+ 
+-static void cmd_tree(BaseSequentialStream *chp, int argc, char *argv[]) {
++static int8_t cmd_tree(BaseSequentialStream *chp, int argc, char *argv[]) {
+   FRESULT err;
+   uint32_t clusters;
+   FATFS *fsp;
+@@ -520,16 +526,16 @@
+   (void)argv;
+   if (argc > 0) {
+     chprintf(chp, "Usage: tree\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   if (!fs_ready) {
+     chprintf(chp, "File System not mounted\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   err = f_getfree("/", &clusters, &fsp);
+   if (err != FR_OK) {
+     chprintf(chp, "FS: f_getfree() failed\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   chprintf(chp,
+            "FS: %lu free clusters, %lu sectors per cluster, %lu bytes free\r\n",
+@@ -537,6 +543,8 @@
+            clusters * (uint32_t)SDC_FS.csize * (uint32_t)MMCSD_BLOCK_SIZE);
+   fbuff[0] = 0;
+   scan_files(chp, (char *)fbuff);
++
++  return SHELL_CMD_CONTINUE;
+ }
+ 
+ static const ShellCommand commands[] = {
+Index: demos/PPC-SPC56EL-GCC/main.c
+===================================================================
+--- demos/PPC-SPC56EL-GCC/main.c	(Revision 6305)
++++ demos/PPC-SPC56EL-GCC/main.c	(Arbeitskopie)
+@@ -23,28 +23,30 @@
+ #define SHELL_WA_SIZE   THD_WA_SIZE(1024)
+ #define TEST_WA_SIZE    THD_WA_SIZE(256)
+ 
+-static void cmd_mem(BaseSequentialStream *chp, int argc, char *argv[]) {
++static int8_t cmd_mem(BaseSequentialStream *chp, int argc, char *argv[]) {
+   size_t n, size;
+ 
+   (void)argv;
+   if (argc > 0) {
+     chprintf(chp, "Usage: mem\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   n = chHeapStatus(NULL, &size);
+   chprintf(chp, "core free memory : %u bytes\r\n", chCoreStatus());
+   chprintf(chp, "heap fragments   : %u\r\n", n);
+   chprintf(chp, "heap free total  : %u bytes\r\n", size);
++
++  return SHELL_CMD_CONTINUE;
+ }
+ 
+-static void cmd_threads(BaseSequentialStream *chp, int argc, char *argv[]) {
++static int8_t cmd_threads(BaseSequentialStream *chp, int argc, char *argv[]) {
+   static const char *states[] = {THD_STATE_NAMES};
+   Thread *tp;
+ 
+   (void)argv;
+   if (argc > 0) {
+     chprintf(chp, "Usage: threads\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   chprintf(chp, "    addr    stack prio refs     state time\r\n");
+   tp = chRegFirstThread();
+@@ -55,23 +57,27 @@
+             states[tp->p_state], (uint32_t)tp->p_time);
+     tp = chRegNextThread(tp);
+   } while (tp != NULL);
++
++  return SHELL_CMD_CONTINUE;
+ }
+ 
+-static void cmd_test(BaseSequentialStream *chp, int argc, char *argv[]) {
++static int8_t cmd_test(BaseSequentialStream *chp, int argc, char *argv[]) {
+   Thread *tp;
+ 
+   (void)argv;
+   if (argc > 0) {
+     chprintf(chp, "Usage: test\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   tp = chThdCreateFromHeap(NULL, TEST_WA_SIZE, chThdGetPriority(),
+                            TestThread, chp);
+   if (tp == NULL) {
+     chprintf(chp, "out of memory\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   chThdWait(tp);
++
++  return SHELL_CMD_CONTINUE;
+ }
+ 
+ static const ShellCommand commands[] = {
+Index: demos/Posix-GCC/main.c
+===================================================================
+--- demos/Posix-GCC/main.c	(Revision 6305)
++++ demos/Posix-GCC/main.c	(Arbeitskopie)
+@@ -32,28 +32,30 @@
+ static Thread *shelltp1;
+ static Thread *shelltp2;
+ 
+-static void cmd_mem(BaseSequentialStream *chp, int argc, char *argv[]) {
++static int8_t cmd_mem(BaseSequentialStream *chp, int argc, char *argv[]) {
+   size_t n, size;
+ 
+   (void)argv;
+   if (argc > 0) {
+     chprintf(chp, "Usage: mem\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   n = chHeapStatus(NULL, &size);
+   chprintf(chp, "core free memory : %u bytes\r\n", chCoreStatus());
+   chprintf(chp, "heap fragments   : %u\r\n", n);
+   chprintf(chp, "heap free total  : %u bytes\r\n", size);
++
++  return SHELL_CMD_CONTINUE;
+ }
+ 
+-static void cmd_threads(BaseSequentialStream *chp, int argc, char *argv[]) {
++static int8_t cmd_threads(BaseSequentialStream *chp, int argc, char *argv[]) {
+   static const char *states[] = {THD_STATE_NAMES};
+   Thread *tp;
+ 
+   (void)argv;
+   if (argc > 0) {
+     chprintf(chp, "Usage: threads\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   chprintf(chp, "    addr    stack prio refs     state time\r\n");
+   tp = chRegFirstThread();
+@@ -64,23 +66,27 @@
+             states[tp->p_state], (uint32_t)tp->p_time);
+     tp = chRegNextThread(tp);
+   } while (tp != NULL);
++
++  return SHELL_CMD_CONTINUE;
+ }
+ 
+-static void cmd_test(BaseSequentialStream *chp, int argc, char *argv[]) {
++static int8_t cmd_test(BaseSequentialStream *chp, int argc, char *argv[]) {
+   Thread *tp;
+ 
+   (void)argv;
+   if (argc > 0) {
+     chprintf(chp, "Usage: test\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   tp = chThdCreateFromHeap(NULL, TEST_WA_SIZE, chThdGetPriority(),
+                            TestThread, chp);
+   if (tp == NULL) {
+     chprintf(chp, "out of memory\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   chThdWait(tp);
++
++  return SHELL_CMD_CONTINUE;
+ }
+ 
+ static const ShellCommand commands[] = {
+Index: demos/ARMCM4-STM32F407-DISCOVERY-MEMS/main.c
+===================================================================
+--- demos/ARMCM4-STM32F407-DISCOVERY-MEMS/main.c	(Revision 6305)
++++ demos/ARMCM4-STM32F407-DISCOVERY-MEMS/main.c	(Arbeitskopie)
+@@ -34,28 +34,30 @@
+ #define SHELL_WA_SIZE   THD_WA_SIZE(2048)
+ #define TEST_WA_SIZE    THD_WA_SIZE(256)
+ 
+-static void cmd_mem(BaseSequentialStream *chp, int argc, char *argv[]) {
++static int8_t cmd_mem(BaseSequentialStream *chp, int argc, char *argv[]) {
+   size_t n, size;
+ 
+   (void)argv;
+   if (argc > 0) {
+     chprintf(chp, "Usage: mem\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   n = chHeapStatus(NULL, &size);
+   chprintf(chp, "core free memory : %u bytes\r\n", chCoreStatus());
+   chprintf(chp, "heap fragments   : %u\r\n", n);
+   chprintf(chp, "heap free total  : %u bytes\r\n", size);
++
++  return SHELL_CMD_CONTINUE;
+ }
+ 
+-static void cmd_threads(BaseSequentialStream *chp, int argc, char *argv[]) {
++static int8_t cmd_threads(BaseSequentialStream *chp, int argc, char *argv[]) {
+   static const char *states[] = {THD_STATE_NAMES};
+   Thread *tp;
+ 
+   (void)argv;
+   if (argc > 0) {
+     chprintf(chp, "Usage: threads\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   chprintf(chp, "    addr    stack prio refs     state time\r\n");
+   tp = chRegFirstThread();
+@@ -66,21 +68,23 @@
+             states[tp->p_state], (uint32_t)tp->p_time);
+     tp = chRegNextThread(tp);
+   } while (tp != NULL);
++
++  return SHELL_CMD_CONTINUE;
+ }
+ 
+-static void cmd_test(BaseSequentialStream *chp, int argc, char *argv[]) {
++static int8_t cmd_test(BaseSequentialStream *chp, int argc, char *argv[]) {
+   Thread *tp;
+ 
+   (void)argv;
+   if (argc > 0) {
+     chprintf(chp, "Usage: test\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   tp = chThdCreateFromHeap(NULL, TEST_WA_SIZE, chThdGetPriority(),
+                            TestThread, chp);
+   if (tp == NULL) {
+     chprintf(chp, "out of memory\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   chThdWait(tp);
+ }
+Index: demos/ARMCM3-STM32F103ZG-FATFS/main.c
+===================================================================
+--- demos/ARMCM3-STM32F103ZG-FATFS/main.c	(Revision 6305)
++++ demos/ARMCM3-STM32F103ZG-FATFS/main.c	(Arbeitskopie)
+@@ -154,28 +154,30 @@
+ #define SHELL_WA_SIZE   THD_WA_SIZE(2048)
+ #define TEST_WA_SIZE    THD_WA_SIZE(256)
+ 
+-static void cmd_mem(BaseSequentialStream *chp, int argc, char *argv[]) {
++static int8_t cmd_mem(BaseSequentialStream *chp, int argc, char *argv[]) {
+   size_t n, size;
+ 
+   (void)argv;
+   if (argc > 0) {
+     chprintf(chp, "Usage: mem\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   n = chHeapStatus(NULL, &size);
+   chprintf(chp, "core free memory : %u bytes\r\n", chCoreStatus());
+   chprintf(chp, "heap fragments   : %u\r\n", n);
+   chprintf(chp, "heap free total  : %u bytes\r\n", size);
++
++  return SHELL_CMD_CONTINUE;
+ }
+ 
+-static void cmd_threads(BaseSequentialStream *chp, int argc, char *argv[]) {
++static int8_t cmd_threads(BaseSequentialStream *chp, int argc, char *argv[]) {
+   static const char *states[] = {THD_STATE_NAMES};
+   Thread *tp;
+ 
+   (void)argv;
+   if (argc > 0) {
+     chprintf(chp, "Usage: threads\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   chprintf(chp, "    addr    stack prio refs     state time\r\n");
+   tp = chRegFirstThread();
+@@ -186,26 +188,30 @@
+             states[tp->p_state], (uint32_t)tp->p_time);
+     tp = chRegNextThread(tp);
+   } while (tp != NULL);
++
++  return SHELL_CMD_CONTINUE;
+ }
+ 
+-static void cmd_test(BaseSequentialStream *chp, int argc, char *argv[]) {
++static int8_t cmd_test(BaseSequentialStream *chp, int argc, char *argv[]) {
+   Thread *tp;
+ 
+   (void)argv;
+   if (argc > 0) {
+     chprintf(chp, "Usage: test\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   tp = chThdCreateFromHeap(NULL, TEST_WA_SIZE, chThdGetPriority(),
+                            TestThread, chp);
+   if (tp == NULL) {
+     chprintf(chp, "out of memory\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   chThdWait(tp);
++
++  return SHELL_CMD_CONTINUE;
+ }
+ 
+-static void cmd_tree(BaseSequentialStream *chp, int argc, char *argv[]) {
++static int8_t cmd_tree(BaseSequentialStream *chp, int argc, char *argv[]) {
+   FRESULT err;
+   uint32_t clusters;
+   FATFS *fsp;
+@@ -213,16 +219,16 @@
+   (void)argv;
+   if (argc > 0) {
+     chprintf(chp, "Usage: tree\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   if (!fs_ready) {
+     chprintf(chp, "File System not mounted\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   err = f_getfree("/", &clusters, &fsp);
+   if (err != FR_OK) {
+     chprintf(chp, "FS: f_getfree() failed\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   chprintf(chp,
+            "FS: %lu free clusters, %lu sectors per cluster, %lu bytes free\r\n",
+@@ -230,6 +236,8 @@
+            clusters * (uint32_t)SDC_FS.csize * (uint32_t)MMCSD_BLOCK_SIZE);
+   fbuff[0] = 0;
+   scan_files(chp, (char *)fbuff);
++
++  return SHELL_CMD_CONTINUE;
+ }
+ 
+ static const ShellCommand commands[] = {
+Index: demos/PPC-SPC563M-GCC/main.c
+===================================================================
+--- demos/PPC-SPC563M-GCC/main.c	(Revision 6305)
++++ demos/PPC-SPC563M-GCC/main.c	(Arbeitskopie)
+@@ -25,28 +25,30 @@
+ #define SHELL_WA_SIZE   THD_WA_SIZE(1024)
+ #define TEST_WA_SIZE    THD_WA_SIZE(256)
+ 
+-static void cmd_mem(BaseSequentialStream *chp, int argc, char *argv[]) {
++static int8_t cmd_mem(BaseSequentialStream *chp, int argc, char *argv[]) {
+   size_t n, size;
+ 
+   (void)argv;
+   if (argc > 0) {
+     chprintf(chp, "Usage: mem\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   n = chHeapStatus(NULL, &size);
+   chprintf(chp, "core free memory : %u bytes\r\n", chCoreStatus());
+   chprintf(chp, "heap fragments   : %u\r\n", n);
+   chprintf(chp, "heap free total  : %u bytes\r\n", size);
++
++  return SHELL_CMD_CONTINUE;
+ }
+ 
+-static void cmd_threads(BaseSequentialStream *chp, int argc, char *argv[]) {
++static int8_t cmd_threads(BaseSequentialStream *chp, int argc, char *argv[]) {
+   static const char *states[] = {THD_STATE_NAMES};
+   Thread *tp;
+ 
+   (void)argv;
+   if (argc > 0) {
+     chprintf(chp, "Usage: threads\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   chprintf(chp, "    addr    stack prio refs     state time\r\n");
+   tp = chRegFirstThread();
+@@ -57,23 +59,27 @@
+             states[tp->p_state], (uint32_t)tp->p_time);
+     tp = chRegNextThread(tp);
+   } while (tp != NULL);
++
++  return SHELL_CMD_CONTINUE;
+ }
+ 
+-static void cmd_test(BaseSequentialStream *chp, int argc, char *argv[]) {
++static int8_t cmd_test(BaseSequentialStream *chp, int argc, char *argv[]) {
+   Thread *tp;
+ 
+   (void)argv;
+   if (argc > 0) {
+     chprintf(chp, "Usage: test\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   tp = chThdCreateFromHeap(NULL, TEST_WA_SIZE, chThdGetPriority(),
+                            TestThread, chp);
+   if (tp == NULL) {
+     chprintf(chp, "out of memory\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   chThdWait(tp);
++
++  return SHELL_CMD_CONTINUE;
+ }
+ 
+ static const ShellCommand commands[] = {
+Index: demos/ARMCM3-STM32F103-FATFS/main.c
+===================================================================
+--- demos/ARMCM3-STM32F103-FATFS/main.c	(Revision 6305)
++++ demos/ARMCM3-STM32F103-FATFS/main.c	(Arbeitskopie)
+@@ -176,28 +176,30 @@
+ #define SHELL_WA_SIZE   THD_WA_SIZE(2048)
+ #define TEST_WA_SIZE    THD_WA_SIZE(256)
+ 
+-static void cmd_mem(BaseSequentialStream *chp, int argc, char *argv[]) {
++static int8_t cmd_mem(BaseSequentialStream *chp, int argc, char *argv[]) {
+   size_t n, size;
+ 
+   (void)argv;
+   if (argc > 0) {
+     chprintf(chp, "Usage: mem\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   n = chHeapStatus(NULL, &size);
+   chprintf(chp, "core free memory : %u bytes\r\n", chCoreStatus());
+   chprintf(chp, "heap fragments   : %u\r\n", n);
+   chprintf(chp, "heap free total  : %u bytes\r\n", size);
++
++  return SHELL_CMD_CONTINUE;
+ }
+ 
+-static void cmd_threads(BaseSequentialStream *chp, int argc, char *argv[]) {
++static int8_t cmd_threads(BaseSequentialStream *chp, int argc, char *argv[]) {
+   static const char *states[] = {THD_STATE_NAMES};
+   Thread *tp;
+ 
+   (void)argv;
+   if (argc > 0) {
+     chprintf(chp, "Usage: threads\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   chprintf(chp, "    addr    stack prio refs     state time\r\n");
+   tp = chRegFirstThread();
+@@ -208,26 +210,30 @@
+             states[tp->p_state], (uint32_t)tp->p_time);
+     tp = chRegNextThread(tp);
+   } while (tp != NULL);
++
++  return SHELL_CMD_CONTINUE;
+ }
+ 
+-static void cmd_test(BaseSequentialStream *chp, int argc, char *argv[]) {
++static int8_t cmd_test(BaseSequentialStream *chp, int argc, char *argv[]) {
+   Thread *tp;
+ 
+   (void)argv;
+   if (argc > 0) {
+     chprintf(chp, "Usage: test\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   tp = chThdCreateFromHeap(NULL, TEST_WA_SIZE, chThdGetPriority(),
+                            TestThread, chp);
+   if (tp == NULL) {
+     chprintf(chp, "out of memory\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   chThdWait(tp);
++
++  return SHELL_CMD_CONTINUE;
+ }
+ 
+-static void cmd_tree(BaseSequentialStream *chp, int argc, char *argv[]) {
++static int8_t cmd_tree(BaseSequentialStream *chp, int argc, char *argv[]) {
+   FRESULT err;
+   uint32_t clusters;
+   FATFS *fsp;
+@@ -235,16 +241,16 @@
+   (void)argv;
+   if (argc > 0) {
+     chprintf(chp, "Usage: tree\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   if (!fs_ready) {
+     chprintf(chp, "File System not mounted\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   err = f_getfree("/", &clusters, &fsp);
+   if (err != FR_OK) {
+     chprintf(chp, "FS: f_getfree() failed\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   chprintf(chp,
+            "FS: %lu free clusters, %lu sectors per cluster, %lu bytes free\r\n",
+@@ -252,6 +258,8 @@
+            clusters * (uint32_t)MMC_FS.csize * (uint32_t)MMCSD_BLOCK_SIZE);
+   fbuff[0] = 0;
+   scan_files(chp, (char *)fbuff);
++
++  return SHELL_CMD_CONTINUE;
+ }
+ 
+ static const ShellCommand commands[] = {
+Index: demos/ARMCM3-STM32F107-FATFS/main.c
+===================================================================
+--- demos/ARMCM3-STM32F107-FATFS/main.c	(Revision 6305)
++++ demos/ARMCM3-STM32F107-FATFS/main.c	(Arbeitskopie)
+@@ -168,28 +168,30 @@
+ #define SHELL_WA_SIZE   THD_WA_SIZE(2048)
+ #define TEST_WA_SIZE    THD_WA_SIZE(256)
+ 
+-static void cmd_mem(BaseSequentialStream *chp, int argc, char *argv[]) {
++static int8_t cmd_mem(BaseSequentialStream *chp, int argc, char *argv[]) {
+   size_t n, size;
+ 
+   (void)argv;
+   if (argc > 0) {
+     chprintf(chp, "Usage: mem\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   n = chHeapStatus(NULL, &size);
+   chprintf(chp, "core free memory : %u bytes\r\n", chCoreStatus());
+   chprintf(chp, "heap fragments   : %u\r\n", n);
+   chprintf(chp, "heap free total  : %u bytes\r\n", size);
++
++  return SHELL_CMD_CONTINUE;
+ }
+ 
+-static void cmd_threads(BaseSequentialStream *chp, int argc, char *argv[]) {
++static int8_t cmd_threads(BaseSequentialStream *chp, int argc, char *argv[]) {
+   static const char *states[] = {THD_STATE_NAMES};
+   Thread *tp;
+ 
+   (void)argv;
+   if (argc > 0) {
+     chprintf(chp, "Usage: threads\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   chprintf(chp, "    addr    stack prio refs     state time\r\n");
+   tp = chRegFirstThread();
+@@ -200,26 +202,30 @@
+             states[tp->p_state], (uint32_t)tp->p_time);
+     tp = chRegNextThread(tp);
+   } while (tp != NULL);
++
++  return SHELL_CMD_CONTINUE;
+ }
+ 
+-static void cmd_test(BaseSequentialStream *chp, int argc, char *argv[]) {
++static int8_t cmd_test(BaseSequentialStream *chp, int argc, char *argv[]) {
+   Thread *tp;
+ 
+   (void)argv;
+   if (argc > 0) {
+     chprintf(chp, "Usage: test\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   tp = chThdCreateFromHeap(NULL, TEST_WA_SIZE, chThdGetPriority(),
+                            TestThread, chp);
+   if (tp == NULL) {
+     chprintf(chp, "out of memory\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   chThdWait(tp);
++
++  return SHELL_CMD_CONTINUE;
+ }
+ 
+-static void cmd_tree(BaseSequentialStream *chp, int argc, char *argv[]) {
++static int8_t cmd_tree(BaseSequentialStream *chp, int argc, char *argv[]) {
+   FRESULT err;
+   uint32_t clusters;
+   FATFS *fsp;
+@@ -227,16 +233,16 @@
+   (void)argv;
+   if (argc > 0) {
+     chprintf(chp, "Usage: tree\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   if (!fs_ready) {
+     chprintf(chp, "File System not mounted\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   err = f_getfree("/", &clusters, &fsp);
+   if (err != FR_OK) {
+     chprintf(chp, "FS: f_getfree() failed\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   chprintf(chp,
+            "FS: %lu free clusters, %lu sectors per cluster, %lu bytes free\r\n",
+@@ -244,6 +250,8 @@
+            clusters * (uint32_t)MMC_FS.csize * (uint32_t)MMCSD_BLOCK_SIZE);
+   fbuff[0] = 0;
+   scan_files(chp, (char *)fbuff);
++
++  return SHELL_CMD_CONTINUE;
+ }
+ 
+ static const ShellCommand commands[] = {
+Index: demos/PPC-SPC560B-GCC/main.c
+===================================================================
+--- demos/PPC-SPC560B-GCC/main.c	(Revision 6305)
++++ demos/PPC-SPC560B-GCC/main.c	(Arbeitskopie)
+@@ -23,28 +23,30 @@
+ #define SHELL_WA_SIZE   THD_WA_SIZE(1024)
+ #define TEST_WA_SIZE    THD_WA_SIZE(256)
+ 
+-static void cmd_mem(BaseSequentialStream *chp, int argc, char *argv[]) {
++static int8_t cmd_mem(BaseSequentialStream *chp, int argc, char *argv[]) {
+   size_t n, size;
+ 
+   (void)argv;
+   if (argc > 0) {
+     chprintf(chp, "Usage: mem\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   n = chHeapStatus(NULL, &size);
+   chprintf(chp, "core free memory : %u bytes\r\n", chCoreStatus());
+   chprintf(chp, "heap fragments   : %u\r\n", n);
+   chprintf(chp, "heap free total  : %u bytes\r\n", size);
++
++  return SHELL_CMD_CONTINUE;
+ }
+ 
+-static void cmd_threads(BaseSequentialStream *chp, int argc, char *argv[]) {
++static int8_t cmd_threads(BaseSequentialStream *chp, int argc, char *argv[]) {
+   static const char *states[] = {THD_STATE_NAMES};
+   Thread *tp;
+ 
+   (void)argv;
+   if (argc > 0) {
+     chprintf(chp, "Usage: threads\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   chprintf(chp, "    addr    stack prio refs     state time\r\n");
+   tp = chRegFirstThread();
+@@ -55,23 +57,27 @@
+             states[tp->p_state], (uint32_t)tp->p_time);
+     tp = chRegNextThread(tp);
+   } while (tp != NULL);
++
++  return SHELL_CMD_CONTINUE;
+ }
+ 
+-static void cmd_test(BaseSequentialStream *chp, int argc, char *argv[]) {
++static int8_t cmd_test(BaseSequentialStream *chp, int argc, char *argv[]) {
+   Thread *tp;
+ 
+   (void)argv;
+   if (argc > 0) {
+     chprintf(chp, "Usage: test\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   tp = chThdCreateFromHeap(NULL, TEST_WA_SIZE, chThdGetPriority(),
+                            TestThread, chp);
+   if (tp == NULL) {
+     chprintf(chp, "out of memory\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   chThdWait(tp);
++
++  return SHELL_CMD_CONTINUE;
+ }
+ 
+ static const ShellCommand commands[] = {
+@@ -173,6 +179,11 @@
+   chSysInit();
+ 
+   /*
++   * Shell manager initialization.
++   */
++  shellInit();
++
++  /*
+    * Activates the serial driver 1 using the driver default configuration.
+    */
+   sdStart(&SD1, NULL);
+Index: demos/ARM7-AT91SAM7X-FATFS-GCC/main.c
+===================================================================
+--- demos/ARM7-AT91SAM7X-FATFS-GCC/main.c	(Revision 6305)
++++ demos/ARM7-AT91SAM7X-FATFS-GCC/main.c	(Arbeitskopie)
+@@ -188,28 +188,30 @@
+ #define SHELL_WA_SIZE   THD_WA_SIZE(1024)
+ #define TEST_WA_SIZE    THD_WA_SIZE(256)
+ 
+-static void cmd_mem(BaseSequentialStream *chp, int argc, char *argv[]) {
++static int8_t cmd_mem(BaseSequentialStream *chp, int argc, char *argv[]) {
+   size_t n, size;
+ 
+   (void)argv;
+   if (argc > 0) {
+     chprintf(chp, "Usage: mem\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   n = chHeapStatus(NULL, &size);
+   chprintf(chp, "core free memory : %u bytes\r\n", chCoreStatus());
+   chprintf(chp, "heap fragments   : %u\r\n", n);
+   chprintf(chp, "heap free total  : %u bytes\r\n", size);
++
++  return SHELL_CMD_CONTINUE;
+ }
+ 
+-static void cmd_threads(BaseSequentialStream *chp, int argc, char *argv[]) {
++static int8_t cmd_threads(BaseSequentialStream *chp, int argc, char *argv[]) {
+   static const char *states[] = {THD_STATE_NAMES};
+   Thread *tp;
+ 
+   (void)argv;
+   if (argc > 0) {
+     chprintf(chp, "Usage: threads\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   chprintf(chp, "    addr    stack prio refs     state time\r\n");
+   tp = chRegFirstThread();
+@@ -220,26 +222,30 @@
+             states[tp->p_state], (uint32_t)tp->p_time);
+     tp = chRegNextThread(tp);
+   } while (tp != NULL);
++
++  return SHELL_CMD_CONTINUE;
+ }
+ 
+-static void cmd_test(BaseSequentialStream *chp, int argc, char *argv[]) {
++static int8_t cmd_test(BaseSequentialStream *chp, int argc, char *argv[]) {
+   Thread *tp;
+ 
+   (void)argv;
+   if (argc > 0) {
+     chprintf(chp, "Usage: test\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   tp = chThdCreateFromHeap(NULL, TEST_WA_SIZE, chThdGetPriority(),
+                            TestThread, chp);
+   if (tp == NULL) {
+     chprintf(chp, "out of memory\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   chThdWait(tp);
++
++  return SHELL_CMD_CONTINUE;
+ }
+ 
+-static void cmd_tree(BaseSequentialStream *chp, int argc, char *argv[]) {
++static int8_t cmd_tree(BaseSequentialStream *chp, int argc, char *argv[]) {
+   FRESULT err;
+   uint32_t clusters;
+   FATFS *fsp;
+@@ -247,16 +253,16 @@
+   (void)argv;
+   if (argc > 0) {
+     chprintf(chp, "Usage: tree\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   if (!fs_ready) {
+     chprintf(chp, "File System not mounted\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   err = f_getfree("/", &clusters, &fsp);
+   if (err != FR_OK) {
+     chprintf(chp, "FS: f_getfree() failed\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   chprintf(chp,
+            "FS: %lu free clusters, %lu sectors per cluster, %lu bytes free\r\n",
+@@ -264,6 +270,8 @@
+            clusters * (uint32_t)MMC_FS.csize * (uint32_t)MMCSD_BLOCK_SIZE);
+   fbuff[0] = 0;
+   scan_files(chp, (char *)fbuff);
++
++  return SHELL_CMD_CONTINUE;
+ }
+ 
+ static const ShellCommand commands[] = {
+Index: demos/PPC-SPC564A-GCC/main.c
+===================================================================
+--- demos/PPC-SPC564A-GCC/main.c	(Revision 6305)
++++ demos/PPC-SPC564A-GCC/main.c	(Arbeitskopie)
+@@ -25,28 +25,30 @@
+ #define SHELL_WA_SIZE   THD_WA_SIZE(1024)
+ #define TEST_WA_SIZE    THD_WA_SIZE(256)
+ 
+-static void cmd_mem(BaseSequentialStream *chp, int argc, char *argv[]) {
++static int8_t cmd_mem(BaseSequentialStream *chp, int argc, char *argv[]) {
+   size_t n, size;
+ 
+   (void)argv;
+   if (argc > 0) {
+     chprintf(chp, "Usage: mem\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   n = chHeapStatus(NULL, &size);
+   chprintf(chp, "core free memory : %u bytes\r\n", chCoreStatus());
+   chprintf(chp, "heap fragments   : %u\r\n", n);
+   chprintf(chp, "heap free total  : %u bytes\r\n", size);
++
++  return SHELL_CMD_CONTINUE;
+ }
+ 
+-static void cmd_threads(BaseSequentialStream *chp, int argc, char *argv[]) {
++static int8_t cmd_threads(BaseSequentialStream *chp, int argc, char *argv[]) {
+   static const char *states[] = {THD_STATE_NAMES};
+   Thread *tp;
+ 
+   (void)argv;
+   if (argc > 0) {
+     chprintf(chp, "Usage: threads\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   chprintf(chp, "    addr    stack prio refs     state time\r\n");
+   tp = chRegFirstThread();
+@@ -57,23 +59,27 @@
+             states[tp->p_state], (uint32_t)tp->p_time);
+     tp = chRegNextThread(tp);
+   } while (tp != NULL);
++
++  return SHELL_CMD_CONTINUE;
+ }
+ 
+-static void cmd_test(BaseSequentialStream *chp, int argc, char *argv[]) {
++static int8_t cmd_test(BaseSequentialStream *chp, int argc, char *argv[]) {
+   Thread *tp;
+ 
+   (void)argv;
+   if (argc > 0) {
+     chprintf(chp, "Usage: test\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   tp = chThdCreateFromHeap(NULL, TEST_WA_SIZE, chThdGetPriority(),
+                            TestThread, chp);
+   if (tp == NULL) {
+     chprintf(chp, "out of memory\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   chThdWait(tp);
++
++  return SHELL_CMD_CONTINUE;
+ }
+ 
+ static const ShellCommand commands[] = {
+Index: demos/PPC-SPC560P-GCC/main.c
+===================================================================
+--- demos/PPC-SPC560P-GCC/main.c	(Revision 6305)
++++ demos/PPC-SPC560P-GCC/main.c	(Arbeitskopie)
+@@ -23,28 +23,30 @@
+ #define SHELL_WA_SIZE   THD_WA_SIZE(1024)
+ #define TEST_WA_SIZE    THD_WA_SIZE(256)
+ 
+-static void cmd_mem(BaseSequentialStream *chp, int argc, char *argv[]) {
++static int8_t cmd_mem(BaseSequentialStream *chp, int argc, char *argv[]) {
+   size_t n, size;
+ 
+   (void)argv;
+   if (argc > 0) {
+     chprintf(chp, "Usage: mem\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   n = chHeapStatus(NULL, &size);
+   chprintf(chp, "core free memory : %u bytes\r\n", chCoreStatus());
+   chprintf(chp, "heap fragments   : %u\r\n", n);
+   chprintf(chp, "heap free total  : %u bytes\r\n", size);
++
++  return SHELL_CMD_CONTINUE;
+ }
+ 
+-static void cmd_threads(BaseSequentialStream *chp, int argc, char *argv[]) {
++static int8_t cmd_threads(BaseSequentialStream *chp, int argc, char *argv[]) {
+   static const char *states[] = {THD_STATE_NAMES};
+   Thread *tp;
+ 
+   (void)argv;
+   if (argc > 0) {
+     chprintf(chp, "Usage: threads\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   chprintf(chp, "    addr    stack prio refs     state time\r\n");
+   tp = chRegFirstThread();
+@@ -55,23 +57,27 @@
+             states[tp->p_state], (uint32_t)tp->p_time);
+     tp = chRegNextThread(tp);
+   } while (tp != NULL);
++
++  return SHELL_CMD_CONTINUE;
+ }
+ 
+-static void cmd_test(BaseSequentialStream *chp, int argc, char *argv[]) {
++static int8_t cmd_test(BaseSequentialStream *chp, int argc, char *argv[]) {
+   Thread *tp;
+ 
+   (void)argv;
+   if (argc > 0) {
+     chprintf(chp, "Usage: test\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   tp = chThdCreateFromHeap(NULL, TEST_WA_SIZE, chThdGetPriority(),
+                            TestThread, chp);
+   if (tp == NULL) {
+     chprintf(chp, "out of memory\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   chThdWait(tp);
++
++  return SHELL_CMD_CONTINUE;
+ }
+ 
+ static const ShellCommand commands[] = {
+Index: demos/Win32-MinGW/main.c
+===================================================================
+--- demos/Win32-MinGW/main.c	(Revision 6305)
++++ demos/Win32-MinGW/main.c	(Arbeitskopie)
+@@ -30,28 +30,30 @@
+ static Thread *shelltp1;
+ static Thread *shelltp2;
+ 
+-static void cmd_mem(BaseSequentialStream *chp, int argc, char *argv[]) {
++static int8_t cmd_mem(BaseSequentialStream *chp, int argc, char *argv[]) {
+   size_t n, size;
+ 
+   (void)argv;
+   if (argc > 0) {
+     chprintf(chp, "Usage: mem\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   n = chHeapStatus(NULL, &size);
+   chprintf(chp, "core free memory : %u bytes\r\n", chCoreStatus());
+   chprintf(chp, "heap fragments   : %u\r\n", n);
+   chprintf(chp, "heap free total  : %u bytes\r\n", size);
++
++  return SHELL_CMD_CONTINUE;
+ }
+ 
+-static void cmd_threads(BaseSequentialStream *chp, int argc, char *argv[]) {
++static int8_t cmd_threads(BaseSequentialStream *chp, int argc, char *argv[]) {
+   static const char *states[] = {THD_STATE_NAMES};
+   Thread *tp;
+ 
+   (void)argv;
+   if (argc > 0) {
+     chprintf(chp, "Usage: threads\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   chprintf(chp, "    addr    stack prio refs     state time\r\n");
+   tp = chRegFirstThread();
+@@ -62,23 +64,27 @@
+             states[tp->p_state], (uint32_t)tp->p_time);
+     tp = chRegNextThread(tp);
+   } while (tp != NULL);
++
++  return SHELL_CMD_CONTINUE;
+ }
+ 
+-static void cmd_test(BaseSequentialStream *chp, int argc, char *argv[]) {
++static int8_t cmd_test(BaseSequentialStream *chp, int argc, char *argv[]) {
+   Thread *tp;
+ 
+   (void)argv;
+   if (argc > 0) {
+     chprintf(chp, "Usage: test\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   tp = chThdCreateFromHeap(NULL, TEST_WA_SIZE, chThdGetPriority(),
+                            TestThread, chp);
+   if (tp == NULL) {
+     chprintf(chp, "out of memory\r\n");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   chThdWait(tp);
++
++  return SHELL_CMD_CONTINUE;
+ }
+ 
+ static const ShellCommand commands[] = {
+Index: os/various/shell.c
+===================================================================
+--- os/various/shell.c	(Revision 6305)
++++ os/various/shell.c	(Arbeitskopie)
+@@ -64,12 +64,12 @@
+   }
+ }
+ 
+-static void cmd_info(BaseSequentialStream *chp, int argc, char *argv[]) {
++static int8_t cmd_info(BaseSequentialStream *chp, int argc, char *argv[]) {
+ 
+   (void)argv;
+   if (argc > 0) {
+     usage(chp, "info");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+ 
+   chprintf(chp, "Kernel:       %s\r\n", CH_KERNEL_VERSION);
+@@ -94,16 +94,20 @@
+   chprintf(chp, "Build time:   %s%s%s\r\n", __DATE__, " - ", __TIME__);
+ #endif
+ #endif
++
++  return SHELL_CMD_CONTINUE;
+ }
+ 
+-static void cmd_systime(BaseSequentialStream *chp, int argc, char *argv[]) {
++static int8_t cmd_systime(BaseSequentialStream *chp, int argc, char *argv[]) {
+ 
+   (void)argv;
+   if (argc > 0) {
+     usage(chp, "systime");
+-    return;
++    return SHELL_CMD_CONTINUE;
+   }
+   chprintf(chp, "%lu\r\n", (unsigned long)chTimeNow());
++
++  return SHELL_CMD_CONTINUE;
+ }
+ 
+ /**
+@@ -116,11 +120,11 @@
+ };
+ 
+ static bool_t cmdexec(const ShellCommand *scp, BaseSequentialStream *chp,
+-                      char *name, int argc, char *argv[]) {
++                      char *name, int argc, char *argv[], int8_t *cont) {
+ 
+   while (scp->sc_name != NULL) {
+     if (strcasecmp(scp->sc_name, name) == 0) {
+-      scp->sc_function(chp, argc, argv);
++      *cont = scp->sc_function(chp, argc, argv);
+       return FALSE;
+     }
+     scp++;
+@@ -143,6 +147,7 @@
+   const ShellCommand *scp = ((ShellConfig *)p)->sc_commands;
+   char *lp, *cmd, *tokp, line[SHELL_MAX_LINE_LENGTH];
+   char *args[SHELL_MAX_ARGUMENTS + 1];
++  int8_t cont = SHELL_CMD_CONTINUE;
+ 
+   chRegSetThreadName("shell");
+   chprintf(chp, "\r\nChibiOS/RT Shell\r\n");
+@@ -183,11 +188,13 @@
+           list_commands(chp, scp);
+         chprintf(chp, "\r\n");
+       }
+-      else if (cmdexec(local_commands, chp, cmd, n, args) &&
+-          ((scp == NULL) || cmdexec(scp, chp, cmd, n, args))) {
++      else if (cmdexec(local_commands, chp, cmd, n, args, &cont) &&
++          ((scp == NULL) || cmdexec(scp, chp, cmd, n, args, &cont))) {
+         chprintf(chp, "%s", cmd);
+         chprintf(chp, " ?\r\n");
+       }
++      if(cont == SHELL_CMD_EXIT)
++        break;
+     }
+   }
+   /* Atomically broadcasting the event source and terminating the thread,
+Index: os/various/shell.h
+===================================================================
+--- os/various/shell.h	(Revision 6305)
++++ os/various/shell.h	(Arbeitskopie)
+@@ -40,9 +40,19 @@
+ #endif
+ 
+ /**
++ * @brief   The shell will terminate when a command returns this.
++ */
++#define SHELL_CMD_EXIT              0
++
++/**
++ * @brief   The shell continues to run when a command returns this.
++ */
++#define SHELL_CMD_CONTINUE          1
++
++/**
+  * @brief   Command handler function type.
+  */
+-typedef void (*shellcmd_t)(BaseSequentialStream *chp, int argc, char *argv[]);
++typedef int8_t (*shellcmd_t)(BaseSequentialStream *chp, int argc, char *argv[]);
+ 
+ /**
+  * @brief   Custom command entry type.
diff --git a/software/mpu/Makefile b/software/mpu/Makefile
index a690ead..0b6e58f 100644
--- a/software/mpu/Makefile
+++ b/software/mpu/Makefile
@@ -66,6 +66,8 @@ ifeq ($(MCU),cortex-m4)
   endif
 endif
 
+BUILDDIR = build-$(MURSAT_TRGT)
+
 # Enable this if you really want to use the STM FWLib.
 ifeq ($(USE_FWLIB),)
   USE_FWLIB = no
diff --git a/software/mpu/usb-cdc-shell.c b/software/mpu/usb-cdc-shell.c
index c36ca19..ce62ce4 100644
--- a/software/mpu/usb-cdc-shell.c
+++ b/software/mpu/usb-cdc-shell.c
@@ -176,22 +176,24 @@ static int8_t shell_return_code;
 #define SHELL_WA_SIZE   THD_WA_SIZE(2048)
 #define TEST_WA_SIZE    THD_WA_SIZE(256)
 
-static void cmd_mem(BaseSequentialStream *chp, int argc, char *argv[])
+static int8_t cmd_mem(BaseSequentialStream *chp, int argc, char *argv[])
 {
   size_t n, size;
 
   (void)argv;
   if (argc > 0) {
     chprintf(chp, "Usage: mem\r\n");
-    return;
+    return SHELL_CMD_CONTINUE;
   }
   n = chHeapStatus(NULL, &size);
   chprintf(chp, "core free memory : %u bytes\r\n", chCoreStatus());
   chprintf(chp, "heap fragments   : %u\r\n", n);
   chprintf(chp, "heap free total  : %u bytes\r\n", size);
+
+  return SHELL_CMD_CONTINUE;
 }
 
-static void cmd_threads(BaseSequentialStream *chp, int argc, char *argv[])
+static int8_t cmd_threads(BaseSequentialStream *chp, int argc, char *argv[])
 {
   static const char *states[] = {THD_STATE_NAMES};
   Thread *tp;
@@ -199,7 +201,7 @@ static void cmd_threads(BaseSequentialStream *chp, int argc, char *argv[])
   (void)argv;
   if (argc > 0) {
     chprintf(chp, "Usage: threads\r\n");
-    return;
+    return SHELL_CMD_CONTINUE;
   }
   chprintf(chp, "    addr    stack prio refs     state     time name\r\n");
   tp = chRegFirstThread();
@@ -211,60 +213,67 @@ static void cmd_threads(BaseSequentialStream *chp, int argc, char *argv[])
              (tp->p_name == NULL) ? "-" : tp->p_name);
     tp = chRegNextThread(tp);
   } while (tp != NULL);
+
+  return SHELL_CMD_CONTINUE;
 }
 
-static void cmd_test(BaseSequentialStream *chp, int argc, char *argv[])
+static int8_t cmd_test(BaseSequentialStream *chp, int argc, char *argv[])
 {
   Thread *tp;
 
   (void)argv;
   if (argc > 0) {
     chprintf(chp, "Usage: test\r\n");
-    return;
+    return SHELL_CMD_CONTINUE;
   }
   tp = chThdCreateFromHeap(NULL, TEST_WA_SIZE, chThdGetPriority(),
                            TestThread, chp);
   if (tp == NULL) {
     chprintf(chp, "out of memory\r\n");
-    return;
+    return SHELL_CMD_CONTINUE;
   }
   chThdWait(tp);
+
+  return SHELL_CMD_CONTINUE;
 }
 
-static void cmd_halt(BaseSequentialStream *chp, int argc, char *argv[])
+static int8_t cmd_halt(BaseSequentialStream *chp, int argc, char *argv[])
 {
   (void)argv;
   if (argc > 0) {
     chprintf(chp, "Usage: halt\r\n");
-    return;
+    return SHELL_CMD_CONTINUE;
   }
   shell_return_code = MPU_HALT;
   chprintf(chp, "halting system.\r\n");
-      /* TODO: tell shell to terminate - but how??? */
+
+  return SHELL_CMD_EXIT;
 }
 
-static void cmd_reboot(BaseSequentialStream *chp, int argc, char *argv[])
+static int8_t cmd_reboot(BaseSequentialStream *chp, int argc, char *argv[])
 {
   (void)argv;
   if (argc > 0) {
     chprintf(chp, "Usage: reboot\r\n");
-    return;
+    return SHELL_CMD_CONTINUE;
   }
   shell_return_code = MPU_REBOOT;
   chprintf(chp, "rebooting system ...\r\n");
-      /* TODO: tell shell to terminate - but how??? */
+
+  return SHELL_CMD_EXIT;
 }
 
-static void cmd_bootloader(BaseSequentialStream *chp, int argc, char *argv[])
+static int8_t cmd_bootloader(BaseSequentialStream *chp, int argc, char *argv[])
 {
   (void)argv;
   if (argc > 0) {
     chprintf(chp, "Usage: bootloader\r\n");
-    return;
+    return SHELL_CMD_CONTINUE;
   }
   shell_return_code = MPU_BOOTLOADER;
   chprintf(chp, "rebooting to bootloader ...\r\n");
-      /* TODO: tell shell to terminate - but how??? */
+
+  return SHELL_CMD_EXIT;
 }
 
 static const ShellCommand commands[] = {
author	Christian Pointner <equinox@mur.at>	2013-10-01 11:54:58 +0000
committer	Christian Pointner <equinox@mur.at>	2013-10-01 11:54:58 +0000
commit	6a4d1de2083f6412da45b485a51f769726b32202 (patch)
tree	e1ba49306cd9b7a573e4a37cad283575b7ffadaf
parent	implemented system shutdown and reboot (not yet finished) (diff)