[JAVA] Développement d'applications ROS sur Android

Contenu de cet article

Je vais vous expliquer l'application tutoriel pour la communication Pub-Sub de ROS (Robot Operating System) sur Android. L'application Android ROS est développée avec rosjava, mais j'ai créé un article car la quantité d'informations en japonais est inférieure ou antérieure à roscpp et rospy.

En gros, je me réfère au tutoriel ROS.org http://wiki.ros.org/android.

Connaissances préalables

--Connaissance générale du développement d'applications Android --Connaissance générale du développement ROS

Contenu du tutoriel

Ici, en supposant que ROS Master fonctionne sur le PC ROS, vérifiez l'opération d'abonnement du message publié sur le smartphone sur le PC ROS (+ le smartphone lui-même).

Environnement de vérification de fonctionnement

• téléphone intelligent

  • Nexus 5X
  • Android 6.0.1

• ** Développement d'applications PC ** Utilisé pour le développement d'applications Android.

  • Windows 7 Professional
  • Android Studio 3.2.1

• ROS PC Il est utilisé pour vérifier la communication Pub-Sub entre les terminaux. Vous pouvez vérifier le fonctionnement uniquement avec le smartphone.

  • Ubuntu 16.04
  • ROS Kinetic

Préparation

La procédure détaillée pour chaque élément est omise car elle est introduite sur d'autres sites.

• ** Développement d'applications PC ** Il semble qu'il était nécessaire de créer un environnement ROS sur le PC de développement d'applications auparavant, mais maintenant il ne peut être développé qu'avec Android Studio. --Installez Android Studio --Installez le pilote USB du Nexus 5X --Installez le SDK avec l'API 15 ou supérieur

• ROS PC --Installez ROS Kinetic

• ** Réseau ** Connectez votre smartphone et votre PC ROS au même réseau. Dans mon environnement, l'adresse IP est la suivante. --Smartphone: 192.168.0.14

  • ROS PC：192.168.0.15

Procédure de développement d'applications

• ** Créez une application avec Nouveau-> Nouveau projet dans Android Studio **

• Sélectionnez l'API 15 ou version ultérieure pour "Appareils Android cibles" dans "Téléphone et tablette" -Sélectionnez «Activité vide» pour «Ajouter une activité au mobile» --Autre que ça, c'est OK par défaut

• ** Modifier build.gradle (niveau supérieur) **

build.gradle

// Top-level build file where you can add configuration options common to all sub-projects/modules.

buildscript {
    repositories {
        google()
        jcenter()
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:3.2.1'

        // NOTE: Do not place your application dependencies here; they belong
        // in the individual module build.gradle files
    }
}

buildscript {
    apply from: "https://github.com/rosjava/android_core/raw/kinetic/buildscript.gradle"
}

subprojects {
    apply plugin: 'ros-android'

    afterEvaluate { project ->
        android {
            // Exclude a few files that are duplicated across our dependencies and
            // prevent packaging Android applications.
            packagingOptions {
                exclude "META-INF/LICENSE.txt"
                exclude "META-INF/NOTICE.txt"
            }
        }
    }
}

allprojects {
    repositories {
        google()
        jcenter()
    }
}

task clean(type: Delete) {
    delete rootProject.buildDir
}

Ici, dans le tutoriel d'origine

Edit the top-level build.gradle file and replace this part:

• "Premier buildscript" *

with this:

• "Second buildscript" *

Il y a une déclaration (j'ai ajouté l'accent sur remplacer), mais dans mon environnement, j'ai eu une erreur lorsque j'ai supprimé le premier buildscript, donc je l'ai laissé tel quel.

• ** Modifier build.gradle (application) **

build.gradle

apply plugin: 'com.android.application'

android {
    compileSdkVersion 28
    defaultConfig {
        applicationId "goodclues.example.myrosapplication"
        minSdkVersion 15
        targetSdkVersion 28
        versionCode 1
        versionName "1.0"
        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
    }
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
    }
}

dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar'])
    implementation 'com.android.support.constraint:constraint-layout:1.1.3'
    testImplementation 'junit:junit:4.12'
    androidTestImplementation 'com.android.support.test.espresso:espresso-core:3.0.2'
    implementation 'org.ros.android_core:android_15:[0.3,0.4)'
}

La dernière «implémentation» est «compiler» à la maison, mais elle semble désormais obsolète. ~~ Aussi, changeons le nombre de 15 "android_15" en fonction du niveau d'API. ~~ (← Veuillez noter dans les commentaires, il semble que le numéro et le niveau d'API ne soient pas liés. De plus, il semble que la méthode de description ait changé maintenant, veuillez donc consulter le tutoriel pour les dernières informations.)

• ** Ajouter des autorisations à AndroidManifest.xml **

<uses-permission android:name="android.permission.INTERNET" />

Autorisation d'utiliser le réseau.

• ** Ajouter une activité à AndroidManifest.xml **

<activity android:name="org.ros.android.MasterChooser" />

Master Chooser est une activité pour spécifier l'URI du maître ROS. Si vous décrivez cela, l'écran de réglage s'affichera automatiquement au démarrage de l'application. Vous pouvez également coder en dur l'URI maître, mais consultez le didacticiel d'origine pour savoir comment procéder.

