Changeset 09bfa38f5e75d239ff955f3201095e75f13df68b

Timestamp:

04/05/07 04:13:01 (6 years ago)

Author:

dsmith <dsmith@…>

Children:

9ef2b8aa3699c1c8aac4ba5a95d932f0b2a74fc1

Parents:

04e0f0ee34ed6e6299d325e7f38f99e66aa7ea29

git-author:

L. Donnie Smith <donnie.smith@…> (04/05/07 04:13:01)

git-committer:

dsmith <dsmith@…> (04/05/07 04:13:01)

Message:

Handle wiimote disconnect/Bluetooth error gracefully (#12)

git-svn-id: http://abstrakraft.org/cwiid/svn/trunk@65 918edb2d-ff29-0410-9de2-eb38e7f22bc7

Files:

• ChangeLog (modified) (1 diff)
• wiimote/connect.c (modified) (6 diffs)
• wiimote/event.c (modified) (21 diffs)
• wiimote/queue.c (modified) (3 diffs)
• wiimote/queue.h (modified) (2 diffs)
• wiimote/rw.c (modified) (10 diffs)
• wiimote/wiimote.h (modified) (5 diffs)
• wiimote/wiimote_internal.h (modified) (3 diffs)
• wmdemo/wmdemo.c (modified) (3 diffs)
• wmgui/main.c (modified) (2 diffs)
• wminput/main.c (modified) (3 diffs)

ChangeLog

@@ -3 +3 @@
         * removed --noyywrap from lex
 
+        wiimote
+        * added queue_flush
+        * reimplemented queue_queue with queue_flush
+        * added wiimote_mesg_error message type
+        * moved RW error state to separate wiimote member
+        * updated wiimote_read and wiimote_write to trigger and detect rw_error
+        * cancel rw operations from wiimote_disconnect
+        * implemented process_error to handle socket read errors
+        * added rw_status triggers to read and write handlers
+
+        wmdemo
+        * made wiimote handle global
+        * disconnect and exit on wiimote_mesg_error
+
+        wmgui
+        * disconnect on wiimote_mesg_error
+
+        wminput
+        * exit on wiimote_mesg_error
+
+2007-04-03 L. Donnie Smith <cwiid@abstrakraft.org>
         wiimote
         * fixed wiimote_find_wiimote seg fault

wiimote/connect.c

@@ -16 +16 @@
  *
  *  ChangeLog:
+ *  04/04/2007: L. Donnie Smith <cwiid@abstrakraft.org>
+ *  * cancel rw operations from wiimote_disconnect
+ *
  *  04/01/2007: L. Donnie Smith <cwiid@abstrakraft.org>
  *  * wiimote_connect now takes a pointer to bdaddr_t
@@ -84 +87 @@
         if (bacmp(bdaddr, BDADDR_ANY) == 0) {
                 if (wiimote_find_wiimote(bdaddr, 2)) {
-                        /* TODO: wiimote functions should print their own errors */
-                        wiimote_err(wiimote, "Unable to find wiimote");
                         goto ERR_HND;
                 }
@@ -144 +145 @@
         /* Set rw_status before interrupt thread */
         wiimote->rw_status = RW_NONE;
+        wiimote->rw_error = 0;
 
         /* Launch interrupt channel listener and dispatch threads */
@@ -197 +199 @@
         /* Cancel and join int_thread */
         if (pthread_cancel(wiimote->int_listen_thread)) {
-                wiimote_err(wiimote, "Error canceling int_listen_thread");
+                /* int could exit on it's own, so we don't care */
+                /* wiimote_err(wiimote, "Error canceling int_listen_thread"); */
         }
         else {
@@ -208 +211 @@
                 }
         }
-        /* TODO: cancel RW operations if they are in progress */
+
+        /* Cancel any RW operations in progress */
+        wiimote->rw_error = 1;
+        if (pthread_mutex_lock(&wiimote->rw_cond_mutex)) {
+                wiimote_err(wiimote, "Error locking rw_cond_mutex: deadlock warning");
+        }
+        else {
+                if (pthread_cond_signal(&wiimote->rw_cond)) {
+                        wiimote_err(wiimote, "Error signaling rw_cond: deadlock warning");
+                }
+                if (pthread_mutex_unlock(
+                  &wiimote->rw_cond_mutex)) {
+                        wiimote_err(wiimote, "Error unlocking rw_cond_mutex");
+                }
+        }
+
         /* Cancel and detach dispatch_thread */
         /* We detach to decouple dispatch (which runs the callback) from wiimote
@@ -227 +245 @@
         }
 
+        /* TODO: We have no way of telling if all in flight rw operations
+         * have exited yet, so for now, user must verify that all have returned
+         * before calling disconnect */
+
         /* Destroy sync variables */
         if (pthread_mutex_destroy(&wiimote->wiimote_mutex)) {

wiimote/event.c

@@ -16 +16 @@
  *
  *  ChangeLog:
+ *  04/04/2007: L. Donnie Smith <cwiid@abstrakraft.org>
+ *  * implemented process_error to handle socket read errors
+ *  * added rw_status triggers to read and write handlers
+ *
  *  03/14/2007: L. Donnie Smith <cwiid@abstrakraft.org>
  *  * audit error checking
@@ -102 +106 @@
  * placed at the end of mesg_array. */
 
+static int process_error(struct wiimote *, size_t);
 static int process_status(struct wiimote *, const unsigned char *,
                           struct mesg_array *);
@@ -131 +136 @@
         do {
                 /* Read packet */
-                if ((len = read(wiimote->int_socket, buf, READ_BUF_LEN)) == -1) {
-                        wiimote_err(wiimote, "Interrupt channel read error");
-                        /* TODO: return ? */
+                len = read(wiimote->int_socket, buf, READ_BUF_LEN);
+                if ((len == -1) || (len == 0)) {
+                        process_error(wiimote, len);
+                        /* Quit! */
+                        break;
                 }
                 else {
@@ -162 +169 @@
                                 case RPT_STATUS:
                                         if (process_status(wiimote, &buf[2], mesg_array)) {
-                                                err = -1;
+                                                err = 1;
                                         }
                                         break;
                                 case RPT_BTN:
                                         if (process_btn(wiimote, &buf[2], mesg_array)) {
-                                                err = -1;
+                                                err = 1;
                                         }
                                         break;
@@ -173 +180 @@
                                         if (process_btn(wiimote, &buf[2], mesg_array) ||
                                           process_acc(wiimote, &buf[4], mesg_array)) {
-                                                err = -1;
+                                                err = 1;
                                         }
                                         break;
@@ -179 +186 @@
                                         if (process_btn(wiimote, &buf[2], mesg_array) ||
                                           process_ext(wiimote, &buf[4], 8, mesg_array)) {
-                                                err = -1;
+                                                err = 1;
                                         }
                                         break;
@@ -186 +193 @@
                                           process_acc(wiimote, &buf[4], mesg_array) ||
                                           process_ir12(wiimote, &buf[7], mesg_array)) {
-                                                err = -1;
+                                                err = 1;
                                         }
                                         break;
@@ -192 +199 @@
                                         if (process_btn(wiimote, &buf[2], mesg_array) ||
                                           process_ext(wiimote, &buf[4], 19, mesg_array)) {
-                                                err = -1;
+                                                err = 1;
                                         }
                                         break;
@@ -199 +206 @@
                                           process_acc(wiimote, &buf[4], mesg_array) ||
                                           process_ext(wiimote, &buf[7], 16, mesg_array)) {
-                                                err = -1;
+                                                err = 1;
                                         }
                                         break;
@@ -206 +213 @@
                                           process_ir10(wiimote, &buf[4], mesg_array) ||
                                           process_ext(wiimote, &buf[14], 9, mesg_array)) {
-                                                err = -1;
+                                                err = 1;
                                         }
                                         break;
@@ -214 +221 @@
                                           process_ir10(wiimote, &buf[7], mesg_array) ||
                                           process_ext(wiimote, &buf[17], 6, mesg_array)) {
-                                                err = -1;
+                                                err = 1;
                                         }
                                         break;
                                 case RPT_EXT21:
                                         if (process_ext(wiimote, &buf[2], 21, mesg_array)) {
-                                                err = -1;
+                                                err = 1;
                                         }
                                         break;
@@ -230 +237 @@
                                         if (queue_queue(wiimote->dispatch_queue, mesg_array)) {
                                                 free_mesg_array(mesg_array);
-                                                wiimote_err(wiimote,
-                                                            "error dispatching mesg array");
+                                                wiimote_err(wiimote, "error dispatching mesg array");
                                         }
                                 }
