Bonsoir à tous,
Je travaille actuellement sur un projet de domotique qui consiste à récupérer des données de différents capteurs afin de les afficher sur une IHM web.
L'IHM web sera hébergé sur un serveur monté sur une carte achetée qui fonctionne comme une raspberry.
Pour ce faire j'étais partis sur une communication bidirectionnelle BOX / Modules grâce à des modules MRF89XA avec sur chaque module un PIC18F46J50.
J'ai commencé par fabriquer une carte prototype et un premier module qui est une prise commandée pour tester la communication entre les deux mais après plusieurs jours de recherche je ne comprend toujours pas comment fonctionne cet émetteur / récepteur.
Dans un premier temps j'ai essayé de configurer le module en me basant sur sa datasheet mais après plusieurs essais je me suis basé sur une MLA de microchip qui prend en charge le module mais avec leur protocole, le but serait d'utiliser un autre protocole fait maison.
Beaucoup de forums traite le sujet mais aucun n'a réussi à me débloquer en testant un peu toute les solutions c'est pour cela que je me tourne vers vous.
Le problème viendrait surement de la configuration du module mais j'ai repris la configuration par défaut de la MLA de microchip.
Voici le code :
Pour expliquer un peu le code lors de la configuration, je configure un registre, je lis ce qu'il y a écrit, si le registre est bien configuré je passe au suivant sinon j’essaie de le reconfigurer 3 fois.Code:#include "ConfigER.h" #pragma warning disable 752 /********************************************************************* * Variables **********************************************************************/ UINT8 ui8_RFMode; //Variable ayant le mode actuel du module /* Configurations par défaut du module */ char tc_InitConfigRegs[] = { /* 0 */ CHIPMODE_STBYMODE | FREQBAND_915 | VCO_TRIM_11, /* 1 */ MODSEL_FSK | DATAMODE_PACKET | IFGAIN_0, /* 2 */ FREGDEV_80, /* 3 */ BITRATE_25, /* 4 */ OOKFLOORTHRESH_VALUE, /* 5 */ FIFOSIZE_64 | FIFO_THRSHOLD_1, /* 6 */ 0, /* 7 */ 0, /* 8 */ 0, /* 9 */ 0, /* 10 */ 0, /* 11 */ 0, /* 12 */ DEF_PARAMP | PA_RAMP_23, /* 13 */ IRQ0_RX_STDBY_SYNCADRS | IRQ1_RX_STDBY_CRCOK | IRQ1_TX_TXDONE, /* 14 */ DEF_IRQPARAM1 | IRQ0_TX_START_FIFOTHRESH | IRQ1_PLL_LOCK_PIN_ON, /* 15 */ RSSIIRQTHRESH_VALUE, /* 16 */ PASSIVEFILT_378 | RXFC_FOPLUS100, /* 17 */ DEF_RXPARAM1 | FO_100, /* 18 */ DEF_RXPARAM2 | POLYPFILT_OFF | SYNC_SIZE_32 | SYNC_ON | SYNC_ERRORS_0, /* 19 */ DEF_RXPARAM3, /* 20 */ 0, /* 21 */ OOK_THRESH_DECSTEP_000 | OOK_THRESH_DECPERIOD_000 | OOK_THRESH_AVERAGING_00, /* 22 */ 0x69, // 1st byte of Sync word, /* 23 */ 0x81, // 2nd byte of Sync word, /* 24 */ 0x7E, // 3rd byte of Sync word, /* 25 */ 0x96, // 4th byte of Sync word, /* 26 */ FC_400 | TXPOWER_13, /* 27 */ CLKOUT_ON | CLKOUT_12800, /* 28 */ MANCHESTER_OFF | 64, /* 29 */ NODEADRS_VALUE, /* 30 */ PKT_FORMAT_VARIABLE | PREAMBLE_SIZE_4 | WHITENING_OFF | CRC_ON | ADRSFILT_NONE, /* 31 */ FIFO_AUTOCLR_ON | FIFO_STBY_ACCESS_WRITE }; /********************************************************************* * Fonction de configuration générale du module **********************************************************************/ INT8 i8_RFGeneralConfiguration(void) { REGISTER_CONFIG en_registerConfig; BOOL b_configCheck = VRAI; INT8 i8_errorConfig = ERROR_FAIL_CONFIG_EM; UINT8 ui8_cptTestConfig = 0; UINT8 ui8_NextRegister; UINT8 input; /* RESET DU MODULE */ RESET_MRF = 1; /* Mise à 1 de la pin de reset 100us */ WAIT_100USEC; RESET_MRF = 0; /* Mise à 0 de la pin de reset et attente que le module soit prêt */ WAIT_10MSEC; /* Configure tous les registre */ for(en_registerConfig = 0; en_registerConfig < NUMBER_REGISTER && b_configCheck == VRAI; en_registerConfig++) { /* Essais de configurer NUMBER_TRY_CONFIG nombre de fois un registre */ ui8_NextRegister = CONFIG_ACTUAL_REGISTER; for(ui8_cptTestConfig = 0; ui8_cptTestConfig < NUMBER_TRY_CONFIG && ui8_NextRegister == CONFIG_ACTUAL_REGISTER; ui8_cptTestConfig++) { i8_errorConfig = ui8_RegisterConfigDefault(en_registerConfig, tc_InitConfigRegs[en_registerConfig]); if(i8_errorConfig == NO_ERROR) { b_configCheck = VRAI; ui8_NextRegister = CONFIG_NEXT_REGISTER; } else { b_configCheck = FAUX; /* Créer log */ } } } if(b_configCheck == FAUX) { /* Erreur de config */ i8_errorConfig = ERROR_FAIL_CONFIG_EM; } else { /* Ne rien faire */ } if(i8_errorConfig == NO_ERROR) { /* Config mode du module */ input = ui8_RegisterRead(REG_MCPARAM0); v_RegisterSet(REG_MCPARAM0, (input & 0x1F) | RF_SYNTHESIZER); /* clear PLL_LOCK flag so we can see it restore on the new frequency */\ input = ui8_RegisterRead(REG_IRQPARAM1); v_RegisterSet(REG_IRQPARAM1, (input | 0x02)); input = ui8_RegisterRead(REG_MCPARAM0); v_RegisterSet(REG_MCPARAM0, ((input & 0xE7) | FREQBAND_915)); /* Program R, P, S registers */ v_RegisterSet(REG_R1, 119); v_RegisterSet(REG_P1, 100); v_RegisterSet(REG_S1, 52); input = ui8_RegisterRead(REG_MCPARAM0); v_RegisterSet(REG_MCPARAM0, ((input & 0x1F) | RF_SYNTHESIZER)); /* Clear PLL_LOCK flag so we can see it restore on the new frequency */ input = ui8_RegisterRead(REG_IRQPARAM1); v_RegisterSet(REG_IRQPARAM1, (input | 0x02)); /* STANDBY pour stop la configuration */ v_SetRFMode(RF_STANDBY); if(ui8_RFMode == RF_STANDBY) { /* La configuration s'est bien déroulée */ i8_errorConfig = NO_ERROR; } else { /* Erreur, le module n'est pas repassé en standby */ i8_errorConfig = ERROR_FAIL_CONFIG_EM; } } else { /* Erreur de config */ i8_errorConfig = ERROR_FAIL_CONFIG_EM; } return i8_errorConfig; } /********************************************************************* * Configuration d'un registre et vérification de son contenu **********************************************************************/ UINT8 ui8_RegisterConfigDefault(const REGISTER_CONFIG pen_registerConfig, char c_registerConfig) { UINT8 ui8_errorConfig = NO_ERROR; UINT8 ui8_DataRead; v_RegisterSet(pen_registerConfig, c_registerConfig); ui8_DataRead = ui8_RegisterRead(pen_registerConfig); if(ui8_DataRead == c_registerConfig) //Si la valeur du registre correspond à la valeur configurée on passe à la config suivante { ui8_errorConfig = NO_ERROR; } else { ui8_errorConfig = ERROR; } return(ui8_errorConfig); } /********************************************************************* * Fonction de changement de mode du module **********************************************************************/ void v_SetRFMode(UINT8 ui8_Mode) { UINT8 ui8_MCPARAM0Read; switch(ui8_Mode) { case RF_TRANSMITTER: v_RegisterSet(REG_MCPARAM0, (ui8_MCPARAM0Read & 0x1F) | RF_TRANSMITTER); break; case RF_RECEIVER: v_RegisterSet(REG_MCPARAM0, (ui8_MCPARAM0Read & 0x1F) | RF_RECEIVER); break; case RF_SYNTHESIZER: v_RegisterSet(REG_MCPARAM0, (ui8_MCPARAM0Read & 0x1F) | RF_SYNTHESIZER); break; case RF_STANDBY: v_RegisterSet(REG_MCPARAM0, (ui8_MCPARAM0Read & 0x1F) | RF_STANDBY); break; case RF_SLEEP: v_RegisterSet(REG_MCPARAM0, (ui8_MCPARAM0Read & 0x1F) | RF_SLEEP); break; default: break; } ui8_MCPARAM0Read = ui8_RegisterRead(REG_MCPARAM0); if(ui8_MCPARAM0Read == (ui8_MCPARAM0Read & 0x1F) | ui8_Mode) { ui8_RFMode = ui8_Mode; } return; } /********************************************************************* * Fonction de récupération de la valeur du mode du module **********************************************************************/ UINT8 ui8_GetRFMode(void) { return(ui8_RFMode); } /********************************************************************* * Fonction de parametrage de registre **********************************************************************/ void v_RegisterSet(UINT8 ui8_Adress, char c_Data) { SPI_CS_CONFIG = ACTIVE; ui8_Adress = (ui8_Adress<<1); ui8_PutCharSPI1(ui8_Adress); ui8_PutCharSPI1(c_Data); SPI_CS_CONFIG = IDLE; return; } /********************************************************************* * Fonction de lecture de registre **********************************************************************/ UINT8 ui8_RegisterRead(UINT8 ui8_Adress) { UINT8 ui8_Data; SPI_CS_CONFIG = ACTIVE; ui8_Adress = ((ui8_Adress<<1)|0x40); ui8_PutCharSPI1(ui8_Adress); ui8_Data = ui8_GetCharSPI1(); SPI_CS_CONFIG = IDLE; return(ui8_Data); } /********************************************************************* * Fonction d'envoi de message à un autre module **********************************************************************/ UINT8 ui8_SendDatas(UINT8 tui8_TxPacket[], UINT8 ui8_TypeDatas) { UINT8 ui8_DataIterator; UINT8 ui8_DataForResetFIFO; UINT8 ui8_MaxByteToSend = 4; UINT8 ui8_ErrorFlag = 0; v_SetRFMode(RF_STANDBY); WAIT_1MSEC; v_RegisterSet(REG_PKTPARAM3, ((tc_InitConfigRegs[REG_PKTPARAM3] & 0xBF)| FIFO_STBY_ACCESS_WRITE)); v_RegisterSet(REG_IRQPARAM0, (tc_InitConfigRegs[REG_IRQPARAM0] | IRQ1_FIFO_OVERRUN_CLEAR )); v_RegisterSet(REG_IRQPARAM1, ((tc_InitConfigRegs[REG_IRQPARAM1]) | 0x02)); v_WriteFIFO(0x07); /* Nombre de datas à envoyer (fixe pour le test) */ v_WriteFIFO(SENSOR_TYPE); /* Envoi du type du module */ v_WriteFIFO(NUMERO_MODULE); /* Envoi du numéro du module */ v_WriteFIFO(ui8_TypeDatas); /* Envoi du type de datas */ /* Envoi des datas, et attente de fin d'envoi */ for(ui8_DataIterator = 0 ; ui8_DataIterator < ui8_MaxByteToSend; ui8_DataIterator++) { v_WriteFIFO(tui8_TxPacket[ui8_DataIterator]); } v_SetRFMode(RF_TRANSMITTER); WAIT_10MSEC; v_SetRFMode(RF_STANDBY); WAIT_1MSEC; /* Reset FIFO */ ui8_DataForResetFIFO = ui8_RegisterRead(REG_IRQPARAM0); v_RegisterSet(REG_IRQPARAM0, (ui8_DataForResetFIFO | 0x01)); return(ui8_ErrorFlag); } /********************************************************************* * Fonction de réception d'une trame **********************************************************************/ void v_ReceiveFrame(void) { UINT8 ui8_DataForResetFIFO; v_SetRFMode(RF_RECEIVER); if(ui8_RFMode == RF_RECEIVER) { ui8_ReadFIFO(); ui8_ReadFIFO(); ui8_ReadFIFO(); ui8_ReadFIFO(); ui8_ReadFIFO(); ui8_ReadFIFO(); ui8_ReadFIFO(); ui8_ReadFIFO(); v_SetRFMode(RF_STANDBY); if(ui8_RFMode == RF_STANDBY) { /* Reception OK */ } else { /* Erreur */ } } else { /* Erreur */ } //Reset FIFO ui8_DataForResetFIFO = ui8_RegisterRead(REG_IRQPARAM0); v_RegisterSet(REG_IRQPARAM0, (ui8_DataForResetFIFO | 0x01)); } /********************************************************************* * Fonction d'écriture dans la FIFO **********************************************************************/ void v_WriteFIFO(UINT8 ui8_Datas) { SPI_CS_DATA = ACTIVE; ui8_PutCharSPI1(ui8_Datas); SPI_CS_DATA = IDLE; return; } /********************************************************************* * Fonction de lecture dans la FIFO **********************************************************************/ UINT8 ui8_ReadFIFO(void) { UINT8 ui8_Datas; SPI_CS_DATA = ACTIVE; ui8_Datas = ui8_GetCharSPI1(); SPI_CS_DATA = IDLE; return(ui8_Datas); }
La configuration se déroule bien, la fonction ne retourne aucune erreur, j'ai quand même vérifié les données qui transitaient sur le bus spi avec un oscilloscope numérique et je n'ai aperçu aucun problème, les registres sont bien configurés après relecture de ceux-ci.
Dans la configuration actuelle j'ai essayé d'envoyer des trames en appelant la fonction ui8_SendDatas() et en regardant à l'oscilloscope si des trames étaient bien envoyée mais rien ne se passe.
J'appelle donc à l'aide de personnes ayant déjà utilisé ce module afin de m'aider à résoudre ce problème.
Merci par avance de votre aide.
Cordialement, Valentin.
-----