Arduino 33 BLE - piloter servomoteur en bluetooth

Bonjour à toutes et à tous,

Je me tourne vers vous comme je suis quelque peu perdu, pour mon premier projet avec une Arduino (33 BLE).

Je cherche à pouvoir gérer un servo moteur à distance, depuis mon téléphone (iOS) en bluetooth.

Les tests que j'ai pu faire en filaire via l'IDE sont concluant, je gère le servo à ma guise.

J'aimerais donc maintenant pouvoir faire la même chose en BLE, avec à terme avoir un interface avec des boutons assignés à des positions d'angle du servo, et pourquoi pas un potentiomètre virtuelle.
Est-ce bien possible ? J'imagine que oui

J'effectue pas mal de recherches sur le web, mais je n'arrive pas à axer mes recherches de façon concluante, pour savoir quelle direction prendre.
Pourriez-vous m'aiguiller, me donner des pistes ?

Bonsoir

Vois l'application RemoteXY , il me semble qu'elle pourrait facililiter les choses dans ton cas : interaction entre Ios et une carte Arduino par Bluetooth BLE avec comme fonction de piloter un servo

Exemple : Connect servo and operate with smartphone

Pour la carte Arduino 33 BLE (que je connais mal) c'est sans doute la programmation en UART BLE qui est à exploiter.

Merci beaucoup, je me penche là dessus !

De ce que je comprends je ne peux malheureusement pas l'utiliser, comme je ne peux pas utiliser la bibliothèque "servo.h", sans passer par les ports TX et RX... :

There is one feature of the use of the library "servo.h". It can not be used in conjunction with a library of software serial port "SoftwareSerial.h". These libraries use the combined resources of the microcontroller. Servos will twitch, as maintaining a constant pulse duration will be impossible. To solve this problem to communicate with library RemoteXY configure a hardware serial port.

Bonjour

Cette réserve concerne les situations où un module Bluetooth (HC-05, HC-06, HM-11...) serait raccordé au microncontrolleur par un port série logiciel pour ajouter la connectivité Bluetooth.
Avec une carte Arduino 33 BLE c'est hors sujet, le Bluetooth BLE étant intégré dans le microcontrolleur.
Pas besoin de SoftwareSerial pour avoir du BLE, pas de conflit avec la librairie servo
Même situation qu'avec un ESP32.

Merci pour ces précieux renseignements. Je vais tenter de pousser cela alors !

Bonsoir,

Bon et bien... je viens de checker de nouveau cela, tenter d'y voir un peu plus clair dans ce qui concerne la mise en oeuvre d'une connexion bluetooth.
Je (pense) percevoir un peu plus de choses quant à l'UUID, les charateristics, services.., grâce à quelques lectures sur ces sujets (rien en Français, du coup je ne fais malheureusement que nager en surface je crois), et les exemples de l'IDE dans la section "ArduinoBLE" (qui fonctionnent sans soucis quand je les tests)...
Mais quelque chose m'échappe, sûrement l'essentiel du coup, comme je n'arrive pas à établir de connexion entre l'Arduino et mon téléphone (et donc RemoteXY) quand je ne passe plus par ces exemples

Peut être pourriez-vous m'aiguiller pour que je me sente moins bête, et réussisse (enfin !) à effectuer cela ? Peut être auriez-vous un bout de code qui correspond à ce que je cherche à faire ?

Un grand merci !

Bonsoir

Dès qu'il s'agit de créer à partir de zéro un périphérique le BLE c'est la prise de tête assurée...

En BLE je n'utilise pas la carte Arduino 33 BLE, mais uniquement l'ESP32 ou un HM-10

Dans les exemples de la librairie BLE fournie pour la carte 33 BLE n'y en aurait-il pas un qui émule une liaison série ? c'est avec ce type de périphérique BLE que RemoteXY sait dialoguer, il se connecte à tout

En général dans toute bonne librairie BLE il y a un exemple de ce type avec UART ou Serial dans le nom.