@@ -254 +260 @@
         } while (-1);
 
-        /* This should never execute */
         return NULL;
+}
+
+static int process_error(struct wiimote *wiimote, size_t len)
+{
+        struct mesg_array *mesg_array;
+        struct wiimote_error_mesg *error_mesg;
+        int ret = 0;
+
+        /* Error message */
+        if (len == 0) {
+                wiimote_err(wiimote, "Disconnect");
+        }
+        else {
+                wiimote_err(wiimote, "Interrupt channel read error");
+        }
+
+        if ((mesg_array = malloc(sizeof *mesg_array)) == NULL) {
+                wiimote_err(wiimote, "Error allocating mesg array");
+                ret = -1;
+                goto SKIP_QUEUE_MESG;
+        }
+        mesg_array->count = 1;
+        if ((error_mesg = malloc(sizeof *error_mesg)) == NULL) {
+                wiimote_err(wiimote, "Error allocating error message");
+                ret = -1;
+                goto SKIP_QUEUE_MESG;
+        }
+        error_mesg->type = WIIMOTE_MESG_ERROR;
+        if (len == 0) {
+                error_mesg->error = WIIMOTE_ERROR_DISCONNECT;
+        }
+        else {
+                error_mesg->error = WIIMOTE_ERROR_COMM;
+        }
+        mesg_array->mesg[0] = error_mesg;
+        if (queue_flush(wiimote->dispatch_queue, (free_func_t *)free_mesg_array)) {
+                wiimote_err(wiimote, "error flushing dispatch queue");
+                ret = -1;
+        }
+        if (queue_queue(wiimote->dispatch_queue, mesg_array)) {
+                free_mesg_array(mesg_array);
+                wiimote_err(wiimote, "error dispatching mesg array");
+                ret = -1;
+        }
+
+SKIP_QUEUE_MESG:
+
+        /* Cancel any RW operations in progress */
+        wiimote->rw_error = 1;
+        if (pthread_mutex_lock(&wiimote->rw_cond_mutex)) {
+                wiimote_err(wiimote, "Error locking rw_cond_mutex: deadlock warning");
+                ret = -1;
+        }
+        else {
+                if (pthread_cond_signal(&wiimote->rw_cond)) {
+                        wiimote_err(wiimote, "Error signaling rw_cond: deadlock warning");
+                        ret = -1;
+                }
+                if (pthread_mutex_unlock(
+                  &wiimote->rw_cond_mutex)) {
+                        wiimote_err(wiimote, "Error unlocking rw_cond_mutex: "
+                                    "deadlock warning");
+                        ret = -1;
+                }
+        }
+
+        return ret;
 }
 
