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 DSLa 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
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
}
}
} 
