Preliminary Giga Touch support on Zephyr

Zephyr: Added in our preliminary support for touch on the display

In ArduinoCore-zephyr added a callback to register with the
input class.  When set it simply forwards the callbacks to
this function.

Then added some support.  We still don't have things like
gestures as I don't think the zephyr input class has support
for it.

Have a simple touch paint sketch (now supporting multiple
touches, that appears to work

Author: KurtE

src/Arduino_GigaDisplayTouch.cpp

@@ -22,6 +22,123 @@
  * @brief Source file for the Arduino Giga Display Touch library.
  */
 
+
+#ifdef __ZEPHYR__
+/*
+ * Copyright 2023 Arduino SA
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+/**
+ * @file Arduino_GigaDisplayTouch.cpp
+ * @author Leonardo Cavagnis
+ * @brief Source file for the Arduino Giga Display Touch library.
+ */
+
+ /* Includes -----------------------------------------------------------------*/
+#include "Arduino_GigaDisplayTouch.h"
+
+#include <zephyr/kernel.h>
+#include <zephyr/device.h>
+#include <zephyr/input/input.h>
+#include <zephyr/drivers/display.h>
+#include <zephyr/sys/util.h>
+
+
+
+/* Callbacks from Zephyr ----------------------- */
+
+// Static members defined
+  Arduino_GigaDisplayTouch::touch_point_t Arduino_GigaDisplayTouch::zephyr_touch_points[CONFIG_INPUT_GT911_MAX_TOUCH_POINTS];
+
+  uint8_t Arduino_GigaDisplayTouch::zephyr_touch_cb_slot_num = 0;
+  struct k_sem Arduino_GigaDisplayTouch::zephyr_touch_event_sync;
+
+
+void Arduino_GigaDisplayTouch::touch_event_callback(struct input_event *evt, void *user_data) {
+    UNUSED(user_data);
+    //printk("touch_event_callback(%p %p): %p %u %u %u %d\n", evt, user_data,
+    //        evt->dev, evt->sync, evt->type, evt->code, evt->value);
+    switch(evt->code) {
+    case INPUT_ABS_MT_SLOT:
+        zephyr_touch_cb_slot_num = evt->value;
+        break;        
+    case INPUT_ABS_X:
+        zephyr_touch_points[zephyr_touch_cb_slot_num].x = evt->value;
+        break;
+    case INPUT_ABS_Y:
+        zephyr_touch_points[zephyr_touch_cb_slot_num].y = evt->value;
+        break;
+    case INPUT_BTN_TOUCH:
+        zephyr_touch_points[zephyr_touch_cb_slot_num].pressed = evt->value;
+        break;
+    }
+
+    if (evt->sync) {
+        k_sem_give(&zephyr_touch_event_sync);
+    }
+}
+
+
+/* Functions -----------------------------------------------------------------*/
+Arduino_GigaDisplayTouch::Arduino_GigaDisplayTouch()
+{
+}
+
+Arduino_GigaDisplayTouch::~Arduino_GigaDisplayTouch()
+{
+}
+
+extern "C" void registerGigaTouchCallback(void (*cb)(struct input_event *evt, void *user_data));
+
+bool Arduino_GigaDisplayTouch::begin() {
+    k_sem_init(&zephyr_touch_event_sync, 0, 1);
+    registerGigaTouchCallback(&touch_event_callback);
+    return true;
+}
+
+
+void Arduino_GigaDisplayTouch::end()
+{
+        registerGigaTouchCallback(nullptr);
+}
+
+uint8_t Arduino_GigaDisplayTouch::getTouchPoints(GDTpoint_t* points, uint32_t timeout) {
+
+    // First wait to see if we get any events.    
+    if (k_sem_take(&zephyr_touch_event_sync, timeout? K_MSEC(timeout) : K_NO_WAIT) != 0) return 0;
+
+    uint8_t count_pressed = 0;
+    for (uint8_t i = 0; i <= zephyr_touch_cb_slot_num; i++) {
+        if (zephyr_touch_points[i].pressed) {
+            points[count_pressed].x = zephyr_touch_points[i].x;
+            points[count_pressed].y = zephyr_touch_points[i].y;
+            count_pressed++;
+        } 
+    }
+    return count_pressed;
+}
+
+void Arduino_GigaDisplayTouch::onDetect(void (*handler)(uint8_t, GDTpoint_t*)) {
+    UNUSED(handler);
+}
+
+/**** END OF FILE ****/
+#else
+
  /* Includes -----------------------------------------------------------------*/
 #include "Arduino_GigaDisplayTouch.h"
 
@@ -35,7 +152,7 @@
 
 /* Private variables ---------------------------------------------------------*/
 rtos::Thread t;
-events::EventQueue queue(32 * EVENTS_EVENT_SIZE);  
+events::EventQueue queue(32 * EVENTS_EVENT_SIZE);
 Arduino_GigaDisplayTouch * gThis;
 
 /* Private function prototypes -----------------------------------------------*/
@@ -52,7 +169,7 @@ Arduino_GigaDisplayTouch::Arduino_GigaDisplayTouch(TwoWire& wire, uint8_t intPin
 : _wire{wire}, _intPin{intPin}, _rstPin{rstPin}, _addr{addr}, _irqInt{digitalPinToPinName(intPin)}
 { }
 
-Arduino_GigaDisplayTouch::~Arduino_GigaDisplayTouch() 
+Arduino_GigaDisplayTouch::~Arduino_GigaDisplayTouch()
 { }
 
 bool Arduino_GigaDisplayTouch::begin() {
@@ -143,7 +260,7 @@ void _lvglTouchCb(lv_indev_drv_t * indev, lv_indev_data_t * data) {
 #endif
 #endif
 
-void Arduino_GigaDisplayTouch::end() 
+void Arduino_GigaDisplayTouch::end()
 { }
 
 uint8_t Arduino_GigaDisplayTouch::getTouchPoints(GDTpoint_t* points) {
@@ -159,12 +276,12 @@ uint8_t Arduino_GigaDisplayTouch::getTouchPoints(GDTpoint_t* points) {
     }
 
     for (uint8_t i = 0; i < contacts; i++) {
-        points[i].trackId  = rawpoints[1 + 8*i];	    
+        points[i].trackId  = rawpoints[1 + 8*i];
         points[i].x        = ((uint16_t)rawpoints[3 + 8*i] << 8) + rawpoints[2 + 8*i];
         points[i].y        = ((uint16_t)rawpoints[5 + 8*i] << 8) + rawpoints[4 + 8*i];
         points[i].area     = ((uint16_t)rawpoints[7 + 8*i] << 8) + rawpoints[6 + 8*i];
     }
- 
+
     _gt911WriteOp(GT911_REG_GESTURE_START_POINT, 0); /* Reset buffer status to finish the reading */
 
     return contacts;
@@ -192,7 +309,7 @@ uint8_t Arduino_GigaDisplayTouch::_gt911WriteBytesOp(uint16_t reg, uint8_t * dat
 
     /* Data [0..n] */
     for (uint8_t i = 0; i < len; i++) {
-        _wire.write(data[i]); 
+        _wire.write(data[i]);
     }
 
     status = _wire.endTransmission();
@@ -233,33 +350,35 @@ void Arduino_GigaDisplayTouch::_gt911onIrq() {
     }
 
     for (uint8_t i = 0; i < contacts; i++) {
-        _points[i].trackId  = rawpoints[1 + 8*i];	    
+        _points[i].trackId  = rawpoints[1 + 8*i];
         _points[i].x        = ((uint16_t)rawpoints[3 + 8*i] << 8) + rawpoints[2 + 8*i];
         _points[i].y        = ((uint16_t)rawpoints[5 + 8*i] << 8) + rawpoints[4 + 8*i];
         _points[i].area     = ((uint16_t)rawpoints[7 + 8*i] << 8) + rawpoints[6 + 8*i];
     }
 
     if (contacts > 0 && _gt911TouchHandler != nullptr) _gt911TouchHandler(contacts, _points);
- 
+
     _gt911WriteOp(GT911_REG_GESTURE_START_POINT, 0); /* Reset buffer status to finish the reading */
 }
 
 uint8_t Arduino_GigaDisplayTouch::_gt911ReadInputCoord(uint8_t * pointsbuf, uint8_t& contacts) {
     uint8_t error;
-    
+
     contacts = 0;
     error    = _gt911ReadOp(GT911_REG_GESTURE_START_POINT, pointsbuf, GT911_CONTACT_SIZE * GT911_MAX_CONTACTS);
 
     if (error) {
         return 1; /* I2C comm error */
     }
-    
-    if (!(pointsbuf[0] & 0x80)) {	  
+
+    if (!(pointsbuf[0] & 0x80)) {
         return 2; /* Data buffer not ready */
     }
 
     contacts = pointsbuf[0] & 0xF;
     return 0;
 }
 
+#endif /* zephyr */
+
 /**** END OF FILE ****/

src/Arduino_GigaDisplayTouch.h

@@ -28,6 +28,101 @@
 #ifndef __ARDUINO_GIGADISPLAYTOUCH_H
 #define __ARDUINO_GIGADISPLAYTOUCH_H
 
+#ifdef __ZEPHYR__
+/* Note a lot of this is exact duplicate of the MBed define */
+
+/* Includes ------------------------------------------------------------------*/
+#include <Arduino.h>
+#include "Wire.h"
+//#include "pinDefinitions.h"
+
+/* Exported defines ----------------------------------------------------------*/
+#define GT911_I2C_ADDR_BA_BB    (0x5D | 0x80)  // 0xBA/0xBB - 0x5D (7bit address)
+#define GT911_I2C_ADDR_28_29    (0x14 | 0x80)  // 0x28/0x29 - 0x14 (7bit address)
+
+#define GT911_CONTACT_SIZE      8
+#define GT911_MAX_CONTACTS      5
+
+/* Exported types ------------------------------------------------------------*/
+typedef struct GDTpoint_s GDTpoint_t;
+
+/* Exported enumeration ------------------------------------------------------*/
+
+/* Exported struct -----------------------------------------------------------*/
+
+/**
+ * @brief Struct representing a touch point.
+ */
+struct GDTpoint_s {
+  // 0x814F-0x8156, ... 0x8176 (5 points)
+  uint8_t trackId;
+  uint16_t x;
+  uint16_t y;
+  uint16_t area;
+  uint8_t reserved;
+};
+
+
+/* Class ----------------------------------------------------------------------*/
+
+/**
+ * @class Arduino_GigaDisplayTouch
+ * @brief Class for Giga Display Touch controller driver.
+ */
+class Arduino_GigaDisplayTouch {
+  public:
+      Arduino_GigaDisplayTouch();
+      ~Arduino_GigaDisplayTouch();
+
+
+      /**
+       * @brief Initialize the touch controller.
+       *
+       * @return true If the touch controller is successfully initialized, false Otherwise
+       */
+      bool begin();
+
+      /**
+       * @brief De-initialize the touch controller.
+       */
+      void end();
+
+      /**
+       * @brief Check if a touch event is detected and get the touch points.
+       * @param points The array containing the coordinates of the touch points.
+       * @return uint8_t The number of detected touch points.
+       */
+      uint8_t getTouchPoints(GDTpoint_t* points, uint32_t timeout=0);
+
+      /**
+       * @brief Attach an interrupt handler function for touch detection callbacks.
+       * @param handler The pointer to the user-defined handler function.
+       */
+      void onDetect(void (*handler)(uint8_t, GDTpoint_t*));
+
+
+      /*
+       * @brief Support for callbacks from zephyr
+       */
+      typedef struct {
+          size_t x;
+          size_t y;
+          bool pressed;
+      } touch_point_t;
+
+      static touch_point_t zephyr_touch_points[CONFIG_INPUT_GT911_MAX_TOUCH_POINTS];
+
+      static uint8_t zephyr_touch_cb_slot_num;
+      static struct k_sem zephyr_touch_event_sync;
+
+      static void touch_event_callback(struct input_event *evt, void *user_data);
+
+  protected:
+
+};
+
+#else
+
 /* Includes ------------------------------------------------------------------*/
 #include <Arduino.h>
 #include "Wire.h"
@@ -52,7 +147,7 @@ typedef struct GDTpoint_s GDTpoint_t;
  * @brief Struct representing a touch point.
  */
 struct GDTpoint_s {
-  // 0x814F-0x8156, ... 0x8176 (5 points) 
+  // 0x814F-0x8156, ... 0x8176 (5 points)
   uint8_t trackId;
   uint16_t x;
   uint16_t y;
@@ -67,7 +162,7 @@ struct GDTpoint_s {
  * @brief Class for Giga Display Touch controller driver.
  */
 class Arduino_GigaDisplayTouch {
-  public:  
+  public:
     /**
      * @brief Construct a new touch controller for Giga Display Shield.
      *
@@ -77,19 +172,19 @@ class Arduino_GigaDisplayTouch {
      * @param addr The device address for the touch controller.
      */
     #if defined(ARDUINO_GIGA)
-      Arduino_GigaDisplayTouch(TwoWire& wire  = Wire1, 
+      Arduino_GigaDisplayTouch(TwoWire& wire  = Wire1,
                                uint8_t intPin = PinNameToIndex(PI_1),
-                               uint8_t rstPin = PinNameToIndex(PI_2), 
+                               uint8_t rstPin = PinNameToIndex(PI_2),
                                uint8_t addr   = GT911_I2C_ADDR_BA_BB);
     #elif defined(ARDUINO_PORTENTA_H7_M7)
-      Arduino_GigaDisplayTouch(TwoWire& wire  = Wire, 
+      Arduino_GigaDisplayTouch(TwoWire& wire  = Wire,
                                uint8_t intPin = PinNameToIndex(PD_4),
-                               uint8_t rstPin = PinNameToIndex(PD_5), 
+                               uint8_t rstPin = PinNameToIndex(PD_5),
                                uint8_t addr   = GT911_I2C_ADDR_BA_BB);
-    #else 
-      Arduino_GigaDisplayTouch(TwoWire& wire, 
-                               uint8_t intPin, 
-                               uint8_t rstPin, 
+    #else
+      Arduino_GigaDisplayTouch(TwoWire& wire,
+                               uint8_t intPin,
+                               uint8_t rstPin,
                                uint8_t addr);
     #endif
       ~Arduino_GigaDisplayTouch();
@@ -122,7 +217,7 @@ class Arduino_GigaDisplayTouch {
   private:
       TwoWire&          _wire;
       uint8_t           _intPin;
-      mbed::InterruptIn _irqInt; 
+      mbed::InterruptIn _irqInt;
       uint8_t           _rstPin;
       uint8_t           _addr;
       GDTpoint_t        _points[GT911_MAX_CONTACTS];
@@ -135,4 +230,6 @@ class Arduino_GigaDisplayTouch {
       uint8_t   _gt911ReadInputCoord(uint8_t * pointsbuf, uint8_t& contacts);
 };
 
+#endif /* Zephyr */
+
 #endif /* __ARDUINO_GIGADISPLAYTOUCH_H */