@@ -497 +569 @@
                   error) {
                         wiimote_err(wiimote, "Error in read data");
-                        wiimote->rw_status = RW_ERROR;
+                        wiimote->rw_error = 1;
+                        wiimote->rw_status = RW_NONE;
                         ret = -1;
                 }
@@ -510 +583 @@
                         }
                 }
-                if (wiimote->rw_status != RW_PENDING) {
+                if (wiimote->rw_error || (wiimote->rw_status != RW_PENDING)) {
                         /* Lock rw_cond_mutex, signal rw_cond, unlock
                          * rw_cond_mutex */
                         if (pthread_mutex_lock(&wiimote->rw_cond_mutex)) {
-                                wiimote_err(wiimote, "Error locking rw_cond_mutex");
+                                wiimote_err(wiimote, "Error locking rw_cond_mutex: "
+                                            "deadlock warning");
+                                wiimote->rw_error = 1;
                                 ret = -1;
                         }
@@ -521 +596 @@
                                         wiimote_err(wiimote, "Error signaling rw_cond: "
                                                     "deadlock warning");
+                                        wiimote->rw_error = 1;
                                         ret = -1;
                                 }
@@ -527 +603 @@
                                         wiimote_err(wiimote, "Error unlocking rw_cond_mutex: "
                                                 "deadlock warning");
+                                        wiimote->rw_error = 1;
                                         ret = -1;
                                 }
