Input_gt911 - multiple touch and maybe gestures

[KurtE]

I have been experimenting with the input_gt911 device using the Arduino GIGA with the Giga display shield using the Arduino Zephyr setup. In their code I added the input_gt911 input callback code into their fixup.c, which then looks to see if an Arduino sketch (or library) registers a callback function, if so the one in fixup.c will forward the callbacks...

I now have the single finger touch paint sketch reasonably working.

So then I wondered about adding multiple touch support. I edited the config file for the GIGA under the display shield and set:
CONFIG_INPUT_GT911_MAX_TOUCH_POINTS =3

Rebuilt zephyr flashed my giga. rebuilt the sketch... And the touch still worked. But wondered how to detect if I have
multiple fingers touching...

I was using, code similar to the input example sketch which looks like:

void Arduino_GigaDisplayTouch::touch_event_callback(struct input_event *evt, void *user_data) {
    UNUSED(user_data);
    if (evt->code == INPUT_ABS_X) {
        last_touch_point.x = evt->value;
    }
    if (evt->code == INPUT_ABS_Y) {
        last_touch_point.y = evt->value;
    }
    if (evt->code == INPUT_BTN_TOUCH) {
        last_touch_point.pressed = evt->value;
    }
    if (evt->sync) {
        k_sem_give(&touch_event_sync);
    }
}

And was not seeing anything. Then closer at the code in input_gt911.c and noticed that it is sending another event code:
Which I can check for like:
if (evt->code == INPUT_ABS_MT_SLOT) {

But the question is, how should a sketch/library know maybe when it should process these callbacks. That is currently
the callback code here sets a semaphore each time it gets a sync which is for every point. Which might at that point wake up my
main thread that is waiting on the semaphore.

I confirmed this with a simple sketch, that receives all of the callbacks and simply stores the data away, until I type something in the Serial monitor and which point it prints these all out:

#include <zephyr/input/input.h>

typedef struct {
  uint32_t timeUS;
  struct input_event evt;  
} touch_events_t;

#define MAX_EVENTS 100
touch_events_t events[MAX_EVENTS];
int event_count = 0;

void touch_event_callback(struct input_event *evt, void *user_data) {
    UNUSED(user_data);

  if (event_count < MAX_EVENTS) {
    events[event_count].timeUS = micros();
    memcpy(&events[event_count].evt, evt, sizeof(struct input_event));
    event_count++;
  }
}


extern "C" void registerGigaTouchCallback(void (*cb)(struct input_event *evt, void *user_data));

void setup() {
  // put your setup code here, to run once:
  Serial.begin(115200);
  while (!Serial && millis() < 5000) {}
  Serial.println("GIGA Zephyr touch test");
  Serial.print("Max Touch Points: ");
  Serial.println(CONFIG_INPUT_GT911_MAX_TOUCH_POINTS, DEC);
  registerGigaTouchCallback(&touch_event_callback);

}

void loop() {
  if(Serial.available()) {
    while(Serial.read() != -1) {};

    if (event_count) {
      uint32_t last_time = events[0].timeUS;
      for (int i=0; i < event_count; i++) {
        Serial.print(" "); Serial.print(events[i].timeUS - last_time);
        Serial.print(": "); Serial.print(events[i].evt.type); 
        Serial.print(" "); Serial.print(events[i].evt.code); 
        Serial.print(" ");  Serial.print(events[i].evt.value);
        if (events[i].evt.sync) {
          Serial.println(" $");
        }
        last_time = events[i].timeUS;
      }
      event_count = 0;
      Serial.println();
    }

  }

  delay(5);

}

And I do see some multiple events when I put two fingers on the display, like:

5233: 3 47 0 $
 1: 3 0 86 1: 3 1 231 1: 1 330 1 $
 1: 3 47 1 $
 1: 3 0 358 1: 3 1 39 1: 1 330 1 $

The 3 47 0 -> Is the first finger and the 3 47 1 -> is the second finger.

a) Hope that the sketch or library calling this, is not a higher priority preemptive... and as such maybe we will receive
all of the callbacks before the user code tries to process them.

b) if not a) maybe user code should delay for an ms after waking to see if another event comes in?

c) Maybe the function in input_gt911.c should only set the sync on the last point it is going to output.

d) gt911 send another report at start saying how many points there are

e) The code sending the points output in reverse order and we only process on point 0

Thoughts?

Secondary question: I believe that this device supports gestures, when the number of points is >= 2. Does this
driver support this? I did not notice anything within it.

Thanks
Kurt