1. Introduzione al Plugin
Il plugin FAIRINO MoveIt2 è un plugin che fornisce supporto per il controllo del movimento e la pianificazione del percorso dei robot FAIRINO. Grazie al plugin FAIRINO MoveIt2, è possibile implementare funzionalità complesse come il controllo del movimento del robot, la pianificazione del percorso, la soluzione della cinematica inversa e il rilevamento delle collisioni in tempo reale. È adatto per vari scenari di applicazione dei bracci robotici, come l’industria, la saldatura, la produzione, il carico/scarico automatizzato, il pallettizzazione, il settore medico, ecc.
2. Uso Rapido
Questo capitolo spiega come configurare l’ambiente di esecuzione dell’APP.
Si consiglia di utilizzarlo su Ubuntu 22.04 LTS (Jammy). Dopo aver installato il sistema, è possibile installare ROS2. Si consiglia di utilizzare ros2-humble. L’installazione di ROS2 può essere seguita dal tutorial: https://docs.ros.org/en/humble/index.html.
2.1. Installazione e Configurazione del Pacchetto Plugin FAIRINO MoveIt2
2.1.1. Clonare il Plugin FAIRINO MoveIt2
Clonare il plugin FAIRINO MoveIt2 in locale, quindi cd nella directory di destinazione. I file principali includono: il pacchetto di funzionalità fairino_msgs per i tipi di dati di trasmissione del robot FAIRINO; il pacchetto di funzionalità del plugin hardware fairino_hardware per il robot FAIRINO;
il pacchetto di funzionalità per l’aspetto e i file urdf del robot FAIRINO: fairino_robot/fairino_description;
i pacchetti di configurazione moveit2 per i robot FAIRINO: fairino_robot/fairino3mt_v6_moveit2_config, fairino_robot/fairino3_v6_moveit2_config, fairino_robot/fairino5_v6_moveit2_config, fairino_robot/fairino10_v6_moveit2_config, fairino_robot/fairino16_v6_moveit2_config, fairino_robot/fairino20_v6_moveit2_config, fairino_robot/fairino30_v6_moveit2_config; il pacchetto di codice demo MTC per FAIR: fairino_robot/fairino_mtc_demo.
2.1.2. Compilare i Pacchetti di Funzionalità
Compilare il pacchetto fairino_msgs
1cd ros2_ws
2colcon build --packages-select fairino_msgs
3source install/setup.bash
Compilare il pacchetto fairino_hardware
1cd ros2_ws
2colcon build --packages-select fairino_hardware
3source install/setup.bash
Compilare il pacchetto fairino_description
1cd ros2_ws
2colcon build --packages-select fairino_description
3source install/setup.bash
Compilare i pacchetti di configurazione moveit2 per i robot FAIRINO, prendendo fairino5_v6_moveit2_config come esempio
1cd ros2_ws
2colcon build --packages-select fairino5_v6_moveit2_config
3source install/setup.bash
Compilare il pacchetto di codice demo fairino_mtc_demo per i robot FAIRINO. Se questo pacchetto di esempio non è presente nello spazio di lavoro ufficiale ros2_ws, contattare il servizio post-vendita per ottenerlo.
1cd ros2_ws
2colcon build --packages-select fairino_mtc_demo
3source install/setup.bash
2.2. Configurare il Modello Moveit2 per il Braccio Robotico FAIR
Se non si desidera utilizzare i pacchetti di configurazione moveit2 forniti ufficialmente per il robot, è possibile configurare un pacchetto di configurazione moveit2 personalizzato per il robot tramite moveit_setup_assistant.
2.2.1. Creare uno Spazio di Lavoro
Creare uno spazio di lavoro e un pacchetto di funzionalità
1mkdir -p test_fa_ws/src
2cd test_fa_ws/src
3mkdir fairino5_v6_robot_moveit_config
4cd ..
5cd ..
Compilare il pacchetto di funzionalità e eseguire source
1colcon build
2source install/setup.bash
Avviare moveit_setup_assistant per configurare il robot
1ros2 launch moveit_setup_assistant setup_assistant.launch.py
2.2.2. Configurare il Robot
Avviare l’Interfaccia di Configurazione
Aprire un terminale nella directory test_fa_ws. Nell’interfaccia di configurazione, selezionare «Create New Moveit Configuration Package» per creare un nuovo pacchetto di configurazione moveit.
Quindi selezionare il file di descrizione del robot, cioè il file .urdf, e selezionare «Load Files» per caricare il modello del robot. Si vedrà il modello del robot caricato a destra.
Configurare Self-Collisions
Self-Collisions è l’impostazione delle collisioni del robot. Fare clic su «Generate Collision Matrix» per generare automaticamente la matrice di collisione delle giunzioni. Questa annullerà le collisioni tra due link a contatto e tra link che non entreranno mai in contatto, configurando così la matrice di collisione delle giunzioni del robot ed evitando di calcolare le collisioni tra due superfici a contatto. Fare clic su «Generate Collision Matrix» per generarla automaticamente.
Configurare Virtual Joints
Virtual Joints sono gli assi virtuali del robot. Quando il robot è installato su una piattaforma mobile, è necessario impostare un asse virtuale per il robot, impostando il nome dell’asse virtuale, il link figlio, il tipo di giunzione, ecc. Quando la piattaforma mobile si muove, anche l’asse virtuale si muove in sincronia, spostando così il robot, realizzando la funzione del robot che si muove con la piattaforma mobile. Questa volta posizioniamo direttamente il robot nel sistema di coordinate world, chiamandolo virtual_joint.
Configurare Planning Groups
Planning Groups sono i gruppi di pianificazione del robot. Raggruppano le giunzioni che devono essere considerate insieme durante il calcolo cinematico nello stesso gruppo di pianificazione, per eseguire calcoli cinematici diretti e inversi unificati. Ad esempio, se si posiziona un robot su un AGV e si installa una pinza all’estremità del robot, si possono raggruppare le quattro giunzioni dell’AGV in un gruppo di pianificazione, le sei giunzioni del robot in un gruppo di pianificazione e la giunzione della pinza in un gruppo di pianificazione per il calcolo cinematico.
Poiché questa volta non coinvolge una pinza, aggiungiamo solo i vari gruppi di giunzioni del robot, cioè il gruppo arm. Innanzitutto, aggiungere il gruppo arm. Per il risolutore cinematico «Kinematic Solver» selezionare kdl_kinematics_plugin/KDLKinematicsPlugin, quindi il pianificatore predefinito del gruppo «Group Default Planner» selezionare TRRT, quindi fare clic su «Add Joints» per aggiungere giunzioni a questo gruppo di pianificazione.
Le giunzioni per arm possono essere selezionate multipli tenendo premuto Shift. Fare clic su “>” per aggiungere, quindi fare clic su «save» per salvare.
Il gruppo di pianificazione definito è mostrato di seguito:
Configurare Robot Poses
Robot Poses sono le pose predefinite del robot. Definisce alcune pose predefinite per ogni gruppo di pianificazione. Definire una posa «home» per arm. Questa posa può essere scelta liberamente.
Robot Poses può definire pose predefinite per ogni gruppo di pianificazione. Quando nel robot è presente una pinza, è possibile aggiungere un gruppo di pianificazione per la pinza nella sezione Planning Groups, quindi durante l’impostazione delle pose in Robot Poses è possibile impostare pose predefinite per la pinza.
Configurare End Effectors
End Effectors è l’organo di esecuzione finale del robot. Il gruppo di pianificazione dell’organo di esecuzione finale è hand, e il parent_link di connessione predefinito è panda_link8. Poiché questa volta non c’è un organo di esecuzione finale, questo passaggio può essere saltato.
Modifiche URDF di ros2_control
Le modifiche URDF di ros2_control sono principalmente utilizzate per impostare il tipo di dati delle giunzioni inviati e ricevuti in feedback. È possibile scegliere tra posizione, velocità e coppia. Questa volta selezioniamo sia i dati inviati che quelli di feedback come controllo di posizione, quindi fare semplicemente clic su «Add interfaces».
Importante
Nota:
La selezione del tipo di dati delle giunzioni deve corrispondere al plugin fairino_hardware successivo. Selezionare il tipo di dati delle giunzioni inviati e ricevuti in feedback in base ai dati trasmessi dal plugin fairino_hardware. Poiché il plugin fairino_hardware che controlla il movimento effettivo del robot questa volta utilizza il tipo di dati position, selezioniamo sia i dati inviati che quelli di feedback come controllo di posizione.
Controller ROS 2
I controller ROS 2 sono principalmente utilizzati per generare il file ros2_controllers.yaml. Questo file imposta la frequenza di pubblicazione, i nomi delle giunzioni, i nomi dei controller, i tipi di controller, ecc. Configurare i controller ROS 2 per configurare un controller per ogni gruppo di pianificazione. Fare clic su «Auto Add JointTrajectoryController Controllers For Each Planning Group».
Controller Moveit
I controller Moveit sono principalmente utilizzati per generare il file moveit_controllers. Questo file imposta i nomi dei controller, i tipi di controller, ecc. È importante notare che i nomi dei controller in moveit_controllers devono essere gli stessi dei nomi dei controller in ros2_controllers, altrimenti non funzionerà correttamente.
Inoltre, quando i nomi dei controller in moveit_controllers corrispondono ai nomi dei controller in ros2_controllers, i tipi di controller in moveit_controllers verranno automaticamente mappati sui tipi di controller in ros2_controllers, realizzando l’invio dei dati di controllo tramite moveit_controllers a ros2_controllers, quindi attraverso il plugin in ros2_controllers per guidare il movimento effettivo del robot.
File di Lancio (Launch Files)
Configurare i file di lancio. Utilizzare la configurazione predefinita.
Informazioni sull’Autore
Generare i File di Lancio
Generare i file di lancio. Selezionare la posizione di generazione. Questa volta creare una cartella fairino5_v6_robot_moveit_config nel percorso del file test_fa_ws/src per memorizzare i file di configurazione, quindi selezionare «Generate».
Poiché questa configurazione è stata già eseguita in precedenza, se questa è la configurazione iniziale, il contenuto della sezione «Check files you want to be generated» sarà nero, indicando che è possibile generare i file di lancio.
2.2.3. Avviare il Lancio
Dopo aver completato la configurazione, è possibile compilare il pacchetto di funzionalità. È possibile sostituire il pacchetto di configurazione moveit2 per il robot FAIRINO con un pacchetto di configurazione moveit2 personalizzato per il robot, per realizzare l’uso compatibile del plugin per robot personalizzati dall’utente.
1colcon build --packages-select fairino5_v6_robot_moveit_config
2source install/setup.bash
Quindi eseguire direttamente il file di lancio appena configurato
1ros2 launch fairino5_v6_robot_moveit_config demo.launch.py
Si vedrà l’interfaccia rviz2 configurata.
2.2.4. Utilizzo di Moveit2
Dopo aver aperto il pacchetto configurato, è possibile impostare la posizione target del robot trascinando la sfera blu all’estremità del robot nell’interfaccia 3D a destra, quindi modificare l’orientamento dell’estremità del robot utilizzando i tre anelli rosso, verde e blu all’estremità del robot.
Fare clic sul pulsante «Plan» a sinistra per pianificare la traiettoria di movimento del robot.
Fare clic sul pulsante «Execute» a sinistra per guidare il robot a muoversi lungo la traiettoria pianificata fino alla posa target.
Il pulsante «Plan&Execute» controlla automaticamente il movimento del robot dopo aver pianificato la traiettoria.
Quindi, facendo clic sulla scheda «Joints», è possibile modificare la posa target del robot cambiando gli angoli delle singole giunzioni, quindi utilizzare i pulsanti «Plan», «Execute», «Plan&Execute» per guidare il movimento del robot.
2.3. Plugin fairino_hardware (Pacchetto di configurazione moveit personalizzato per robot)
Il plugin fairino_hardware è lo strato intermedio che collega moveit al robot. Attraverso il plugin fairino_hardware, move_group invia la pianificazione del movimento a moveit_control, che poi lo inoltra a ros2_control. ros2_control guida quindi il robot effettivo attraverso il plugin fairino_hardware. Inoltre, il plugin fairino_hardware riceve anche i dati di feedback dal robot effettivo, realizzando così la sincronizzazione tra il modello del robot nell’interfaccia di simulazione rviz2 e il robot effettivo. Ciò consente all’utente di guidare il robot effettivo attraverso l’interfaccia rviz2.
Inoltre, grazie all’implementazione del plugin fairino_hardware, i robot FAIRINO possono essere integrati nel framework di controllo ros2_control, consentendo ai robot FAIRINO di essere compatibili con pacchetti di funzionalità di terze parti basati su ros2_control.
Nel plugin fairino_hardware adattato alla versione software V3.8.3 del braccio robotico, è stata aggiunta la modalità coppia e l’interfaccia per la coppia di comando, consentendo al braccio robotico di entrare in modalità coppia e ricevere la coppia di comando.
2.3.1. Compilazione del Plugin fairino_hardware
Compilare il pacchetto di funzionalità del plugin fairino_hardware nello spazio di lavoro ros2_ws fornito ufficialmente. Seguendo la compilazione del pacchetto di funzionalità del plugin fairino_hardware nella sezione precedente, si troverà il file .so generato dal plugin, libfairino_hardware.so, in
1ros2_ws/install/fairino_hardware/lib/fairino_hardware
indicando che la compilazione del plugin è riuscita.
È importante notare che i nomi assegnati dal plugin fairino_hardware alle giunzioni del robot devono essere gli stessi dei nomi delle giunzioni del robot configurati in moveit2. Questo plugin fairino_hardware assegna i nomi j1, j2, j3, j4, j5, j6 alle sei giunzioni del robot, dalla posizione della base all’estremità del robot. Pertanto, durante la configurazione del robot in moveit2, è necessario nominare le giunzioni del robot come j1, j2, j3, j4, j5, j6.
2.3.2. Utilizzo del Plugin fairino_hardware
Se si utilizza il pacchetto di configurazione moveit personalizzato per il robot configurato, andare nella directory
1/home/fairino/test_fa_ws/install/fairino5_v6_robot_moveit_config/share/fairino5_v6_robot_moveit_config/config
Trovare il file fairino5_v6_robot.ros2_control.xacro e sostituire il parametro alla riga 3
1use_fake_hardware:=false
con
1use_fake_hardware:=true
In base alla successiva condizione if, si può vedere che impostando use_fake_hardware su true si abilita il plugin fairino_hardware/FairinoHardwareInterface. Salvare il file e uscire.
Qui, «fairino_hardware/FairinoHardwareInterface» è il nome del plugin hardware impostato. I dettagli possono essere visualizzati nel file «fairino_hardware.xml» nella directory «/home/fairino/ros2_ws/src/fairino_hardware».
Nota: il parametro robot_control_mode alla riga 3 del file determina l’interfaccia di comando esposta durante il caricamento del plugin, cioè il parametro rappresenta la modalità di controllo. 0 è la modalità di controllo di posizione e il plugin esporrà l’interfaccia position. 1 è la modalità di controllo di coppia e il plugin esporrà l’interfaccia effort. Una demo per l’interfaccia di controllo di coppia dovrebbe essere rilasciata nel pacchetto di funzionalità fairino_hardware adattato alla versione software V3.8.5 del braccio robotico.
L’attuale controller Moveit2 supporta solo la modalità di controllo di posizione. Non impostare robot_control_mode su 1.
2.3.3. Eseguire il Plugin
Aprire un terminale, quindi passare allo spazio di lavoro ros2_ws ed eseguire source dello spazio di lavoro. Lo scopo è aggiungere il plugin fairino_hardware. È anche possibile aggiungere questo percorso al file «~/.bashrc», ma non è consigliato.
1cd ros2_ws
2source install/setup.bash
Quindi tornare alla directory home, passare allo spazio di lavoro test_fa_ws ed eseguire source dello spazio di lavoro, quindi eseguire il file demo.launch.py
1cd ..
2cd test_fa_ws
3source install/setup.bash
4ros2 launch fairino5_v6_robot_moveit_config demo.launch.py
2.3.4. Risultato dell’Esecuzione
Dopo l’avvio del file demo.launch.py, l’interfaccia rviz2 sarà come mostrato di seguito:
A questo punto, la differenza principale tra l’interfaccia di avvio di rviz2 e quella nella sezione 3.3.1 è la posa iniziale del robot. Ora, poiché è stato aggiunto il plugin fairino_hardware, questo plugin riceverà lo stato delle giunzioni del robot effettivo in tempo reale e lo restituirà a move_group tramite ros2_control, controllando così la posa del robot simulato nell’interfaccia rviz2, realizzando la sincronizzazione tra il robot effettivo e il robot simulato in rviz2.
La posa attuale del robot effettivo è la seguente:
A questo punto è possibile guidare il robot effettivo attraverso l’interfaccia rviz2. Trascinare la sfera blu all’estremità del robot nell’interfaccia rviz2 per spostare l’estremità del robot nella posizione target, quindi trascinare i tre anelli rosso, verde e blu all’estremità del robot per modificare l’orientamento dell’estremità del robot. Fare quindi clic sul pulsante «Planning & Execute» a sinistra per pianificare la traiettoria di movimento e guidare il robot. Si noterà che il robot effettivo e il robot simulato nell’interfaccia rviz2 si muovono in sincronia e si fermano nella posa target.
Le immagini seguenti mostrano il controllo del robot effettivo e del robot simulato nell’interfaccia rviz2 fino alla posa target tramite l’interfaccia rviz2:
A questo punto è possibile controllare il robot effettivo e il robot simulato nell’interfaccia rviz2 per muoversi in sincronia tramite moveit2.
3. Pacchetto di Codice Demo MTC
3.1. Introduzione al Pacchetto di Codice Demo MTC
Il pacchetto di codice demo MTC fornisce un’interfaccia rviz2 ricostruita utilizzando moveit2 e il plugin fairino_hardware, sostituendo la scheda «MotionPlanning» originale con la scheda «Motion Planning Tasks» per visualizzare le varie fasi del movimento del robot. L’interfaccia rviz2 può essere modificata tramite il file «mtc.rviz» nel percorso
1ros2_ws/install/fairino_mtc_demo/share/fairino_mtc_demo/launch
Gli utenti possono personalizzare l’interfaccia rviz2 in base alle proprie esigenze funzionali modificando il file «mtc.rviz».
Inoltre, il pacchetto di codice demo MTC fornisce un esempio di come far muovere il robot in ciclo per afferrare un target utilizzando moveit2 e il plugin fairino_hardware. Attraverso questo esempio, gli utenti possono imparare come interagire meglio con il robot effettivo in forma di codice utilizzando moveit2 e il plugin fairino_hardware. Sulla base di ciò, gli utenti possono personalizzarlo in base alle proprie esigenze.
3.2. Compilazione del Pacchetto di Codice Demo MTC
3.2.1. Clonare il Pacchetto di Codice Demo MTC
Clonare il pacchetto di codice demo MTC ufficiale «fairino_robot» nella directory src dello spazio di lavoro «ros2_ws».
3.2.2. Selezione del Modello di Robot
Nel pacchetto di codice demo MTC fornito ufficialmente, nel file mtc_demo_env.launch.py nella directory
1ros2_ws/src/fairino_robot/fairino_mtc_demo/launch
selezionare il modello di robot, modificando le righe 9, 10, 11 di questo file per corrispondere al robot che si desidera impostare.
I nomi specifici dei modelli di robot possono essere consultati nei pacchetti di funzionalità dei vari modelli di robot nella directory
1ros2_ws/src/fairino_robot/
3.2.3. Compilare il Pacchetto di Codice Demo MTC
Compilare il Pacchetto di Funzionalità fairino_description
Aprire un terminale, passare alla directory ros2_ws, compilare il pacchetto di funzionalità fairino_description, quindi eseguire source
1cd ros2_ws
2colcon build --packages-select fairino_description
3source install/setup.bash
Compilare il Pacchetto di Funzionalità del Robot
Nella directory ros2_ws, compilare il pacchetto di funzionalità del robot corrispondente al modello. Prendendo il robot fairino5 come esempio
1colcon build --packages-select fairino5_v6_moveit2_config
2source install/setup.bash
Quindi è necessario aggiungere il plugin fairino_hardware per sincronizzare il movimento con il robot effettivo. Passare alla directory
1ros2_ws/install/fairino5_v6_moveit2_config/share/fairino5_v6_moveit2_config/config
Trovare fairino5_v6_robot.ros2_control.xacro e sostituire alla riga 9
1<plugin>mock_components/GenericSystem</plugin>
con
1<plugin>fairino_hardware/FairinoHardwareInterface</plugin>
Salvare e uscire.
Compilare il Pacchetto di Funzionalità fairino_mtc_demo
Compilare il pacchetto di funzionalità fairino_mtc_demo ed eseguire source
1colcon build --packages-select fairino_mtc_demo
2source install/setup.bash
3.3. Esecuzione del Pacchetto di Codice Demo MTC
3.3.1. Interfaccia rviz2
Eseguire il file mtc_demo_env.launch.py per aprire l’interfaccia rviz2 personalizzata. La scheda «Motion Planning Tasks» viene utilizzata per visualizzare i vari processi di movimento del robot personalizzati.
1cd ros2_ws
2source install/setup.bash
3ros2 launch fairino_mtc_demo mtc_demo_env.launch.py
3.3.2. Movimento del Robot
Aprire un nuovo terminale, passare alla directory ros2_ws ed eseguire source, quindi eseguire il file mtc_demo_app.launch.py per far muovere il robot.
1cd ros2_ws
2source install/setup.bash
3ros2 launch fairino_mtc_demo mtc_demo_app.launch.py
Quindi, nella scheda «Motion Planning Tasks» dell’interfaccia rviz2, verranno visualizzati i vari processi di movimento del robot e il robot effettivo si sincronizzerà con il robot simulato nell’interfaccia rviz2.
4. Note Importanti
4.1. Sincronizzazione della Versione del Plugin fairino_hardware
Il prerequisito per utilizzare il plugin fairino_hardware è che la versione del plugin fairino_hardware sia coerente con la versione del robot FAIRINO;
Il plugin fairino_hardware riceve i dati di feedback dal robot FAIRINO e li converte nel tipo di dati di comando specificato da ros2_control, quindi converte i dati di movimento del robot inviati da ros2_control in frame dati specifici del robot FAIRINO;
Pertanto, la coerenza dei tipi di dati tra il plugin fairino_hardware e il robot FAIRINO è fondamentale. Versioni diverse del plugin e del robot potrebbero portare a tipi di dati diversi. Quindi, prima di eseguire il debug formale del plugin fairino_hardware, è necessario confermare se la versione del robot FAIRINO corrisponde alla versione del plugin fairino_hardware. In caso contrario, è necessario aggiornare il robot FAIRINO.
Innanzitutto, è possibile visualizzare le versioni attuali del robot nell’interfaccia «WebAPP -> Impostazioni di sistema -> Informazioni» del robot FAIRINO.
Quindi preparare il pacchetto software del robot fornito ufficialmente, quindi accedere all’interfaccia «WebAPP -> Applicazioni ausiliarie -> Corpo robot -> Aggiornamento sistema» del robot FAIRINO, fare clic sul pulsante «Seleziona file», selezionare il pacchetto di aggiornamento software del robot corrispondente alla versione del plugin fairino_hardware preparato, selezionare «Carica pacchetto di aggiornamento» e attendere il completamento dell’aggiornamento software.
Dopo il completamento dell’aggiornamento, il sistema chiederà di riavviare il robot. Impostare l’interruttore sul cabinet di controllo del robot sulla posizione off, attendere circa 25 secondi, quindi avviare il robot. A questo punto, l’aggiornamento della versione software del robot è completo e si può procedere alla compilazione e all’uso successivi del plugin fairino_hardware.
4.2. Problemi Possibili
4.2.1. Possibile problema: Il modello del robot potrebbe non essere caricato a destra durante la configurazione del pacchetto di funzionalità del robot.
Soluzione: Questo errore potrebbe essere causato da percorsi errati nel file .urdf. È possibile risolverlo modificando i percorsi nel file .urdf e copiando la cartella meshes nella directory install/test_moveit/share/test_moveit dello spazio di lavoro.
4.2.2. Errore durante l’esecuzione dopo aver generato il pacchetto.
Soluzione: Eliminare «[«capabilities»]» alla riga 203 del file launches.py, nella riga default_value=moveit_config.move_group_capabilities[«capabilities»], per risolvere il problema.
5. Riepilogo
Questo manuale descrive l’installazione, la configurazione e l’uso del plugin MoveIt2; l’installazione e l’uso del plugin fairino_hardware, realizzando il movimento sincronizzato tra il robot simulato in rviz2 e il robot effettivo; nonché la compilazione e l’esecuzione del pacchetto di codice demo MTC, utilizzando moveit2 e il plugin fairino_hardware per implementare funzionalità personalizzate.
Si spera che attraverso questa guida gli utenti possano avere una comprensione più completa di MoveIt2 e del plugin fairino_hardware, e che possa aiutare gli utenti a personalizzare meglio i servizi del robot FAIRINO.