@@ -534 +611 @@
         else {
                 wiimote_err(wiimote, "Extraneous read data received");
-                ret = 1;
+                ret = -1;
         }
 
@@ -549 +626 @@
                  * write_cond_mutex */
                 if (pthread_mutex_lock(&wiimote->rw_cond_mutex)) {
-                        wiimote_err(wiimote, "Error locking rw_cond_mutex");
+                        wiimote_err(wiimote, "Error locking rw_cond_mutex: "
+                                    "deadlock warning");
+                        wiimote->rw_error = 1;
                         ret = -1;
                 }
@@ -556 +635 @@
                                 wiimote_err(wiimote, "Error signaling rw_cond: "
                                             "deadlock warning");
+                                wiimote->rw_error = 1;
                                 ret = -1;
                         }
@@ -561 +641 @@
                                 wiimote_err(wiimote, "Error unlocking rw_cond_mutex: "
                                     "deadlock warning");
+                                wiimote->rw_error = 1;
                                 ret = -1;
                         }

wiimote/queue.c

@@ -16 +16 @@
  *
  *  ChangeLog:
+ *  04/04/2007: L. Donnie Smith <cwiid@abstrakraft.org>
+ *  * Added queue_flush
+ *  * Reimplemented queue_free using queue_flush
+ *
  *  03/14/2007: L. Donnie Smith <cwiid@abstrakraft.org>
  *  * audited error checking (coda and error handler sections)
@@ -58 +62 @@
 {
         int ret = 0;
+
+        if (queue_flush(queue, free_func)) {
+                ret = -1;
+        }
+        if (pthread_mutex_destroy(&queue->mutex)) {
+                ret = -1;
+        }
+        if (pthread_cond_destroy(&queue->cond)) {
+                ret = -1;
+        }
+        if (pthread_mutex_destroy(&queue->cond_mutex)) {
+                ret = -1;
+        }
+
+        free(queue);
+
+        return ret;
+}
+
+int queue_flush(struct queue *queue, free_func_t free_func)
+{
         struct queue_node *cursor, *tmp;
-
-        if (pthread_mutex_destroy(&queue->mutex)) {
-                ret = -1;
-        }
-        if (pthread_cond_destroy(&queue->cond)) {
-                ret = -1;
-        }
-        if (pthread_mutex_destroy(&queue->cond_mutex)) {
-                ret = -1;
+        int ret = 0;
+        int canceltype;
+
+        if (pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, &canceltype)) {
+                return -1;
+        }
+
+        if (pthread_mutex_lock(&queue->mutex)) {
+                ret = -1;
+                goto CODA;
         }
 
@@ -79 +105 @@
                 cursor = tmp;
         }
-
-        free(queue);
+        queue->head = NULL;
+        queue->p_tail = &queue->head;
+
+        if (pthread_mutex_unlock(&queue->mutex)) {
+                ret = -1;
+                goto CODA;
+        }
+
+CODA:
+        if (pthread_setcanceltype(canceltype, &canceltype)) {
+                return -1;
+        }
 
         return ret;

wiimote/queue.h

@@ -16 +16 @@
  *
  *  ChangeLog:
+ *  04/04/2007: L. Donnie Smith >cwiid@abstrakraft.org>
+ *  * Added queue_flush prototype
+ *
  *  03/03/2007: L. Donnie Smith <cwiid@abstrakraft.org>
  *  * Initial ChangeLog
@@ -41 +44 @@
 
 struct queue *queue_new();
+int queue_flush(struct queue *queue, free_func_t free_func);
 int queue_free(struct queue *queue, free_func_t free_func);
 int queue_queue(struct queue *queue, void *data);

wiimote/rw.c

@@ -16 +16 @@
  *
  *  ChangeLog:
+ *  04/04/2007: L. Donnie Smith <cwiid@abstrakraft.org>
+ *  * updated wiimote_read and wiimote_write to trigger and detect rw_error
+ *
  *  03/14/2007: L. Donnie Smith <cwiid@abstrakraft.org>
  *  * wiimote_read - changed to obey decode flag only for register read
@@ -57 +60 @@
         int ret = 0;
         int i;