• ** Ajoutez ce qui suit à AndroidManifest.xml **

<application xmlns:tools="http://schemas.android.com/tools"
        tools:replace="android:icon"
        ...(Suite ci-dessous)

Je ne sais pas pourquoi, mais sans cela, j'obtiens une erreur. Le fichier manifeste final ressemble à ceci:

AndroidManifest.xml

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="goodclues.example.myrosapplication">

    <uses-permission android:name="android.permission.INTERNET" />

    <application xmlns:tools="http://schemas.android.com/tools"
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/AppTheme"
        tools:replace="android:icon">
        <activity android:name=".MainActivity">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
        
        <activity android:name="org.ros.android.MasterChooser" />
    </application>

• ** Changer le texte de activity_main.xml **
• Changement de la vue TextView par défaut en org.ros.android.view.RosTextView
• Ajout de id = "@ + id / texte"

activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<android.support.constraint.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">

    <org.ros.android.view.RosTextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Hello World!"
        android:id="@+id/text"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintLeft_toLeftOf="parent"
        app:layout_constraintRight_toRightOf="parent"
        app:layout_constraintTop_toTopOf="parent" />

</android.support.constraint.ConstraintLayout>

• ** Modifier MainActivity **

Pour utiliser ROS, créez une activité qui étend RosActivity. L'exemple ci-dessous a une classe appelée Talker qui publie un message / chatter et une vue qui s'abonne à un sujet de discussion appelé RosTextView.

La classe Talker publie en interne un nombre qui est incrémenté chaque seconde.

MainActivity.java

/*
 * Copyright (C) 2011 Google Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not
 * use this file except in compliance with the License. You may obtain a copy of
 * the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations under
 * the License.
 */
package goodclues.example.myrosapplication;

import android.os.Bundle;
import org.ros.android.MessageCallable;
import org.ros.android.RosActivity;
import org.ros.android.view.RosTextView;
import org.ros.node.NodeConfiguration;
import org.ros.node.NodeMainExecutor;

/**
 * @author [email protected] (Damon Kohler)
 */
public class MainActivity extends RosActivity {

    private RosTextView<std_msgs.String> rosTextView;
    private Talker talker;

    public MainActivity() {
        // The RosActivity constructor configures the notification title and ticker
        // messages.
        super("Pubsub Tutorial", "Pubsub Tutorial");
    }

    @SuppressWarnings("unchecked")
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        rosTextView = (RosTextView<std_msgs.String>) findViewById(R.id.text);
        rosTextView.setTopicName("chatter");
        rosTextView.setMessageType(std_msgs.String._TYPE);
        rosTextView.setMessageToStringCallable(new MessageCallable<String, std_msgs.String>() {
            @Override
            public String call(std_msgs.String message) {
                return message.getData();
            }
        });
    }

    @Override
    protected void init(NodeMainExecutor nodeMainExecutor) {
        talker = new Talker();

        // At this point, the user has already been prompted to either enter the URI
        // of a master to use or to start a master locally.

        // The user can easily use the selected ROS Hostname in the master chooser
        // activity.
        NodeConfiguration nodeConfiguration = NodeConfiguration.newPublic(getRosHostname());
        nodeConfiguration.setMasterUri(getMasterUri());
        nodeMainExecutor.execute(talker, nodeConfiguration);
        // The RosTextView is also a NodeMain that must be executed in order to
        // start displaying incoming messages.
        nodeMainExecutor.execute(rosTextView, nodeConfiguration);
    }
}

J'emprunte l'échantillon presque tel quel. Cependant, à la tête de la famille

import org.ros.rosjava_tutorial_pubsub.Talker;

Cependant, dans mon environnement, j'ai eu une erreur, j'ai donc copié la source suivante et créé une classe Talker dans mon projet. http://docs.ros.org/hydro/api/rosjava_core/html/Talker_8java_source.html

Contrôle de fonctionnement

Démarrez roscore sur le PC ROS.

$ roscore

Ensuite, lorsque vous démarrez l'application, l'écran de configuration de la connexion ROS Master suivant s'affiche. (Si vous cochez Afficher les options avancées, vous verrez un bouton pour définir les paramètres réseau détaillés et le smartphone lui-même un ROS Master, mais je l'omettrai ici car ce n'est pas nécessaire)

Entrez l'URI maître ROS dans "URI maître". Ce n'est pas grave si vous changez l'endroit où il est "localhost" en "192.168.0.15" défini ci-dessus. Ensuite, appuyez sur CONNEXION et si la connexion réussit, elle passera à l'activité principale.

Le numéro affiché à droite de Hello world! Est le message auquel vous vous abonnez (publié par vous-même).

Maintenant, vérifions si vous pouvez vous abonner sur ROS PC. Au terminal

$ rostopic echo /chatter

Puis

data: "Hello world! X"

Si le message est émis à intervalles réguliers comme celui-ci, il réussit. (X est un nombre)

en conclusion

J'ai expliqué la procédure de développement d'applications Android qui réalise une communication Pub-Sub simple avec le tutoriel de ROS.org. Cela facilitera la liaison du robot avec une caméra de smartphone, etc., alors essayez-le.