Projet petit Logger commandé par BLE

International Français
1

Bonjour alors voila je suis en train de fabriquer un Logger ultra léger.

pour cela j'utilise les 4 cartes donné ci dessous pour les caractéristique suivante :

Une tinytile coeur du systeme (avec un intel curie) 6 axe + gyroscope +BLE
une carte RTC PCF 8523 (adafruit)
une carte Micro-SD (pour le logger)
une carte équipé d'un chargeur induction pour charger la batterie lithium de 3.7 300mAh

Dans l'idée je souhaite utilisé 3 cartes tinytile 1 en master 2 en slave
la première et relier à un ordinateur et envoie des commandes via le BLE au 2autres cartes

les commandes sont :

START enregistrement
STOP enregistrement
Synchro RTC
et une commande qui liste les fichiers enregistré

Description de ce que je veux faire :

une synchro met à l'heure les 2 RTC des cartes logger via une transmission de l'heure PC via la carte master qui y est raccordé peut mettre mettre ca dans le setup est une bonne idée.

Alors START crée un fichier CVS qui prend pour nom la date et l'heure du RTC et enregistre les 6 axes de laccelero et le gyroscope et certain angle calculer via les data enregistré. Le fichier ne dépasse pas plus d'une minute d'enregistrement à 100hz
et se recrée toute les 1minutes jusqu'à lenvoie d'une commande STOP.

Une commande DIR qui liste les fichiers et leur taille pour vérifier que tout ce passe bien.

Alors moi jusqu'ici j'ai utilisé un code exemple pour allumer et éteindre une led a distance via le BLE que voici ci dessous

  • il ne s'adresse qu'à une seul périphérique au lieu de 2
  • il ne transmets pas la Synchro RTC via le BLE
    Mais il me laisse pensé que je peux m'appuyer dessus pour réaliser ce que je souhaite faire :
#include <CurieBLE.h>
const size_t INPUT_SIZE = 128;

void setup()
{
// initialisation port serie
Serial.begin(9600);
//
BLE.begin();
Serial.println("BLE central - Commande LED");
Serial.println(" INITIALISATION ... (waiting)");
Serial.println();
Serial.println();
Serial.println("____________ COMMANDE SHELL_____________");
Serial.println("");
Serial.println("CMD = START        Starting Logger");
Serial.println("CMD = STOP         Stop Logger");
Serial.println("CMD = SYNCH        demande l'heure au RTC");
Serial.println("CMD = DIR          Arboressence du repertoire root");
Serial.println("CMD = CUCU         ben la sa sert a rien ");
Serial.println("");
Serial.println("____________ COMMANDE FIN_______________");

Serial.println();
Serial.println();
//débute un scan des réseaux BLE
BLE.scanForUuid("19b10000-e8f2-537e-4f6c-d104768a1214");

}

void loop()

{
   
    BLEDevice peripheral = BLE.available();
    if (peripheral)
    {
      Serial.print("Periph Trouvé : ");
      Serial.print(peripheral.address());
      Serial.print(" : ");
      Serial.print(peripheral.localName());
      Serial.print(" : ");
      Serial.print(peripheral.advertisedServiceUuid());
      Serial.println();
      BLE.stopScan();
      Shellcommande(peripheral);
      BLE.scanForUuid("19b10000-e8f2-537e-4f6c-d104768a1214");     
    }

}


