Bienvenue aux nouveaux arrivants sur FantasPic !

- Pensez à lire les règles durant votre visite, il n'y en a pas beaucoup, mais encore faut-il les respecter .
- N’hésitez pas à faire des remarques et/ou suggestions sur le Forum, dans le but de l'améliorer et de rendre vos prochaines visites plus agréables.
- Vous pouvez regarder votre "panneau de l'utilisateur" afin de configurer vos préférences.
- Un passage par "l'utilisation du forum" est recommandé pour connaître les fonctionnalités du forum.

--- L’équipe FantasPic ---
Forum général sur le langage C !

Modérateur : Jérémy

Blue-Tooth recuperation de signal apres veille
Jérémy
Administrateur du site
Administrateur du site
Messages : 2722
Âge : 44
Enregistré en : juillet 2015
Localisation : Dans le sud
Contact :

#1 Message par Jérémy » mer. 22 juin 2016 20:31

Bonsoir à tous,

Je me rends compte qu'en postant dans la partie [PROJET] , tout le monde ne voit pas les messages !

Je re-post alors ici au cas où !

Je souhaite rendre nomade ma prise Blue-tooth "modifiée". Pour ce faire j'ai donc besoin d'économiser du courant . Mais le HIC c'est que je n'arrive pas à reprendre la com une fois sorti du mode veille , ou plutôt mon programme n’envoie plus de donnée, mais peut en recevoir. Je vous explique :

Tout d'abord la DS comprenant les commandes du module : LIEN

