Is it possible that the i2c_write command to setup calibration is wrong in flicklib.py?

[cmisip]

Should it be:

flicklib.i2c_write([0x10, 0x00, 0x00, 0xa2, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0x00, 0x00, 0x00])

Thanks,
Chris

[danny7894]

Yes it should be, maybe or flicklib.i2c_write([0xa1, 0x00, 0x00, 0xa2, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0x00, 0x00, 0x00]

[cmisip]

I thought I had a ghost hand hovering over my board. It turns out that auto calibration was actually turned off in the code. I am just starting to learn python and I am trying to wrap my head around the code.

It seems that in flicklib.py

160: is_edge = (d_gesture[3] & 0b00000001) > 0

is checking the first bit of the fourth byte or bit 24 of the 32 bit gesture payload.
Shouldn't it be :
is_edge = (d_gesture[2] & 0b00000001) > 0 #check the 16th bit of the 32 bit gesture payload

is_edge is also not being sent to the callable method _on_flick()

Also should we be checking bit 31 of the gesture payload to ensure the recognizer is done or is byte 0 empty if the recognizer is still recognizing?

My ultimate goal here is to enable Hold detection and use that as a separate recognition outcome. I just need to validate my assumptions.

I think ultimately:

1. I need to enable it in dspgesturemask by setting bit 22:
   RuntimeParameterID 0x85 dspGestureMask:

binary 00000000 01000000 00000000 00011111 or hex 00 40 00 1F which in little endian is:
flicklib.i2c_write(0x10, 0x00 ,0x00, 0xA2, 0x85, 0x00 , 0x00 ,0x00, 0x1F, 0x00, 0x40, 0x00, 0xFF, 0xFF, 0xFF, 0xFF)
2. Check if the hold bit is set in bit 28 of GestureInfo
is_hold = d_gesture[3] & 0b0010000

3. Handle the case when gesture[0] is not in the enumerate(gestures) and check that gesture[0] = decimal 64

   `for i,gesture in enumerate(gestures): 
         if d_gesture[0] == i + 1:
   
            if gesture[0] == 'flick' and callable(_on_flick):
                _on_flick(gesture[1], gesture[2])
   
            break
   
    if gesture[0] == 64:
         gesture[1]='hold_gesture'
         gesture[2]=is_hold
         if callable(_on_flick):
                _on_flick(gesture[1], gesture[2])`
   

Per the manual:

Recognized Gestures:
The recognized gestures are results of the HMM classification. Edge detection
can be used to further classify where the gesture has been done (Edge
Flicks). Furthermore, gesture attributes give information about the direction of
the flick. The gesture information is given as a bit field and can be decoded as
follows:
Bits 0...7:Recognized gesture as decimal number
0: No gesture
1: Garbage model
2: Flick West to East
3: Flick East to West
4: Flick South to North
5: Flick North to South
6: Circle clockwise (only active if AirWheel disabled)
7: Circle counterclockwise (only active if AirWheel disabled)
8: Wave X
9: Wave Y
64: Hold
73: Presence
65: Edge Flick West to East
66: Edge Flick East to West
67: Edge Flick South to North
68: Edge Flick North to South
69: Double Flick West to East
70: Double Flick East to West
71: Double Flick South to North
72: Double Flick North to South
Bits 8...11: These bits must not be interpreted.
Bits 12...15:Gesture Class read as a decimal number
0: Garbage model
1: Flick gesture
2: Circular gesture
Bit 16:
Edge flick – is ‘1’ if flick gesture is classified as edge flick
Bits 17...26:These bits are reserved.
Bit 27:
HandPresence flag: Is ‘1’ while the user’s hand is within the
sensing space.
Bit 28:
HandHold flag: Is ‘1’ while the hand is not moving. Further
dependencies can be adjusted inside Aurea Parametrization.
Bit 29:
HandInside flag: Is ‘1’ while the user’s hand is approximately
above the sensor.
Bit 30:
This bit is reserved.
Bit 31:
Gesture recognition in progress. This bit is set when the
Gesture Recognizer is active and Reset when the gesture is
recognized and the Recognizer is Off.
Structure: 32-bit Word read as a bit mask
Range: (0x00000000..0xFFFFFFFF)

Thanks,
Chris

[cmisip]

Well, this is what I ended up doing:

`    if d_configmask & SW_DATA_GESTURE and not d_gesture[0] == 0: 
    # We have a gesture packed in 4 bytes
    is_edge =    (d_gesture[2] & 0b00000001) > 0 # bit 16 check  Edge bit
    is_hold =    (d_gesture[3] & 0b00010000) > 0 # bit 28 check  Hand Hold bit
    is_present = (d_gesture[3] & 0b00001000) > 0 # bit 27 check  Presence bit  
    gestures = [
        (0,'none','',''),
        (1,'garbage','',''),
        (2,'flick',str(is_edge),'east'),
        (3,'flick',str(is_edge),'west'),
        (4,'flick',str(is_edge),'north'),
        (5,'flick',str(is_edge),'south'),
        (6,'circle','clockwise',''),
        (7,'circle','counter-clockwise',''),
        (8,'wave','X',''),
        (9,'wave','Y'''),
        (64,'hold',str(is_hold),''),
        (73,'presence',str(is_present),''),
        (65,'edge',str(is_edge),'east'),
        (66,'edge',str(is_edge),'west'),
        (67,'edge',str(is_edge),'north'),
        (68,'edge',str(is_edge),'south'),
        (69,'double','west','east'),
        (70,'double','east','west'),
        (71,'double','south','north'),
        (72,'double','north','south')
    ]

    for gesture in gestures:
        if d_gesture[0] == gesture[0]:

            if callable(_on_flick):
                _on_flick(gesture[1],gesture[2], gesture[3])

            break

`

And then I added the i2c_write command:

 `#7  6  5  4  3  2  1  0     byte[0]

  #15 14 13 12 11 10 9  8     byte[1]

  #23 22 21 20 19 18 17 16    byte[2]

  #31 30 29 28 27 26 25 24    byte[3]




#Enable flick, edge, hold, presence
#                                                         [ 1F    00    C0    0F  ]
i2c_write([0x10, 0x00, 0x00, 0xA2, 0x85, 0x00, 0x00 ,0x00, 0x1F, 0x00, 0xC0, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF])

#Enable flick,hold, presence
#                                                         [ 1F    00    C0    00  ] 
#i2c_write([0x10, 0x00, 0x00, 0xA2, 0x85, 0x00, 0x00 ,0x00, 0x1F, 0x00, 0xC0, 0x00, 0xFF, 0xFF, 0xFF, 0xFF])

#Enable only flick
#                                                         [ 1F    00    00    00  ] 
#i2c_write([0x10, 0x00, 0x00, 0xA2, 0x85, 0x00, 0x00 ,0x00, 0x1F, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF])`

Presence bit is never set. Hold bit is never set. Edge bit is set only if edge swipes are enabled and detected.
Presence recognition by HMM is after 3 seconds. Hold recognition by HMM is 1 second later after presence recognition. Enabling double flicks seems to step on regular flicks. I don't know how to set the timeout for presence and hold recognition.

I think I am checking the hold bit and presence bit correctly. I don't know what they are for at this time because they seem to be always unset. If you spot any errors, let me know.

   ` is_edge =     (d_gesture[2] & 0b00000001) > 0 # bit 16 check  Edge bit

     is_hold =     (d_gesture[3] & 0b00010000) > 0 # bit 28 check  Hand Hold bit

     is_present =  (d_gesture[3] & 0b00001000) > 0 # bit 27 check  Presence bit  

     in_progress = (d_gesture[3] & 0b10000000) > 0 # bit 31 check to see if recognition is still ongoing`

Chris

[cmisip]

This is my final configuration, disable hold and just use presence:

 `#Enable flick, presence
 #                                                         [ 1F    00    80    00  ] 
 i2c_write([0x10, 0x00, 0x00, 0xA2, 0x85, 0x00, 0x00 ,0x00, 0x1F, 0x00, 0x80, 0x00, 0xFF, 0xFF, 0xFF, 0xFF])`

For some reason, this results in the board returning a hold instead of a presence when you hover your hand above it. It takes 3 seconds to recognize the hold gesture. This is definitely better than returning a presence followed by a hold which my script sees as two different actionable events.

FYI for those trying to use the hold/presence gesture. I was getting GPIO busy errors which I blamed on async functions but I think it is just random. Made these further edits to have flicklib just swallow the error.
For i2c_read:

`def i2c_read(len):
   try: 
      data = i2cm.transaction(i2c.reading(SW_ADDR, len))
      return data[0]
   except Exception as e:
     print(e)
     return [0]`

For read_msg:

  `def _read_msg(len=132):
         end = time.time() + 0.005
         while GPIO.input(SW_XFER_PIN) and time.time() < end:
                time.sleep(0.001)
         if GPIO.input(SW_XFER_PIN):
               # No new msg available
                return [0, 0, 0, 0]
         # Assert transfer line low to ensure
         # MGC3130 does not update data buffers
         if not GPIO.input(SW_XFER_PIN):
             GPIO.setup(SW_XFER_PIN, GPIO.OUT, initial=GPIO.LOW)
             try:
                data = i2c_read(len)
                io_error_count = 0
                return bytearray(data)
             except Exception as e:
                print(e) 
                return [0,0,0,0,0,0,0,0,0]`

and added a recalibrate method:

      `def recalibrate():
           _stop_poll()
           #                [ Header                          ][ Parameter ID ][ Reserved  ][   Argument 0                ][    Argument 1                 ]      
           i2c_write( [0x10, 0x00, 0x00, 0xa2,   0x00, 0x10,      0x00, 0x00,  0x00, 0x00, 0x00, 0x00,   0x00, 0x00, 0x00, 0x00])
           time.sleep(0.02)
           _start_poll()`         

Hopefully, no more issues. I just wish I could find the i2c command for adjusting the hold gesture timeout. Its not in the manual and its not on the internet as far as I know.

So now I have airwheel left and right, 4 flick directions, a hover low and hover high gesture ( difference is just the value of z). Although hover high is not as reliable as hover low. And garbage recognition could be used to turn off the screensaver. Just make sure to come straight down onto the board and wiggle your fingers and come up again ( so you don't accidentally trigger a flick).

Chris

[sanan1160]

I created a repo for the flicklib patch and script. I have not had any issues running this a full day. Hopefully, project is finished.

https://github.com/sanan1160/MyFlick/tree/main

Happy Scripting,
Chris