void Shellcommande(BLEDevice peripheral)
{
Serial.println("connexion au peripherique en cours ....");
  if(peripheral.connect())
  {
    Serial.println ("connexion effectuée bienvenu au japon ");
    Serial.println ("");
    Serial.println ("");
    Serial.println ("_________ HISTORIQUE DE COMMANDE_________");
  }else{
    Serial.println("connexion échoué rateau dans ta geule");
    return;
  }
//Serial.println("Attribu du peripherique en cours...");
if(peripheral.discoverAttributes())
{
  //Serial.println("Attribu decouvert ca envoie du lourd ");
}else{
  Serial.println("attribu qui a trop bu echec de lecture des attribu");
  peripheral.disconnect();
  return;
  }



BLECharacteristic ledCharacteristic = peripheral.characteristic("19b10001-e8f2-537e-4f6c-d104768a1214");

  if (!ledCharacteristic) {
    Serial.println("Peripheral does not have LED characteristic!");
    peripheral.disconnect();
    return;
  } else if (!ledCharacteristic.canWrite()) {
    Serial.println("Peripheral does not have a writable LED characteristic!");
    peripheral.disconnect();
    return;
  }




while(peripheral.connected())
  {

     if ( Serial.available() > 0 )
    {
     
    static char input[ INPUT_SIZE ];
    static char CMD0 [6]  = "START";
    static char CMD1 [5]   = "STOP" ;
    static char CMD2 [6]  = "SYNCH";
    static char CMD3 [5]   = "DIR" ;
    static char CMD4 [5]   = "CUCU" ;
    static uint8_t i;
   
    char c = Serial.read();
   
    if ( c != '\n' && i < INPUT_SIZE - 1 )
      input[ i++ ] = c;
     else
      {
      input[ i ] = '\0';
      i = 0;
     
      Serial.print( "Commande envoyé: " );
      Serial.println( input );
      if (strcmp(input, CMD0) == 0)
      {
        ledCharacteristic.writeChar(strcmp(input, CMD0));
        Serial.println("Data_logger_Start");
      }else if (strcmp(input, CMD1) == 0)
             {
              ledCharacteristic.writeByte(0x00);
              Serial.println("Data_Logger_Stop");
             }else if(strcmp(input, CMD2) == 0)
                      {
                         Serial.println("RTC_SYNCHRONISATION");
                         Serial.println("command qui fait rien mais qui va transmetre l'horloge");
                         
                      }else if (strcmp(input, CMD3) == 0)
                              {
                                Serial.println("Analyse_Repertoire");
                               
                              }else if (strcmp(input, CMD4) == 0)
                                     {
                                      Serial.println("PAS DIDEE");
                                     
                                     }else{
                                            Serial.println(" Erreur commande");
                                          }
             
        }
      }
 }
  Serial.println("peripherique déconnecté");
2

recepteur :

Code: [Select]



include <CurieBLE.h>

const int ledPin = 13; // set ledPin to use on-board LED

BLEService ledService("19B10000-E8F2-537E-4F6C-D104768A1214"); // create service

// create switch characteristic and allow remote device to read and write
BLECharCharacteristic switchChar("19B10001-E8F2-537E-4F6C-D104768A1214", BLERead | BLEWrite);

void setup() {
  Serial.begin(9600);
  pinMode(ledPin, OUTPUT); // use the LED on pin 13 as an output

  // begin initialization
  BLE.begin();

  // set the local name peripheral advertises
  BLE.setLocalName("LEDCB");
  // set the UUID for the service this peripheral advertises
  BLE.setAdvertisedService(ledService);

  // add the characteristic to the service
  ledService.addCharacteristic(switchChar);

  // add service
  BLE.addService(ledService);

  // assign event handlers for connected, disconnected to peripheral
  BLE.setEventHandler(BLEConnected, blePeripheralConnectHandler);
  BLE.setEventHandler(BLEDisconnected, blePeripheralDisconnectHandler);

  // assign event handlers for characteristic
  switchChar.setEventHandler(BLEWritten, switchCharacteristicWritten);
  // set an initial value for the characteristic
  switchChar.setValue(0);

  // start advertising
  BLE.advertise();

  Serial.println(("Bluetooth device active, waiting for connections..."));
}

void loop() {
  // poll for BLE events
  BLE.poll();
}

void blePeripheralConnectHandler(BLEDevice central) {
  // central connected event handler
  Serial.print("Connected event, central: ");
  Serial.println(central.address());
}

void blePeripheralDisconnectHandler(BLEDevice central) {
  // central disconnected event handler
  Serial.print("Disconnected event, central: ");
  Serial.println(central.address());
}

void switchCharacteristicWritten(BLEDevice central, BLECharacteristic characteristic) {
  // central wrote new value to characteristic, update LED
  Serial.print("Characteristic event, written: ");

  if (switchChar.value()) {
    Serial.println("LED on");
    digitalWrite(ledPin, HIGH);
  } else {
    Serial.println("LED off");
    digitalWrite(ledPin, LOW);
  }
}

code RTC:

Code: [Select]




#include "RTClib.h"

RTC_PCF8523 rtc;

char daysOfTheWeek[7][12] = {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"};

void setup () {

  while (!Serial) {
    delay(1); 
  }

  Serial.begin(57600);
  if (! rtc.begin()) {
    Serial.println("Couldn't find RTC");
    while (1);
  }

  if (! rtc.initialized()) {
    Serial.println("RTC is NOT running!");
   
    //rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
 
  }
}

void loop () {
    DateTime now = rtc.now();

    Serial.print(now.year(), DEC);
    Serial.print('-');
    Serial.print(now.month(), DEC);
    Serial.print('-');
    Serial.print(now.day(), DEC);
    Serial.print(" (");
    Serial.print(daysOfTheWeek[now.dayOfTheWeek()]);
    Serial.print(") ");
    Serial.print(now.hour(), DEC);
   
    Serial.print('H');
     Serial.print(' ');
    Serial.print(now.minute(), DEC);
   
    Serial.print('M');
    Serial.print(' ');
    Serial.print(now.second(), DEC);
   
    Serial.print('S');
    Serial.print(' ');
    Serial.println();

 
    delay(1000);
}

Bon voila jespere que la presentation du sujet est pas trop lourd donc ma premiere étape serai de transmettre le RTC a distance et de demander l'heure a la carte fille via le BLE.

J'ai fait le poste le plus claire possible :smiley: merci d'etre arrivé jusque la pour ce qui lisent ceci.

c'est parti!

3

alors dans le premier programme je ne voie pas comment récupérer l'heure du pc pour l'afficher dans le setup et la mettre dans une variable

Je suis en train d'explorer la librairie time.h je vais vou mettre le code que j'essaye de faire des qu jarrive plus à avancer si je peux avoir un coup de main

4

Re bon je suis en PLS je n'arrive pas a recuperer la date et heure du PC pour la stocker dans un tableau

un peut comme le fait la lib RTC avec la fonction:

rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));