Actuellement niveau courant j'ai ça, vu a l'oscillo ( en // avec R de 1 Ohm) :

==> Non connecté : je suis à 18mA pendant 2.5s et j'ai un pic a 45mA pendant 0.6s environ . Ca correspond bien avec la DS et au mode par défaut, le module cherche si il y a d'autre périphérique.
==> Connecté la conso passe a 45-50mA en permanence , normale ils discutent entre eux. Ca correpond aussi à la DS

La configuration du module BT est celle-ci : :?:
[spoil]

Code : Tout sélectionner

//-----------------------   CONFIGURATION DU MODULE   ------------------------------
void  BT_Configure() {

  do {
     UART1_Write_Text("$$$");                  // On rentre dans la configuration
     Delay_ms(500);
  } while (BT_Get_Response() != BT_CMD);       // On reste ICI tant qu'on à pas la réponse du module BT

  do {
    UART1_Write_Text("SN,BT de Jeremy");       // Selection du Nom de notre module qui apparaitra lors de la recherche 20 caractéres max
    UART1_Write(13);
    UART1_Write(10);
    Delay_ms(500);
  } while (BT_Get_Response() != BT_AOK);      // On reste ICI tant qu'on à pas la réponse du module BT

   do {
    UART1_Write_Text("SO,Master");            // Extended status string , pas compris !
    UART1_Write(13);
    UART1_Write(10);
    Delay_ms(500);
  } while (BT_Get_Response() != BT_AOK);     // On reste ICI tant qu'on à pas la réponse du module BT

  do {
    UART1_Write_Text("SM,1");                // selection du mode (0 = esclave, 1 = master, 2 = trigger, 3 = auto-connect, 4 = DTR, 5 = ANY)
    UART1_Write(13);
    UART1_Write(10);
    Delay_ms(500);
  } while (BT_Get_Response() != BT_AOK);     // On reste ICI tant qu'on à pas la réponse du module BT

  do {
    UART1_Write_Text("SA,0");                // Selection Authentication (0 désactivé , 1 activé) il me semble que ca concerne que l'appairage
    UART1_Write(13);
    UART1_Write(10);
    Delay_ms(500);
  } while (BT_Get_Response() != BT_AOK);     // On reste ICI tant qu'on à pas la réponse du module BT

  do {
    UART1_Write_Text("SP,1");                // Code de sécurité ( SP =Security Pin), à l'origine "SP,1234"
    UART1_Write(13);
    UART1_Write(10);
    Delay_ms(500);
  } while (BT_Get_Response() != BT_AOK);     // On reste ICI tant qu'on à pas la réponse du module BT

  do {
    UART1_Write_Text("---");                 // Indique la fin ! On sort du mode de commande
    UART1_Write(13);
    UART1_Write(10);
    Delay_ms(500);
  } while (BT_Get_Response() != BT_END);    // On reste ICI tant qu'on à pas la réponse du module BT
 
[/spoil]

Je pense que la chose à retenir ici est qu'il est maitre !?!

LE but étant de passé en veille pour descendre sous les 3mA de la DS . voir 300µA en deep sleep ! mais je ne sais pas si ça convient.

Toujours à l'heure actuelle, le comportement du module est celui-ci :
-Je me connecte avec ma tablette ou smartphone à mon module, je lance le chrono, le module renvoie les infos du temps qu'il reste et la tablette affiche les infos quelle reçoit .
-Si je coupe la COM. Et que je la rallume mon chrono se met à jour et tout est nickel ! je reprends la main sur le module si je veux l’arrêter par exemple.

Il faudrait réussir à faire exactement la même chose , mais quand la com est coupée qu'il passe en sommeil plutôt que de rester actif et consommer 18mA + les pics à 50mA .

J'ai essayé tout plein de combinaisons mais à chaque fois, je ne parviens pas a reprendre la main sur mon module. quand je coupe la COM et que je la rallume, mon chrono ne se met plus à jour! par contre je peux l’arrêter il peut donc recevoir, mais sans envoyer le temps restant à ma tablette.

C'est pourquoi je penche sur un problème avec mon programme ! à la coupure de com, le BT ne doit pas se réinitialiser ou reste bloquer dans une boucle quelques part .

j'ai fais beaucoup de tests et de combinaisons donc impossible de tout posté .

Mon idée était celle-ci . Page 41 de la DS il explique tout ( en anglais peut etre mon erreur lol).

d’après ce que je comprends le Deep sleep coupe tout ou presque et peut réveiller le module sur une reception UART ! au risque de manger le premier caractères ( pas grave je pourrais l'envoyer plusieurs fois).
Mais le HIC c'est que je module ne me renvoie jamais les données une fois ré-connecter . je suppose que je suis reconnecter car je peux l’arrêter !

LA commande pour passer en mode deep sleep est (SW, 8xxx)
J'ai essayé en mode sniff mode avec la commande (SW, 0640)

Pareil ! de recevoir les infos sur ma tablette

Savez ce qui ne tourne pas rond ? dans mon programme ou ma configuration ? je penche pour un problème avec mon programme qui quand il perd la com n'arrive plus à se repérer !
Dois je le mettre ne slave , en master?
Dois-je surveiller son état (connecté ou non) pour réagir en qu'a de déconnexion ?

Une piste ?

Voici mon programme:

Code : Tout sélectionner

/*##################################################################################
Programme de prise électrique Bluetooth avec module RN-41
Fait par Jérémy pour http://www.FantasPic.fr
- Version du "13-04-2016"
- MikroC version 6.6.2
- PIC 12F1840 FOSC a 32MHZ , Quartz 8Mhz PLL Enable
- Data-Shit du PIC : http://ww1.microchip.com/downloads/en/DeviceDoc/41412F.pdf
#################################################################################*/

#include "BT_Routines.h"

// Constantes pour analyser les réponses
const BT_CMD  = 1;
const BT_AOK  = 2;
const BT_CONN = 3;
const BT_END  = 4;

//#######################     DEFINE   #########################
#define  Led_Opto PORTA.B2

//#######################     Déclaration des Variables    #########################
char txt[20]={0};

unsigned short Index_Buffer, tmp, DataReady, Flag_seconde,compteur=0, i ;
char CMD_mode, BT_state, response_rcvd, responseID, response = 0 ;
unsigned short Var_Heure, Var_Minute, Var_Seconde, Lancement, bit_de_vie ;

//###########################     Interruption    ##################################
void interrupt(){
  
  if 
(TMR0IF_bit)              // Interruption sur Timer1 toutes les 8 ms
     {
       TMR0IF_bit = 0;        // RAZ du flag
       TMR0      = 5;         // On recale notre timer0 pour 8 ms
       compteur++ ;           // On signale que 5ms se sont écoulées
     }

  if (RCIF_bit == 1) {       // Interruption sur reception UART
    tmp = UART1_Read();      // On enregistre notre byte

    if (CMD_mode){           // Si CMD_mode est égale à 1, l'initialisation n'est pas encore terminée
                             // Tout ce qui arrive sur le buffer est une commande
      switch (BT_state) {
          case  0: {
                    response = 0;                   // Clear response
                    if (tmp == 'C')                 // We have 'C', it could be CMD<cr><lf>  or CONN
                      BT_state = 1;                 // Expecting 'M' or 'N'
                    if (tmp == 'A')                 // We have 'A', it could be AOK<cr><lf>
                      BT_state = 11;                // expecting 'O'
                    if (tmp == 'E')                 // We have 'E', it could be END<cr><lf>
                      BT_state = 31;                // expecting 'N'
                    break;                          // ...
          }
          case  1: {
                    if (tmp == 'M')
                      BT_state = 2;
                    else if (tmp == 'O')
                      BT_state = 22;
                    else
                      BT_state 
= 0;
                    break;
          }
          case  2: {
                    if (tmp == 'D') {
                      response = BT_CMD;           // CMD
                      BT_state = 40;
                    }
                    else
                      BT_state 
= 0;
                    break;
          }
          case 11: {
                    if (tmp == 'O')
                      BT_state = 12;
                    else
                      BT_state 
= 0;
                    break;
          }
          case 12: {
                    if (tmp == 'K'){
                      response = BT_AOK;            // AOK
                      BT_state = 40;
                    }
                    else
                      BT_state 
= 0;
                    break;
          }
          case 22: {
                    if (tmp == 'N')
                      BT_state = 23;
                    else
                      BT_state 
= 0;
                    break;
          }
          case 23: {
                    if (tmp == 'N') {
                      response = BT_CONN;           // SlaveCONNECTmikroE
                      response_rcvd = 1;
                      responseID = response;
                    }
                    BT_state = 0;
                    break;
          }
          case 31: {
                    if (tmp == 'N')
                      BT_state = 32;
                    else
                      BT_state 
= 0;
                    break;
          }
          case 32: {
                    if (tmp == 'D') {
                      response = BT_END;           // END
                      BT_state = 40;
                    }
                    else
                      BT_state 
= 0;
                    break;
          }
          case 40: {
                    if (tmp == 13)
                      BT_state = 41;
                    else
                      BT_state 
= 0;
                    break;
          }
          case 41: {
                    if (tmp == 10){
                      response_rcvd = 1;
                      responseID = response;
                    }
                    BT_state = 0;
                    break;
          }

          default: {
                    BT_state = 0;
                    break;
          }
      }
  }
    else                                // Une fois l'initialisation finie on remplie notre buffer
      {
        if (tmp == 13)                  // Si on recoit un "CR" fin d'une chaine de caractere
           {
              txt[Index_Buffer] = 0;       // Terminateur de string , on rajoute un 0 pour dire "Fin de la chaine"
              DataReady = 1;               // Une donnée à été recue et est prête , on léve le drapeau
           }
        else                               // Sin on a pas recu de "CR"
           {
              txt[Index_Buffer] = tmp;     // On place la donnée recue dans le tableau txt[] à l'endroit de l'index
              Index_Buffer++;              // Incremente l'index du tableau pour palcer la lettre suivante
           }
        RCIF_bit = 0;                     // Ré-arme le flag
      }
  }
}

// Get BlueTooth response, if there is any   ???? je sais pas trop, désolé ??????
char BT_Get_Response() {                  // Il doit s'agir de la reponse du module en fonction de la question
  if (response_rcvd) {
    response_rcvd = 0;
    return responseID;
  }
  else
    return 0
;
}

//##################################################################################
//#########################     PROGRAMME PRINCIPAL     ############################
//##################################################################################

void main() {
  // Configuration des PORTs
  ANSELA = 0;
  Led_Opto = 1;
  TRISA = 0b00000010;
  Led_Opto = 1;

  // Initialisation des variables

  CMD_mode = 1;
  BT_state = 0;
  response_rcvd = 0;
  responseID = 0;
  response = 0;
  tmp = 0;
  DataReady = 0;

  //--------  Interruption sur reception UART   ------------------------
  INTCON = 0b11000000 ;// active toutes les INT et l'INT sur les peripheriques
  PIE1.RCIE = 1;       // Enable UART RX interrupt
  PIR1.RCIF = 0;       // Drapeau d'interrutpion
//--------------------------------------------------------------------

//--------  reglages timer0  ------------------------
   OPTION_REG= 0b00000111;   // PREscaler "on" ,Valeur prescaler = 256
   TMR0 = 5;                 // RAZ du TMR0
//--------  reglages INT  ------------------------
   INTCON.GIE = 1 ; // Configuration de l'INT
   INTCON.TMR0IE = 1 ;

//--------------------------------------------------------------------

  UART1_init(115200);           // Initialise UART1 pour module /!\ NE PAS CHANGER  /!\ //
  delay_ms(100);

  // Configure le module BlueTooth-Click

 BT_Configure();  // Envoi la configuration au BT au démarrage via le fichier BT_Routines.c

  response_rcvd = 0;
  responseID = 0;
  response = 0;
  tmp = 0;
 while (BT_Get_Response() != BT_CONN);    //  Tant que le BT n'est pas connecté on reste ici

  GIE_bit = 0;                  // Désactive les INT
  CMD_mode = 0;                 // On arrete le mode de commande car le BT est configuré et Connecté

  GIE_bit = 1;                  // On ré-Active les INT

  DataReady = 0;                // RAZ du flag
  Index_Buffer = 0;             // RAZ dde l'index
  Flag_seconde = 0;             // RAZ du flag seconde
  Lancement = 0;                // RAZ du flag Lancement

//###################################################################################
 while (1) {

    if (DataReady)              // Si une donnée est recue
       {
         GIE_bit  = 0;          // Interdit les Interutpions le temps du traitement
         DataReady = 0;         // Réarme le flag
         Index_Buffer = 0;      // Raz l'index du buffer


         //---------------  Reception des valeurs du chrono  ---------------------------
         if ( txt[0] == 'c' & txt[1] == 'h') // on verifie le mot de commande "ch" correspondant à chrono
            {
               Var_Heure = txt[3];    // On enregistre les valeurs du chrono recues dans les variables
               Var_Minute = txt[5];
               Var_Seconde = txt[7];

               Led_Opto = 0 ;

               Lancement = 1;   // On met le flag à 1 pour signaler le Lancement du chrono
            }


         //---------------  Reception de l'arret du chrono  ---------------------------
         else if ( txt[0] == 's' & txt[1] == 't')  // on verifie le mot de commande "st" correspondant à stop
            {
               Lancement = 0;   // On met le flag à 0 pour signaler l'arret du chrono
               Led_Opto = 1 ;
            }

        GIE_bit = 1;                // On ré-active les INT
       }

//----------------------------------------------------------------------------------
    if ( compteur >= 125)        // Toute les secondes ont envoie les infos pour tenir le fil de vie
          {
            if ( Lancement == 1 )  // Si le Lancement à été effetué
               {                   // On effectue le décompte des secondes et on envoie les valeurs par BT
                  Var_Seconde--;   // On décremente une seconde

                  if (Var_Seconde > 59 )   // Quand la seconde passe de 0 à 255
                     {
                        Var_Seconde = 59;
                        Var_Minute--;      // On décremente une minute
                        if (Var_Minute> 59 )
                           {
                              Var_Minute = 59;
                              Var_Heure--;

                              if (Var_Heure > 59 )  // Si le Compte à rebours arrive à zéro
                                 {
                                   Lancement = 0;   // On arrete le chrono
                                   Led_Opto = 1 ;
                                   Var_Heure = Var_Minute = Var_Seconde = 0;  // On RAZ les valeurs
                                 }
                            }
                      }
               }

             UART1_Write_text("MAJ"); // Mot de reconnaisance pour la tablette
             UART1_Write(Lancement);  // On indique que le chrono tourne ou non
             UART1_Write(Var_Heure);  // On indique la variable pour MAJ de la tablette
             UART1_Write(Var_Minute);
             UART1_Write(Var_Seconde);

             compteur = 0;    // RAZ le compteur de seconde
          }
  }
C'est en faisant des erreurs, que l'on apprend le mieux !!!

Blue-Tooth recuperation de signal apres veille
Jérémy
Administrateur du site
Administrateur du site
Messages : 2722
Âge : 44
Enregistré en : juillet 2015
Localisation : Dans le sud
Contact :

#2 Message par Jérémy » sam. 25 juin 2016 11:14

Vraiment grosse galère .

Je n'arrive même pas à déterminer si c'est le module BT qui n'envoie pas car bloqué dans une boucle , ou alors si c'est le device qui ne l’affiche pas , car il ne reçoit pas les bons ordres !

J'ai imprimer la notice et tout et tout, mais je me perds totalement ! Si jamais quelqu'un connaissant le protocole Blue-Tooth passe par la pour me faire un petit topo rapide , surtout sur le cheminement après une perte de com et une reprise de la com après mise en veille.... ce serait vraiment sympa !

Si je ne met pas le module en veille, la com revient parfaitement !
C'est en faisant des erreurs, que l'on apprend le mieux !!!

Blue-Tooth recuperation de signal apres veille
Jérémy
Administrateur du site
Administrateur du site
Messages : 2722
Âge : 44
Enregistré en : juillet 2015
Localisation : Dans le sud
Contact :

#3 Message par Jérémy » sam. 25 juin 2016 20:34

Allez , mare , j'abandonne !

A+
C'est en faisant des erreurs, que l'on apprend le mieux !!!

Blue-Tooth recuperation de signal apres veille
Subzero64170
Avatar de l’utilisateur
Débutant
Débutant
Messages : 51
Âge : 37
Enregistré en : octobre 2015
Localisation : PAU

#4 Message par Subzero64170 » dim. 26 juin 2016 00:47

Bonsoir Jeremy,
Est ce que tu ne peux pas essayer de renvoyer un caractère simplement dés que tu sors le module du mode veille dans un premier temps? pour voir si déja ça fonctionne correctement l'envoie par le bluetooth au redémarrage.Peut etre qu'au redémarrage il faut re-synschroniser les données ou un truc du genre puis les envoyer...
“L'imagination est plus importante que le savoir.” A.Einstein

Blue-Tooth recuperation de signal apres veille
Jérémy
Administrateur du site
Administrateur du site
Messages : 2722
Âge : 44
Enregistré en : juillet 2015
Localisation : Dans le sud
Contact :

#5 Message par Jérémy » mer. 6 juil. 2016 21:54

Bonsoir,

Allez je touche au but et je vous fait un topo une fois fini !
C'est en faisant des erreurs, que l'on apprend le mieux !!!


Retourner vers « Langage C »

Qui est en ligne

Utilisateurs parcourant ce forum : Aucun utilisateur enregistré et 40 invités