Projets:Can2RNET

Can2RNET
Informations
Description	Contrôler un fauteuil roulant électrique avec le protocole de communication RNET
Catégorie	Motricité
Etat d'avancement	Réalisés
Techniques	raspberry pi
Durée de fabrication	de 8 à 16 h
Coût matériel	De 100 à 200 euros
Niveau	Difficile
Licence	by-sa
Date de création	2019-10-18
Équipe
Porteur de projet	Jonathan
Contributeurs	Florian, Régis, Jonathan, Laetitia, Luc, André, Federico, Julien, Nicolas, Stéphane
Fabmanager	Delphine
Référent documentation	Margaux
Nom humanlab	Humanlab_MHK
Documentation
Statut de la documentation	Complète
Relecture de la documentation	Non vérifiée

MHK: control wheelchair hack based on the can2RNET project

Description du projet

L'objectif est de piloter un fauteuil électrique avec un joystick et à distance.

• Ce projet est une partie du projet global "Magic Joystick" Projets:Magic_Joystick
• Ce projet a été débuté lors du Fabrikarium chez ArianeGroup (Les Mureaux) du 16 au 18 octobre 2019 avec la collaboration des salariés d'ArianeGroup
• La réalisation de ce projet a pû être réalisé grâce aux créateurs de "Can2RNET" et de leurs différentes documentations.

Lien de la vidéo de la démonstration https://youtu.be/GE2F3cAntdk

Cahier des charges

Démontrer la faisabilité de prise de controle à distance d'un fauteuil roulant à l'aide d'un appareil externe tel qu'un joystick. - Porteur de projet : Jonathan Menir

- Contributeurs: Florian, Régis, Jonathan, Laetitia, Luc, André, Federico, Julien, Nicolas et Stéphane

- Coordinateur du projet : Stéphane

- Responsable de documentation Margaux

Equipe (Porteur de projet et contributeurs)

• Porteur de projet : Janathan Menir
• Contributeurs: Florian, Régis, Jonathan, Laetitia, Luc, André, Federico, Julien, Nicolas et Stéphane
• Coordinateur du projet : Stéphane
• Responsable de documentation Margaux

Matériels nécessaires

- Raspberry Pi 3 (Model B+) avec Carte SD 2GB

- Carte PiCan2 (non testé)

- R-Net cable

- Manette Xbox360

Coût

RaspberryPI 3 : https://www.ldlc.com/fiche/PB00246555.html

Carte Pican2 : https://www.elektor.fr/pican-2-can-bus-board-for-raspberry-pi

Câble r-net : Exemple : https://www.warmex.net/r-net-stuurkastkabel-2-5m.html

Ressources

Présentation du protocole R-NET sur le bus CAN
File:canPPT.pdf
File:ChipHackingV07B.pdf

Documentation technique
File:RNETdictionary_catagorized.txt
File:RNETdictionary_V2.txt
File:R-net-Electronics-Technical-Manual-v6.pdf

Autre exemple de hack de fauteuil electrique
File:DEFCON24_chairhacking.pdf

Processus de réalisation

Le principe est de connecter via une interface au fauteuil roulant de manière à pouvoir le diriger sur un appareil externe au fauteuil comme un joystick.

Vous pouvez trouver tous les fichiers sur le github de myhumankit https://github.com/myhumankit/MHK-can2RNET

Installer la raspberry

Le raspberry sert de réservoir à interface (bluetooth, wifi, usb, ...) pour communiquer et permettre d'analyser et de contrôler les flux du fauteuil.

1. Mettre en place la raspberry :

• Installation d'un système d'exploitation Raspbian https://www.raspberrypi.org/downloads/raspbian/
• Retrouver le processus d'installation et de configuration sur ce site https://www.raspberrypi-france.fr/guide/
• Se connecter en SSH sur le raspberry Pi sous Raspbian

SSH (Secure Shell) est un protocole de communication qui va permettre d'accéder au raspberry Pi à distance depuis un ordinateur. Pour activer et se connecter en SSH https://www.raspberrypi-france.fr/guide/connecter-ssh-raspbian/

Vous pouvez maintenant communiquer avec le raspberry Pi depuis votre ordinateur via un terminal.

Il y plusieurs moyens de connexion :

• bluetooth: https://github.com/redragonx/r-net-bluetooth-control-app. Il permet de contrôler le bluetooth à distance

• Autres (par ip = wifi,...) : https://github.com/redragonx/can2RNET/tree/master/R-net_over_IP

2. (Non testé) Installer PiCan2 sur la rasppi3 https://www.elektormagazine.fr/news/avec-pican2-le-raspberry-pi-prend-le-bus-can

D'après le projet can2rnet, il faudrait ajouter à /boot/config.txt

dtparam=spi=on 
dtoverlay=mcp2515-can0,oscillator=16000000,interrupt=25         
dtoverlay=spi-bcm2835

Puis ajouter les lignes suivantes au fichier /etc/network/interfaces. À noter que le bitrate est fixé à 1250000.

allow-hotplug can0
iface can0 can static
       bitrate 125000
       up /sbin/ip link set $IFACE down
       up /sbin/ip link set $IFACE up

Puis charger les modules noyaux sous : /etc/modules

mcp251x
can_dev