-        uint8_t address_flags;
-
-        /* Lock wiimote rw access */
-        if (pthread_mutex_lock(&wiimote->rw_mutex)) {
-                wiimote_err(wiimote, "Error locking rw_mutex");
+
+        /* TODO: once this code has been tested, check for rw_error before printing
+         * error messages */
+
+        /* Exit immediately if rw_error */
+        if (wiimote->rw_error) {
                 return -1;
         }
 
-        address_flags = flags & (WIIMOTE_RW_EEPROM | WIIMOTE_RW_REG);
-
         /* Compose read request packet */
-        buf[0]=address_flags;
+        buf[0]=flags & (WIIMOTE_RW_EEPROM | WIIMOTE_RW_REG);
         buf[1]=(unsigned char)((offset>>16) & 0xFF);
         buf[2]=(unsigned char)((offset>>8) & 0xFF);
@@ -75 +77 @@
         buf[5]=(unsigned char)(len & 0xFF);
 
+
+        /* Lock wiimote rw access */
+        if (pthread_mutex_lock(&wiimote->rw_mutex)) {
+                wiimote_err(wiimote, "Error locking rw_mutex");
+                return -1;
+        }
+
+        /* Check for rw_error after mutex wait */
+        if (wiimote->rw_error) {
+                ret = -1;
+                goto CODA;
+        }
+
         /* Setup read info */
         wiimote->rw_status = RW_PENDING;
@@ -85 +100 @@
                 wiimote_err(wiimote, "Error sending read request");
                 ret = -1;
-        }
+                goto CODA;
+        }
+
         /* Lock rw_cond_mutex  */
-        else if (pthread_mutex_lock(&wiimote->rw_cond_mutex)) {
+        if (pthread_mutex_lock(&wiimote->rw_cond_mutex)) {
                 wiimote_err(wiimote, "Error locking rw_cond_mutex");
                 ret = -1;
-        }
-        else {
-                /* Wait on condition, signalled by wiimote_int_listen */
-                while ((!ret) && (wiimote->rw_status == RW_PENDING)) {
-                        if (pthread_cond_wait(&wiimote->rw_cond,
-                                              &wiimote->rw_cond_mutex)) {
-                                wiimote_err(wiimote, "Error waiting on rw_cond");
-                                ret = -1;
-                        }
-                }
-                /* Unlock rw_cond_mutex */
-                if (pthread_mutex_unlock(&wiimote->rw_cond_mutex)) {
-                        wiimote_err(wiimote,
-                                    "Error unlocking rw_cond_mutex: deadlock warning");
-                }
-
-                /* Check status */
-                if (wiimote->rw_status == RW_READY) {
-                        ret = 0;
-                }
-                else {
+                goto CODA;
+        }
+        /* Wait on condition, signalled by int_listen */
+        while (!wiimote->rw_error && !ret && (wiimote->rw_status == RW_PENDING)) {
+                if (pthread_cond_wait(&wiimote->rw_cond,
+                                      &wiimote->rw_cond_mutex)) {
+                        wiimote_err(wiimote, "Error waiting on rw_cond");
                         ret = -1;
-                }
-        }
-
+                        /* can't goto CODA from here - unlock rw_cond_mutex first */
+                }
+        }
+        /* Unlock rw_cond_mutex */
+        if (pthread_mutex_unlock(&wiimote->rw_cond_mutex)) {
+                wiimote_err(wiimote, "Error unlocking rw_cond_mutex");
+                wiimote->rw_error = 1;
+                ret = -1;
+                goto CODA;
+        }
+
+        /* Check status */
+        if (wiimote->rw_status != RW_READY) {
+                ret = -1;
+        }
+
+CODA:
         /* Clear rw_status */
         wiimote->rw_status = RW_NONE;
