Piu' sotto, al termine della lingua inglese trovi il testo in italiano.
Below English text you'll find the Italian version
Library provides a function that, allows to assign functions to single/double/long clicks to easily setup a system controlled by gestures.
Function simply receives the distance value measured by the sensor detecting gestures and assigning them any number of functions in a structured way.
Example of using this function is on this YouTube video: Gesture Recognition with ToF sensors: gesture detection and a gesture menu system using VL53L1X
Follow all steps in Mode 1
Follow all steps in Mode 1
Follow all steps in Mode 2
Edit z_vl53l1_gesture.h and set the configuration parameters in USER/PROJECT PARAMETERS session on "STEP 2":
- number if items in the menu (number of menu levels)
- menu enabling sequence and sequence timeout(protecting against unwanted activations)
- menu items switching sequence
- menu inactive timeout
(details and examples on each above parameter on Using a gesture controlled menu)
uint8_t VL53L1__GestureMenu(uint8_t SStatus,uint16_t Distance);
VL53L1__GestureMenu() detects gestures, verifies enabling sequence and the execution of menu commands
To assign commands/functions to menu items (gestures) setup the function:
void VL53L1X__GestureMenu_Items(uint8_t menuItem, uint8_t firstCall, uint8_t shortClick,uint8_t longClick,int16_t *longClickVal,int16_t *longClickLowerValue,int16_t *longClickUpperValue);
VL53L1X__GestureMenu_Items() receives the current menu item (menuItem), indicating if the current call is the first one in a calling series (firstCall=1).
Other parameters specifies if the function is called having detected a single, a double or a long click (please note: single and double clicks are signaled just 1 time, while a long click si signaled (calling VL53L1X__GestureMenu_Items()) each time until sensor detects the longclick)
Next, function receives the current value of the longclick corresponding to the "long detection" and the two limits (the lower and the upper one).
Long click value, lower and upper limits can be modified by VL53L1X__GestureMenu_Items(): typically (only) on the first call, the function set te current value and its limits.
An example of a running VL53L1X__GestureMenu_Items() function is available in z_vl53l1_test.c.
...
SStatus=VL53L1__GetDistance(&Distance);
if (SStatus<=VL53L1__RANGE_STATUS_THRESH)
VL53L1__GestureMenu(SStatus, Distance);
...Having available a pin and a timer (any type) on the uC, the library allows setting up a menu status led, helping the end user to handle menu in a system that might not have any other visual user interface.
Led will be off when menu is disabled and will repeate blinking cycles which number of flashes is equal to the current menu level.
(see A gesture-menu status led for an example)
Setup a pin handling led:
| Pinname to assign | Output level | Mode | Pull-up/down |
|---|---|---|---|
| MENU_LED | x | OutputENU_LED | x |
Set initial output level, pin mode (push pull/open drain), pulled up/down as per your preferred pin configuration.
Setup a counting up timer.
Set the prescaler allowing to conveniently assign ARR values allowing a readable blinking.
Edit z_vl53l1_gesture.h and set the configuration parameters in USER/PROJECT PARAMETERS session on "STEP 3":
- remove comment on "_ISLED" define indicating that there is a menu led in the project.
- notify which pin level makes led on (GPIO_PIN_SET if led is ground connected, GPIO_PIN_RESET if connected to VCC
- which timer is used to drive blinking
- ARR assigned counting values when led is on in a blinking series, when it is off, pause duration between two series.
Connect LED (and a resistor) to the pin.
There is nothing else/more to do: entering in manu, led will start fhashing, showing current menu level.
In the src folder of this repository, you can find also z_vl53l1_test.c and z_vl53l1_test.h, containing the test function shown on Testing a gesture menu.
- Copy the two _test files in the corresponding core/src and core/inc folders.
- Copy "TestMenu_VL53L1X.json" file in the project main folder.
- just call "VL53L1__testMenu()" function in the main loop (after device and ranging initialization and ranging start, as always):
(main.c)
...
/* USER CODE BEGIN WHILE */
if (VL53L1__Init())
while (1) {};
VL53L1__InitGesture();
VL53L1X_StartRanging(VL53L1__ADDR); /* Enabling ranging */
while (1)
{
VL53L1__testMenu();
...- open CubeMonitor, load TestMenu_VL53L1X.json script, deploy it and run Dashboard...
La libreria mette a disposizione una funzione che consente di assegnare funzioni a clic singoli/doppi/lunghi per impostare facilmente un sistema controllato da gesti.
La funzione riceve semplicemente il valore della distanza misurata dal sensore rilevando i gesti e assegnando loro un numero qualsiasi di funzioni in modo strutturato.
Un esempio di utilizzo di questa funzione si trova in questo video di YouTube: Gesture Recognition with ToF sensors: gesture detection and a gesture menu system using VL53L1X
Esegui tutti i passi come in Mode 1
Esegui tutti i passi come in Mode 1
Esegui tutti i passi come in Mode 2
Modifica z_vl53l1_gesture.h e imposta i parametri di configurazione nella sessione USER/PROJECT PARAMETERS nel "STEP 2":
- il numero di voci del menu (numero di livelli del menu)
- la sequenza di attivazione del menu e timeout della sequenza (per la protezione da attivazioni indesiderate)
- la sequenza di commutazione delle voci del menu
- il timeout di inattività del menu (dettagli ed esempi su ciascun parametro sopra riportato su Using a gesture controlled menu)
## Funzioni disponibili
uint8_t VL53L1__GestureMenu(uint8_t SStatus,uint16_t Distance);
VL53L1__GestureMenu() rileva i gesti, verifica la sequenza di attivazione e l'esecuzione dei comandi del menu
Per assegnare comandi e funzioni alle voci di menu (gesti) impostare la funzione:
void VL53L1X__GestureMenu_Items(uint8_t menuItem, uint8_t firstCall, uint8_t shortClick,uint8_t longClick,int16_t *longClickVal,int16_t *longClickLowerValue,int16_t *longClickUpperValue);
VL53L1X__GestureMenu_Items() riceve la voce di menu corrente (menuItem), indicando se la chiamata corrente è la prima di una serie di chiamate (firstCall=1).
Altri parametri specificano se la funzione viene chiamata dopo aver rilevato un clic singolo, doppio o lungo (nota: i clic singoli e doppi vengono segnalati solo 1 volta, mentre un clic lungo viene segnalato (chiamando VL53L1X__GestureMenu_Items()) ogni volta finché il sensore non rileva il clic lungo)
Di seguito, la funzione riceve il valore corrente di longclick corrispondente al "rilevamento lungo" e i due limiti (quello inferiore e quello superiore).
Il valore del longclick, i limiti inferiore e superiore possono essere modificati da VL53L1X__GestureMenu_Items(): tipicamente (solo) alla prima chiamata, la funzione imposta il valore corrente e i suoi limiti.
Un esempio di una funzione VL53L1X__GestureMenu_Items() in esecuzione è disponibile in z_vl53l1_test.c.
...
SStatus=VL53L1__GetDistance(&Distance);
if (SStatus<=VL53L1__RANGE_STATUS_THRESH)
VL53L1__GestureMenu(SStatus, Distance);
...Se nel progetto rimane libero un pin del UC ed un timer (di qualunque tipo), la libreria consente di impostare un led che mostra lo stato del menu, aiutando l'utente finale in un sistema che potrebbe non avere alcun altra interfaccia utente visiva.
(vedi A gesture-menu status led per un esempio)
Configura un pin per il led:
| Nome Pin | Output level | Mode | Pull-up/down |
|---|---|---|---|
| MENU_LED | x | Output x | x |
Imposta l'output level iniziale, il pin mode (push pull/open drain), se pull up/down secondo le tua modalità di gestione del led.
Configura un timer counting up.
Imposta il prescaler in modo da permettere di assegnare valori ARR che permettano lampeggi interpretabili.
Modifica z_vl53l1_gesture.h ed imposta i parametri di configurazione in USER/PROJECT PARAMETERS nella sessione "STEP 3":
- togli il commento alla define "_ISLED" indicando che c'e' un menu_led nel progetto.
- indica quale livello pin accende il led (GPIO_PIN_SET se il led e' connesso a terra, GPIO_PIN_RESET se a VCC
- quale timer viene usato per il lampeggio del led
- i valori assegnati a ARR quando il led e' acceso in una serie di lampeggi, quando è spento, la duratsa della pausa tra due serie.
Collega il LED (e la sua resistenza) al pin.
Non c'e' altro da fare: entrando nel menù, il led inizierà a lampeggiare,
mostrando il livello di menu corrente.
Nella cartella src di questa repository, puoi trovare anche z_vl53l1_test.c e z_vl53l1_test.h, contenenti la funzione di test mostrata in Testing a gesture menu.
- Copia i due file _test nelle cartelle core/src e core/inc corrispondenti.
- Copia il file "TestMenu_VL53L1X.json" nella cartella principale del progetto.
- basta chiamare la funzione "VL53L1__testMenu()" nel ciclo principale (dopo l'inizializzazione del dispositivo e della lettura e l'avvio delle letture, come sempre):
(main.c)
...
/* USER CODE BEGIN WHILE */
if (VL53L1__Init())
while (1) {};
VL53L1__InitGesture();
VL53L1X_StartRanging(VL53L1__ADDR); /* Enabling ranging */
while (1)
{
VL53L1__testMenu();
...- apri CubeMonitor, carica lo script TestMenu_VL53L1X.json, fai il deploy ed esegui la Dashboard...