Ensuite, redémarrer la Raspberry, puis vérifier que l'interface "can0" est bien montée. Utiliser la commande `ifconfig` ou 'ip a' selon la distribution linux

Mise en place de la dérivation R-Net entre le fauteuil et la raspberry

1. Couper et dénuder le cable R-Net qui relie le joystick et le module moteur.

2. Connecter le câble à la pican2 selon le code couleur suivant:

white is can high
blue is can low
black is gnd
red is +vin

Installer l'utilitaire CAN-UTILS (non testé)

$ git clone https://github.com/linux-can/can-utils

ou

$ sudo apt-get install can-utils

Superviser et Contrôler les trames RNET-over-CAN (partiellement testé)

Espionner les trames CAN pendant vos essais de la mise au point, c'est à dire :

• mise sous tension la JSM

• commandes joystick, ...

• activation des voyants, des bips, ...

Avant de passer à la suite, prendre le temps de dérouler le scénario suivant et de comprendre la stratégie :

• doc/canPPT.pdf
• doc/RNETdictionary_*.txt

Fichiers se trouvant sur le github

Etapes à suivre :

1. Identifier la trame du heartbeat périodique de la JSM

- "03c30F0F#8787878787878787" @10Hz

2. Identifier le contrôle XY du joystick (JSM) au power module (PM)

- "02000000#XxYy" @100Hz (device JSM n°0) 
- "02001000#XxYy" @100Hz (device JSM n°1) 
- ...

3. Plusieurs modes possibles :

• [Mode JSMError] Mettre la JSM en mode erreur. Envoyer en moins d'une milliseconde ces trames:

- "0c000000#"
- "0c000000#"
- "0c000000#"

On ne sait pas à quoi cette trame correspond mais elle permet de mettre la JSM en état erreur.

La JSM n'envoie alors plus ses trames de contrôle XY.

Profiter pour envoyer vos trames de controleXY au power module (PM) en vous faisant passer pour le joystick (JSM).

On s'attend à ce que les roues se mettent à tourner en cohérence de la commande envoyée.

• [Mode JSMFollow]

Ce cas est intéressant pour garder le contrôle du JSM. Ce cas n'a pas été réalisé lors du Fabrikarium.

Exemples:

$ candump can0 -L   # -L puts in log format
(1469933235.191687) can0 00C#
(1469933235.212450) can0 00E#08901C8A00000000
(1469933235.212822) can0 7B3#
(1469933235.251708) can0 7B3#
$ cansend can0 181C0D00#0840085008440840  #play a tune
$ cangen can0 -e -g 10  -v -v     #fuzz buss with random extended frames+data
$ candump -n 1 can0,7b3:7ff     #wait for can id 7B3

• Mode JSMEmulate]

Avec ce mode de fonctionnement il est possible de remplacer complètement le JSM. C'est ce mode qui permettrait de développer de nouvelles possibilités d'utilisation du fauteuil (Domotique, ... )

4. Démo Manette Xbox360

Lancer sur la raspberry `python3 runJSMExploit.py` pour contrôler un PWC basé sur R-Net en utilisant n’importe quel gamepad USB connecté au pi3. Python 3 est requis.

 MHK-can2RNET/runJSMExploit.py
 #!/python3

 import can2RNET
 import threading

 from common import logger, dec2hex, createJoyFrame, FRAME_JSM_INDUCE_ERROR
 from time import time, sleep

 def run(cansocket):
    logger.warning("Inducing JSM error:")
    # send in less than 1ms theses frames to induce
    # JSM error
    for _ in range(5):
        can2RNET.cansend(cansocket, FRAME_JSM_INDUCE_ERROR)

    # now let's take over by sending our own
    # joystick frame @100Hz

    mintime = .01
    nexttime = time() + mintime
    while True:
        # get new XY joystick increment
        joystick_x, joystick_y = get_new_joystick_position()
        # building joy frame
        joyframe = createJoyFrame(joystick_x, joystick_y)
        # sending frame
        can2RNET.cansend(cansocket, joyframe)
        # .. at 100 Hz ..
        nexttime += mintime
        t = time()
        if t < nexttime:
            sleep(nexttime - t)
        else:
            nexttime += mintime


 if __name__ == "__main__":
    AG = False
    logger.info("try opening socketcan:")
    try:
        cansocket = can2RNET.opencansocket(0)
    except Exception as e:
        if AG:
            logger.warn(
                "opening specific ag udp sockets to send can frames:")

            import udp2can
            cansocket = udp2can.getUDP2CANSock()
        else:
            raise e

    logger.info("loading gamepad")
    import devXbox360
    dev = devXbox360.DevXbox360()
    watcher = devXbox360.Watcher(dev)
    dev.start()
    watcher.start()

    # set 'get_new_joystick_position' method
    # to fetch new joystick position from xbox360 gamepad device
    def get_new_joystick_position():
        return dev.joystick_x, dev.joystick_y

    logger.info("run exploit JSM Error")
    run(cansocket)
}}

Développement à venir

• Changer le mode de fonctionnement de communication à distance, actuellement JSMerror (contrôlé par une manette xbox), par le mode FollowJSM.
• Tester les modes de fonctionnement avec une carte PiCAN qui n'a pas pû être fait lors du Fabrikarium.