@@ -121 +138 @@
         if (pthread_mutex_unlock(&wiimote->rw_mutex)) {
                 wiimote_err(wiimote, "Error unlocking rw_mutex: deadlock warning");
-        }
-
-        /* Decode only for registers */
-        if ((flags & WIIMOTE_RW_DECODE) && (flags & WIIMOTE_RW_REG)) {
+                wiimote->rw_error = 1;
+        }
+
+        /* Decode (only for register reads) */
+        if ((ret == 0) && (flags & WIIMOTE_RW_DECODE) &&
+          (flags & WIIMOTE_RW_REG)) {
                 for (i=0; i < len; i++) {
                         ((unsigned char *)data)[i] = DECODE(((unsigned char *)data)[i]);
@@ -141 +160 @@
         int ret = 0;
 
+        /* TODO: once this code has been tested, check for rw_error before printing
+         * error messages */
+
+        /* Exit immediately if rw_error */
+        if (wiimote->rw_error) {
+                return -1;
+        }
+
+        /* Compose write packet header */
+        buf[0]=flags;
+
         /* Lock wiimote rw access */
         if (pthread_mutex_lock(&wiimote->rw_mutex)) {
@@ -147 +177 @@
         }
 
-        /* Compose write packet header */
-        buf[0]=flags;
-
         /* Send packets */
-        while (!ret && (sent<len)) {
+        /* Check rw_error after mutex wait */
+        while (!wiimote->rw_error && (sent<len)) {
+                wiimote->rw_status = RW_PENDING;
+
+                /* Compose write packet */
                 buf[1]=(unsigned char)(((offset+sent)>>16) & 0xFF);
                 buf[2]=(unsigned char)(((offset+sent)>>8) & 0xFF);
@@ -162 +193 @@
                 }
                 memcpy(buf+5, data+sent, buf[4]);
-                wiimote->rw_status = RW_PENDING;
+
                 if (send_report(wiimote, 0, RPT_WRITE, RPT_WRITE_LEN, buf)) {
                         wiimote_err(wiimote, "Error sending write");
                         ret = -1;
+                        goto CODA;
                 }
                 /* Lock rw_cond_mutex  */
@@ -171 +203 @@
                         wiimote_err(wiimote, "Error locking rw_cond_mutex");
                         ret = -1;
+                        goto CODA;
                 }
                 else {
                         /* Wait on condition, signalled by wiimote_int_listen */
-                        while ((!ret) && (wiimote->rw_status == RW_PENDING)) {
+                        while (!wiimote->rw_error && !ret &&
+                          (wiimote->rw_status == RW_PENDING)) {
                                 if (pthread_cond_wait(&wiimote->rw_cond,
                                                       &wiimote->rw_cond_mutex)) {
                                         wiimote_err(wiimote, "Error waiting on rw_cond");
                                         ret = -1;
+                                        /* can't goto CODA from here -
+                                         * unlock rw_cond_mutex first */
                                 }
                         }
                         /* Unlock rw_cond_mutex */
                         if (pthread_mutex_unlock(&wiimote->rw_cond_mutex)) {
-                                wiimote_err(wiimote,
-                                            "Error unlocking rw_cond_mutex: deadlock warning");
+                                wiimote_err(wiimote, "Error unlocking rw_cond_mutex");
+                                wiimote->rw_error = 1;
+                                ret = -1;
+                                goto CODA;
                         }
 
+                        /* Check for error from cond_wait */
+                        if (ret == -1) {
+                                goto CODA;
+                        }
+
                         /* Check status */
-                        if (wiimote->rw_status == RW_READY) {
-                                ret = 0;
+                        if (wiimote->rw_status != RW_READY) {
+                                ret = -1;
+                                goto CODA;
                         }
-                        else {
-                                ret = -1;
-                        }
                 }
                 sent+=buf[4];
         }
 
+CODA:
         /* Clear rw_status */
         wiimote->rw_status = RW_NONE;
@@ -204 +246 @@
         if (pthread_mutex_unlock(&wiimote->rw_mutex)) {
                 wiimote_err(wiimote, "Error unlocking rw_mutex: deadlock warning");
+                wiimote->rw_error = 1;
         }
 

wiimote/wiimote.h

@@ -16 +16 @@
  *
  *  ChangeLog:
+ *  04/04/2007: L. Donnie Smith <cwiid@abstrakraft.org>
+ *  * added wiimote_mesg_error message type
+ *
  *  04/01/2007: L. Donnie Smith <cwiid@abstrakraft.org>
  *  * wiimote_connect now takes a pointer to bdaddr_t
@@ -125 +128 @@
         WIIMOTE_MESG_NUNCHUK,
         WIIMOTE_MESG_CLASSIC,
+        WIIMOTE_MESG_ERROR,
         WIIMOTE_MESG_UNKNOWN
 };
@@ -133 +137 @@
         WIIMOTE_EXT_CLASSIC,
         WIIMOTE_EXT_UNKNOWN
+};
+
+enum wiimote_error {
+        WIIMOTE_ERROR_DISCONNECT,
+        WIIMOTE_ERROR_COMM,
 };
 
@@ -186 +195 @@
 };
 