pouvez vous m'aider ?

5

Je viens de poster une solution ici : [Résolu] lcd et heur - #27 by hbachetti - Français - Arduino Forum

6

tien donc je regarde :smiley: merci effectivement
j'avais résolut mon problème en utilisant 3 RTC au lieu de 2
de cette manière le centrale pouvait recouper l'heure du pc et utilisé la librairie RTClib.

Je suis passé au BLE 4.3 qui équipe la carte pour transmettre l'heure et diverse information au 2 cartes esclaves.

sauf que je viens de réalisé que le BLE ne fait pas de multi point meme si le service Uuid et le tableau on les même nom ... et que c'est une connexion une transmission de A vers B puis de A vers C ca m’embête un peut :slight_smile: car je voulais synchronisé mes 2 rtc des cartes esclave avec un broadcast et lancer une cation start ainsi que stop comme cela ...

j'ai juste ou je me trombe pour le point a point ?

7

Aucune idée. Je ne pratique pas BT, pas ma tasse de thé.
Je comprends l'intérêt de passer en BT entre un Android et un ARDUINO au ESP32, entre deux ARDUINO beaucoup moins.

8

ben je veux activer 2 carte qui font loggers en simultané a des endroits différent pour l'instant j’arrive a activé une led et éteindre une led sur une carte mais pas sur 2 en simultané

je vais tenté une autre approche en le faisant tour par tour .