En cas d'absence d'un tel exemple (très regrettable vu l'usage fréquent) tu peux peut tenter de transposer à ta librairie l'exemple fourni içi pour l'ESP32 :

(RemoteXY accepte de se connecter à un ESP32 faisant tourner cet exemple)

Le 'profil' d'émulation série en BLE proposé par Nordic Semiconductor est défini ici (pas de profil BLE standard pour cette fonctionnalité):
https://infocenter.nordicsemi.com/index.jsp?topic=%2Fcom.nordic.infocenter.sdk5.v14.0.0%2Fble_sdk_app_nus_eval.html

Je vous met à disposition un code en fichier joint, il faudra peut être effectuer des modifications sur les tampons.

Essayez et vous verrez bien, cela peut être une base aussi.

UART_BLE_HM10_NO_EVENT.zip (2.89 KB)

Essayez et vous verrez bien, cela peut être une base aussi.

+1

Ce code reproduit l'UART BLE en version 'HM10' donc avec un jeu services/caractéristiques différent de la poposition de Nordic Semicondictor.

XYremote sait se connecter avec un périphérique utilisant ceffe façon de faire, Bluetooth Electronics également.

@al1fch , le problème, c'est que remoteXY nécessite une librairie et il va créer une liaison série pour communiquer avec le module bluetooth alors qu'il est intégré, j'avais dû le tester avec Bluetooth Electronics qui lui ne nécessite pas de librairie pour le tester mais il n'y a pas de version pour ios.

@nico78
oui mais .... RemoteXY sait déjà gérer le module BLE intégré à l'ESP32, (testé)

En étudiant la librairie fournie et en transposant à la librairie BLE des Nano 33 BLE il reste de l'espoir...
Avec le code que tu as posté plus haut au message #8 (nano 33 BLE en émulation HM-10) la compatibilité de RemoteXY avec les cartes nano 33 BLE n'est peut être pas éloignée !!

Dernière version de la libaririe RemoteXY :

Configuration :
2021-03-22_23-04.png
Avoir les fichiers .h joints où l'ESP32 émule un HM-10
Voici le sketch de test qui tourne sur ESP32 avec son BLE interne

/*
  RemoteXY example. 
  Smartphone connect via BLE on ESP32.
  This shows an example of using the library RemoteXY.
  In the example you can control the LED pin 2 using the button on the 
  smartphone. The example uses the BluetoothSerial library which is a standard 
  library in the Arduino IDE on ESP32. 
  
  Download the mobile app from the 
  website: http://remotexy.com/download/ for connect this sketch.
  
  Use the website http://remotexy.com/ to create your own management 
  interface your arduino with your smartphone or tablet.
  You can create different management interfaces. Use buttons, 
  switches, sliders, joysticks (g-sensor) all colors and sizes 
  in its interface. Next, you will be able to get the sample 
  code for arduino to use your interface for control from a 
  smartphone or tablet. You will not need to re-install the 
  android app, as it will determine which interface you have 
  downloaded the arduino.
 */

///////////////////////////////////////////// 
//        RemoteXY include library         // 
///////////////////////////////////////////// 

//#define REMOTEXY__DEBUGLOGS Serial

// RemoteXY select connection mode and include library 
#define REMOTEXY_MODE__ESP32_BLE 
#include <RemoteXY.h>

// RemoteXY connection settings
#define REMOTEXY_BT_DEVICENAME "RemoteXY32"

// RemoteXY configurate 
//unsigned char RemoteXY_CONF[] = 
//  { 1,0,11,0,1,5,1,0,21,2
//  ,59,59,2,88,0 }; 

// ci dessous l'interface graphique
uint8_t RemoteXY_CONF[] =
  { 255,2,0,1,0,36,0,10,13,0,
  2,0,34,8,30,17,2,26,31,31,
  79,78,0,79,70,70,0,66,131,27,
  36,45,19,2,24,4,0,84,8,12,
  49,2,26 };
  
// this structure defines all the variables of your control interface
struct { 

    // input variable
  //unsigned char button_1; // =1 if button pressed, else =0 
  uint8_t switch_1; // =1 if switch ON and =0 if OFF
  int8_t slider_1; // =0..100 slider position 

    // other variable 
  unsigned char connect_flag;  // =1 if wire connected, else =0 

} RemoteXY; 

///////////////////////////////////////////// 
//           END RemoteXY include          // 
///////////////////////////////////////////// 

#define LED_BUILTIN 22

void setup()  
{ 
  RemoteXY_Init ();  
  pinMode (LED_BUILTIN, OUTPUT);   
} 

void loop()  
{  
  RemoteXY_Handler ();   
  digitalWrite(LED_BUILTIN, (RemoteXY.switch_1==0)?LOW:HIGH);
}

2021-03-22_23-04.png

RemoteXY_ESP32_BLE.ino (2.31 KB)

RemoteXYStream_BLEDevice.h (4.67 KB)

RemoteXYStream_BluetoothSerial.h (893 Bytes)

Bonsoir à tous les 2,

Merci de vos échanges, je les ai découvert il y a quelques heures...!

Grâce au code joint par Nico78 au message #8, l'appli RemoteXY détecte l'UART Arduino (merci, c'est déjà une bonne étape qui donne du baume au coeur :)) ).

J'essaie donc d'y intégrer le code source généré par RemoteXY après l'édition de l'interface que je souhaite.
Mais une erreur sur l'indique m'indique "Erreur de compilation pour la carte Arduino Nano 33 BLE"
Peut être est-ce une histoire de bibliothèques que j'aurais mal géré ?

Je vous joins là le code que j'ai maintenant:

#include <ArduinoBLE.h>

const unsigned int tamponBluetooth = 244;
char receiveBluetooth[tamponBluetooth + 1] = {0,};


///////////////////////////////////////////CONFIG CONNEXION BLE - DEBUT//////////////////////////////////////

//Ne pas changer (tampon max de 20 octets pour une notification, restriction du bluetooth 4.0 et 4.1, 4.2 permettrait 244 octets normalement)
// pour les tests avec appli android, conserver la valeur de 20 ne donnera pas de surprise quand au résultat
const unsigned int tamponPortSerie = 20;
char receptionPortSerie[tamponPortSerie + 1] = {0,}; // + 1 pour le '\0' de fin de chaine

BLEService UARTService("0000ffe0-0000-1000-8000-00805f9b34fb");
BLECharacteristic TX_RX("0000ffe1-0000-1000-8000-00805f9b34fb", BLEWriteWithoutResponse | BLENotify, tamponBluetooth);

BLEDevice central;


//////////////////////////////////////////////
//        RemoteXY include library          //
//////////////////////////////////////////////

// RemoteXY select connection mode and include library 
#define REMOTEXY_MODE__SOFTSERIAL
//#include <SoftwareSerial.h>

#include <RemoteXY.h>

// RemoteXY connection settings 
#define REMOTEXY_SERIAL_RX 2
#define REMOTEXY_SERIAL_TX 3
#define REMOTEXY_SERIAL_SPEED 9600


// RemoteXY configurate  
#pragma pack(push, 1)
uint8_t RemoteXY_CONF[] =
  { 255,1,0,0,0,11,0,11,13,0,
  4,128,15,14,66,17,2,26 };
  
// this structure defines all the variables and events of your control interface 
struct {

    // input variables
  int8_t slider_1; // =0..100 slider position 

    // other variable
  uint8_t connect_flag;  // =1 if wire connected, else =0 

} RemoteXY;
#pragma pack(pop)

/////////////////////////////////////////////
//           END RemoteXY include          //
/////////////////////////////////////////////


#include <Servo.h>  

Servo myservo; 

void setup() {
  Serial.begin(9600);
  while (!Serial);

  if (!BLE.begin()) {
    Serial.println("starting BLE failed!");
    while (1);
    
      RemoteXY_Init (); 
  
  // TODO you setup code
   myservo.attach(9); 
  RemoteXY.slider_1 = 50; 
  
  }

  // Nom lié au service GENERIC ACCESS 0x1800 (c'est un service obligatoire)
  BLE.setDeviceName("UART Service");

  // Nom qui apparait lors d'un scan
  BLE.setLocalName("UART BLE");

  // Déclaration du service que l'on veut offrir
  //BLE.setAdvertisedServiceUuid(UARTService.uuid());
  BLE.setAdvertisedService(UARTService);

  UARTService.addCharacteristic(TX_RX);

  BLE.addService(UARTService);

  // Démarrer la publication du service
  BLE.advertise();

  Serial.println("UART Service");
  ///////////////////////////////////////////CONFIG CONNEXION BLE - END//////////////////////////////////////
}

 void loop() {
  int ret = 0;
  static int etat = 0, souscrit = 0;

  // Nous sommes un périphérique esclave (serveur)
  // et nous attendons une connexion centrale maitre (client)

  // En attente de connexion d'un client
  central = BLE.central();

  // etat est utilisé pour éviter la répétition de l'information
  if (etat == 0) {
    etat = 1;
    Serial.println("périphérique esclave (serveur), en attente de connexion d'un client maitre");
    Serial.println("");
  }

  // Test si un appareil s'est connecté
  if (central) {
    delay(500);
    Serial.print("Connecté à l'appareil suivant: ");
    Serial.println(central.address());
    Serial.println("");

    while (central.connected()) {
      if (TX_RX.subscribed()) {
        if (souscrit != 1) {
          souscrit = 1;
          Serial.println("Notification activée!");
        }
      } else {
        if (souscrit != 0) {
          souscrit = 0;
          Serial.println("Notification désactivée!");
        }
      }
      // ***********************************************************************
      // **** Lecture des données reçues du port série *************************
      if (Serial.available() > 0) {
        memset(receptionPortSerie, 0, tamponPortSerie);
        for (unsigned int i = 0; i < tamponPortSerie; ++i) { // lecture par bloc de 20 max
          receptionPortSerie[i] = Serial.read();
          if (receptionPortSerie[i] == '\r' || receptionPortSerie[i] == '\n' ) {
            break;
          }
        }
        // *********************************************************************
        // **** Envoie des données du port Série sur le module Bluetooth **
        if (writeBleUART(receptionPortSerie))
        {
          Serial.print("Longueur envoyées: ");
          Serial.println(strlen(receptionPortSerie));
          Serial.print("Données envoyées: ");
          Serial.println(receptionPortSerie);
        } else {
          Serial.print("Une erreur s'est produite pour l'envoie des données");
        }
        // *********************************************************************
      }

      //***********************************************************************
      //**** Lecture des données du module Bluetooth **************************
      ret = readBleUART();
      if (ret == -1) {                     // si retour = 0
        Serial.println("Une erreur s'est produite!");
      }
      //*************************************************
      // ******* Votre code personnel ici ***************
      //*************************************************

 RemoteXY_Handler (); 

  // TODO you loop code 
  // use the RemoteXY structure for data transfer 

  int ms = RemoteXY.slider_1*20+500; 
  myservo.writeMicroseconds(ms);
      
    }

    Serial.print("Déconnecté du central: ");
    Serial.println(central.address());
    Serial.println("");
    etat = 0;
  }
}


int writeBleUART(char text[]) {
  if (TX_RX.writeValue(text, strlen(text))) {
    Serial.print("Size: ");
    Serial.println(strlen(text));
    Serial.print("  Données envoyées: ");
    Serial.println(text);
    return 1;
  }
  return 0;
}

int readBleUART(void) {
  int ret = 0, lenData = 0;

  if (TX_RX.written()) {
    lenData = TX_RX.valueLength();
    if (lenData) {
      memset(receiveBluetooth, 0, tamponBluetooth);
      ret = TX_RX.readValue(receiveBluetooth, lenData);
      if (ret != lenData) {
        return -1;
      }
    }
  }
  return ret;
}

Merci encore !

Bonjour

Le test de ton code serait facilité si tu utilisais des balises code et non quote

Pour quelle carte configures-tu remoteXY ? avc quel type d'interface BLE ?
Librairie RemoteXY telle quelle ou modifiée ?

le forum de RemoteXY est sans doute l'endroit ou poser la question
ici elle apparait pour une carte Nano 33 IOT : Support for WiFiNINA? (Page 1) — Ideas and suggestions — RemoteXY community

Bonjour,

J'ai modifié l'insertion du code dans mon message précédent :wink: Je prends bonne note pour la suite.

C'est pour une nano 33 BLE, équipée d'une interface sans fil NINA B306: BLE et Bluetooth 5
Je n'ai pas modifié la librairie RemoteXY, simplement mis la dernière à jour depuis leur site.

Je vais jeter un oeil sur le forum du site oui !

C'est pour une nano 33 BLE, équipée d'une interface sans fil NINA B306: BLE et Bluetooth 5

ça j'ai compris , ma question porte sur la configuration choisie sur le site RemoteXY en rempalcement de la tienne qui n'est pas proposée.

Le décalage entre la configuaion réelle et celle annoncée sur le site RemoteXY avant de générer le code pourrait nécessiter des modifications dans la librairie RemoteXY

J'ai tenté:
• Bluetooth + Arduin Nano + HM10
• Bluetooth + ESP32 + Bluetooth on chip

et la libaririe RemoteXY est la version 2.4.6 proposée par le gestionnaire de librairies de l'IDE Arduino ?

le code que tu a publié plus haut ne gère pas RemoteXY par le BLE de ta carte mais par un module HM10 censé être câble en pins 2 et 3 et géré en sofware Serial :

// RemoteXY select connection mode and include library
#define REMOTEXY_MODE__SOFTSERIAL
//#include <SoftwareSerial.h>

#include <RemoteXY.h>

// RemoteXY connection settings
#define REMOTEXY_SERIAL_RX 2
#define REMOTEXY_SERIAL_TX 3
#define REMOTEXY_SERIAL_SPEED 9600

This topic was automatically closed 120 days after the last reply. New replies are no longer allowed.