+struct wiimote_error_mesg {
+        enum wiimote_mesg_type type;
+        enum wiimote_error error;
+};
+
 union wiimote_mesg {
         enum wiimote_mesg_type type;
@@ -194 +208 @@
         struct wiimote_nunchuk_mesg nunchuk_mesg;
         struct wiimote_classic_mesg classic_mesg;
+        struct wiimote_error_mesg error_mesg;
 };
 

wiimote/wiimote_internal.h

@@ -16 +16 @@
  *
  *  ChangeLog:
+ *  04/04/2007: L. Donnie Smith <cwiid@abstrakraft.org>
+ *  * moved RW error state to separate member
+ *
  *  04/01/2007: L. Donnie Smith <cwiid@abstrakraft.org>
  *  * removed WIIMOTE_CMP_LEN macro and wiimote_findfirst prototype
@@ -132 +135 @@
         RW_NONE,
         RW_PENDING,
-        RW_READY,
-        RW_ERROR
+        RW_READY
 };
 
@@ -158 +160 @@
         pthread_mutex_t rw_cond_mutex;
         enum rw_status rw_status;
+        char rw_error;
         void *read_buf;
         uint16_t read_len;

wmdemo/wmdemo.c

@@ -1 +1 @@
 #include <stdarg.h>
 #include <stdio.h>
+#include <stdlib.h>
 
 #include <wiimote.h>
@@ -36 +37 @@
 }
 
+/* wiimote handle */
+wiimote_t *wiimote;
+
 int main(int argc, char *argv[])
 {
         bdaddr_t bdaddr;        /* bluetooth device address */
-        wiimote_t *wiimote;     /* wiimote handle */
         int wiimote_id;         /* wiimote id: useful for handling multiple wiimotes
                                with a single callback */
@@ -237 +240 @@
                                mesg[i]->classic_mesg.l, mesg[i]->classic_mesg.r);
                         break;
+                case WIIMOTE_MESG_ERROR:
+                        if (wiimote_disconnect(wiimote)) {
+                                fprintf(stderr, "Error on wiimote disconnect\n");
+                                exit(-1);
+                        }
+                        exit(0);
+                        break;
                 default:
                         printf("Unknown Report");

wmgui/main.c

@@ -16 +16 @@
  *
  *  ChangeLog:
+ *  04/04/2007 L. Donnie Smith <cwiid@abstrakraft.org>
+ *  * disconnect on wiimote_mesg_error
+ *
  *  04/03/2007 L. Donnie Smith <cwiid@abstrakraft.org>
  *  * commented custom wiimote_err (causing Xlib errors)
@@ -1059 +1062 @@
                         wiimote_classic(&mesg_array[i]->classic_mesg);
                         break;
+                case WIIMOTE_MESG_ERROR:
+                        menuDisconnect_activate();
+                        break;
                 default:
                         break;

wminput/main.c

@@ -16 +16 @@
  *
  *  ChangeLog:
- *  03/03/2007 L. Donnie Smith <cwiid@abstrakraft.rg>
+ *  04/04/2007 L. Donnie Smith <cwiid@abstrakraft.org>
+ *  * exit on wiimote_error
+ *
+ *  03/03/2007 L. Donnie Smith <cwiid@abstrakraft.org>
  *  * Initial ChangeLog
  *  * type audit (stdint, const, char booleans)
@@ -27 +30 @@
 #include <pthread.h>
 #include <signal.h>
+#include <sys/types.h>
 #include <unistd.h>
 
@@ -266 +270 @@
                         process_classic_mesg((struct wiimote_classic_mesg *) mesg[i]);
                         break;
+                case WIIMOTE_MESG_ERROR:
+                        if (kill(getpid(),SIGINT)) {
+                                wminput_err("error sending SIGINT");
+                        }
+                        break;
                 default:
                         break;