Make keypad select/poll'able

This allows a small wrapper class to be written
```py
class AsyncEventQueue:
    def __init__(self, events):
        self._events = events

    async def __await__(self):
        yield asyncio.core._io_queue.queue_read(self._events)
        return self._events.get()

    def __enter__(self):
        return self

    def __exit__(self, exc_type, exc_value, traceback):
        pass

```
and used to just "await" the next event:
```py
async def key_task():
    print("waiting for keypresses")
    with keypad.KeyMatrix([board.D4], [board.D5]) as keys, AsyncEventQueue(keys.events) as ev:
        while True:
            print(await ev)
```

Author: jepler

shared-bindings/keypad/EventQueue.c

@@ -24,8 +24,11 @@
  * THE SOFTWARE.
  */
 
+#include "py/ioctl.h"
+#include "py/mperrno.h"
 #include "py/objproperty.h"
 #include "py/runtime.h"
+#include "py/stream.h"
 #include "shared-bindings/keypad/Event.h"
 #include "shared-bindings/keypad/EventQueue.h"
 
@@ -141,12 +144,44 @@ STATIC const mp_rom_map_elem_t keypad_eventqueue_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(keypad_eventqueue_locals_dict, keypad_eventqueue_locals_dict_table);
 
+#if MICROPY_PY_USELECT
+STATIC mp_uint_t eventqueue_ioctl(mp_obj_t self_in, mp_uint_t request, uintptr_t arg, int *errcode) {
+    (void)errcode;
+    keypad_eventqueue_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    switch (request) {
+        case MP_STREAM_POLL: {
+            mp_uint_t flags = arg;
+            mp_uint_t ret = 0;
+            if ((flags & MP_IOCTL_POLL_RD) && common_hal_keypad_eventqueue_get_available(self)) {
+                ret |= MP_IOCTL_POLL_RD;
+            }
+            return ret;
+        }
+        default:
+            *errcode = MP_EINVAL;
+            return MP_STREAM_ERROR;
+    }
+}
+
+STATIC const mp_stream_p_t eventqueue_p = {
+    MP_PROTO_IMPLEMENT(MP_QSTR_protocol_stream)
+    .read = NULL,
+    .write = NULL,
+    .ioctl = eventqueue_ioctl,
+    .is_text = true,
+};
+#endif
+
+
 const mp_obj_type_t keypad_eventqueue_type = {
     { &mp_type_type },
     .flags = MP_TYPE_FLAG_EXTENDED,
     .name = MP_QSTR_EventQueue,
     MP_TYPE_EXTENDED_FIELDS(
         .unary_op = keypad_eventqueue_unary_op,
+        #if MICROPY_PY_USELECT
+        .protocol = &eventqueue_p,
+        #endif
         ),
     .locals_dict = (mp_obj_t)&keypad_eventqueue_locals_dict,
 };

shared-bindings/keypad/EventQueue.h

@@ -41,5 +41,6 @@ bool common_hal_keypad_eventqueue_get_into(keypad_eventqueue_obj_t *self, keypad
 
 bool common_hal_keypad_eventqueue_get_overflowed(keypad_eventqueue_obj_t *self);
 void common_hal_keypad_eventqueue_set_overflowed(keypad_eventqueue_obj_t *self, bool overflowed);
+bool common_hal_keypad_eventqueue_get_available(keypad_eventqueue_obj_t *self);
 
 #endif  // MICROPY_INCLUDED_SHARED_BINDINGS_KEYPAD_EVENTQUEUE_H

shared-module/keypad/EventQueue.c

@@ -96,3 +96,8 @@ bool keypad_eventqueue_record(keypad_eventqueue_obj_t *self, mp_uint_t key_numbe
 
     return true;
 }
+
+bool common_hal_keypad_eventqueue_get_available(keypad_eventqueue_obj_t *self) {
+    int encoded_event = ringbuf_peek16(&self->encoded_events);
+    return encoded_event != -1;
+}