Répondre à la discussion
Affichage des résultats 1 à 3 sur 3

Configuration du module MRF89XA



  1. #1
    Valou31290

    Configuration du module MRF89XA


    ------

    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 :

    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);
    }
    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.
    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.

    -----

  2. #2
    vincent66

    Re : Configuration du module MRF89XA

    Bonjour,

    Je vais brûler la politesse à daudet en te demandant de nous poster la datasheet du module, ce qui devrait être un automatisme...
    Leonardo était ingénieur "sans papier", et moi diplômé juste...technicien...

  3. #3
    Valou31290

    Re : Configuration du module MRF89XA

    Bien évidemment veuillez m'excuser les voici.
    La première concerne le module avec très peu d'informations et la seconde sur le chip du module avec les différentes configurations.
    Pour comprendre un peu mieux les configurations par registres effectué je fournis également le .h

    Code:
    #ifndef CONFIGER_H
    #define	CONFIGER_H
    
    #include "main.h"
    
    typedef enum
    {
        CONFIG_REGISTER_0 = 0,
        CONFIG_REGISTER_1 = 1,
        CONFIG_REGISTER_2 = 2,
        CONFIG_REGISTER_3 = 3,
        CONFIG_REGISTER_4 = 4,
        CONFIG_REGISTER_5 = 5,
        CONFIG_REGISTER_6 = 6,
        CONFIG_REGISTER_7 = 7,
        CONFIG_REGISTER_8 = 8,
        CONFIG_REGISTER_9 = 9,
        CONFIG_REGISTER_10 = 10,
        CONFIG_REGISTER_11 = 11,
        CONFIG_REGISTER_12 = 12,        
        CONFIG_REGISTER_13 = 13,        
        CONFIG_REGISTER_14 = 14,        
        CONFIG_REGISTER_15 = 15,
        CONFIG_REGISTER_16 = 16, 
        CONFIG_REGISTER_17 = 17, 
        CONFIG_REGISTER_18 = 18, 
        CONFIG_REGISTER_19 = 19, 
        CONFIG_REGISTER_20 = 20, 
        CONFIG_REGISTER_21 = 21, 
        CONFIG_REGISTER_22 = 22, 
        CONFIG_REGISTER_23 = 23, 
        CONFIG_REGISTER_24 = 24, 
        CONFIG_REGISTER_25 = 25, 
        CONFIG_REGISTER_26 = 26, 
        CONFIG_REGISTER_27 = 27, 
        CONFIG_REGISTER_28 = 28, 
        CONFIG_REGISTER_29 = 29, 
        CONFIG_REGISTER_30 = 30, 
        CONFIG_REGISTER_31 = 31   
    } REGISTER_CONFIG;
    
    /********************************************************************
     *                    PROTOTYPES ET DEFINITIONS
    **********************************************************************/
    
    /********************************************************************
     DEFINES SPE
    **********************************************************************/
    #define NUMBER_REGISTER         32
    #define NUMBER_TRY_CONFIG       3
    #define ERROR_FAIL_CONFIG_EM    -55
    
    #define CONFIG_NEXT_REGISTER    0
    #define CONFIG_ACTUAL_REGISTER  1
    
    /********************************************************************
    MRF89XA Operating modes
    **********************************************************************/
    #define RF_SLEEP                         0x00
    #define RF_STANDBY                       0x20
    #define RF_SYNTHESIZER                   0x40
    #define RF_RECEIVER                      0x60
    #define RF_TRANSMITTER                   0x80
    
    /*********************************************************************
    MRF89XA Register Description
    *********************************************************************/
    #define REG_MCPARAM0                     0
    	#define CHIPMODE_SLEEPMODE  0x00	//000 [7:5]
    	#define CHIPMODE_STBYMODE 	0x20	//001 ;default
    	#define CHIPMODE_FSMODE	 	0x40	//010
    	#define CHIPMODE_RX		 	0x60	//011
    	#define CHIPMODE_TX		 	0x80	//100
    
    	#define FREQBAND_902		0x00   //902-915 00 [4:3]
    	#define FREQBAND_915		0x08   //915-928 01 ;default
    	#define FREQBAND_950		0x10	//950-960 or 863-870 10
    	
    	#define VCO_TRIM_00			0x00	// [2:1] Vtune determined by tank inductor values
    	#define VCO_TRIM_01			0x02
    	#define VCO_TRIM_10			0x04
    	#define VCO_TRIM_11			0x06
    
    #define REG_MCPARAM1                     1
    	#define MODSEL_OOK			0x40   //01 [7:6]
    	#define MODSEL_FSK			0x80   //10 ;default
    
    	#define OOKTHRESHTYPE_FIXED 0x00   //00 [4:3]
    	#define OOKTHRESHTYPE_PEAK	0x08	//01
    	#define OOKTHRESHTYPE_AVG	0x10	//10
    
    	#define DATAMODE_CONTINUOUS 0x00   //00 [Bit2,Bit5];default
    	#define DATAMODE_BUFFERED	0x20	//01
    	#define DATAMODE_PACKET	    0x04	//1x
    	
    	#define IFGAIN_0			0x00	//00 [1:0] 0dB ;default
    	#define IFGAIN_45			0x01	//01 -4.5dB
     	#define IFGAIN_9			0x02	//10 -9dB
    	#define IFGAIN_135			0x03	//11 -13.5dB
    
    #define REG_FREGDEV                      2		//default D = 00000011, FDEV = 133 kHz
    		//values may change - should be calculated based on crystal frequency - 12.8 MHz (fxtal/32/(D+1))
    		#define FREGDEV_33		0x0B
    		#define FREGDEV_40		0x09
    		#define FREGDEV_50		0x07
    		#define FREGDEV_67		0x05
    		#define FREGDEV_80		0x04
    		#define FREGDEV_100		0x03
    		#define FREGDEV_133		0x02
    		#define FREGDEV_200		0x01
    	
    #define REG_BITRATE                      3
    												//default C = 0000111, BR = 25 Kbps
    		#define BITRATE_200		0x00
    		#define BITRATE_100		0x01
    		#define BITRATE_66		0x02
    		#define BITRATE_50		0x03
    		#define BITRATE_40		0x04
    		#define BITRATE_25		0x07
    		#define BITRATE_20		0x09
    		#define BITRATE_16		0x0B
    		#define BITRATE_10		0x13
    		#define BITRATE_5		0x27
    		#define BITRATE_2		0x63
    		#define BITRATE_1_56	0x7F
    		#define BITRATE_2_41	0x52
    		#define BITRATE_4_76	0x29
    		#define BITRATE_8		0x18
    		#define BITRATE_9_52	0x14
    		#define BITRATE_12_5	0x0F
    		#define BITRATE_16_67	0x0B
    
    #define REG_OOKFLOORTHRESH               4
    	// OOK threshold (reg4)
    	#define OOKFLOORTHRESH_VALUE 0x0C 
    	
    #define REG_MCPARAM5                     5
    	#define FIFOSIZE_16			0x00	//00 [7:6] - 16bytes - default
    	#define FIFOSIZE_32			0x40
    	#define FIFOSIZE_48			0x80
    	#define FIFOSIZE_64			0xC0
    	
    	#define FIFO_THRSHOLD_31	0x0F	//31 bytes - default [5:0]
    	#define FIFO_THRSHOLD_1		0x01
    
    #define REG_R1                           6
    
    #define REG_P1                           7
    
    #define REG_S1                           8
    
    #define REG_R2                           9
    
    #define REG_P2                           10
    
    #define REG_S2                           11
    
    #define REG_MCPARAM12                    12
    	#define PA_RAMP_3			0x00	//[4:3] - 3us
    	#define PA_RAMP_85			0x08	//8.5us
    	#define PA_RAMP_15			0x10	//15us
    	#define PA_RAMP_23			0x18	//23us
    	#define DEF_PARAMP			0x20
    
    #define REG_IRQPARAM0                    13
    	// IRQ Param 0 (reg13)
    	// Select RX&STDBY IRQ_0 sources (Packet mode) (reg13)
    	#define IRQ0_RX_STDBY_PAYLOADREADY    0x00
    	#define IRQ0_RX_STDBY_WRITEBYTE       0x40
    	#define IRQ0_RX_STDBY_FIFOEMPTY       0x80
    	#define IRQ0_RX_STDBY_SYNCADRS        0xC0
    	
    	// Select RX&STDBY IRQ_1 sources (Packet mode) (reg13)
    	#define IRQ1_RX_STDBY_CRCOK           0x00
    	#define IRQ1_RX_STDBY_FIFOFULL        0x10
    	#define IRQ1_RX_STDBY_RSSI            0x20
    	#define IRQ1_RX_STDBY_FIFOTHRESH      0x30
    	
    	// Select TX IRQ_1 sources (Packet mode) (reg13)
    	#define IRQ1_TX_FIFOFULL              0x00
    	#define IRQ1_TX_TXDONE                0x08
    
    	// Select TX IRQ_1 sources (Continuous mode) (reg13)
    	#define IRQ1_TX_DCLK              	  0x00
    	
    	// FIFO overrun/clear  (reg13)
    	#define IRQ1_FIFO_OVERRUN_CLEAR       0x01
    	
    #define REG_IRQPARAM1                    14
    	// IRQ Param 1
    	#define DEF_IRQPARAM1                   0x08
    	// Select TX start condition and IRQ_0 source (Packet mode)
    	#define IRQ0_TX_START_FIFOTHRESH        0x00
    	#define IRQ0_TX_START_FIFONOTEMPTY      0x10
    	
    	// RSSI IRQ flag
    	#define IRQ1_RSSI_IRQ_CLEAR             0x04
    	
    	// PLL_Locked flag
    	#define IRQ1_PLL_LOCK_CLEAR             0x02
    	
    	// PLL_Locked pin
    	#define IRQ1_PLL_LOCK_PIN_OFF           0x00
    	#define IRQ1_PLL_LOCK_PIN_ON            0x01
    	
    	// RSSI threshold for interrupt
    	#define RSSIIRQTHRESH_VALUE             0x00
    
        #define NODEADRS_VALUE                  0x00
    
    #define REG_RSSIIRQTHRESH                15
    
    #define REG_RXPARAM0                     16
    	// RX Param 0
    	// Passive filter (kHz)
    	#define PASSIVEFILT_65            0x00		//65 KHz
    	#define PASSIVEFILT_82            0x10		//82 KHz
    	#define PASSIVEFILT_109           0x20
    	#define PASSIVEFILT_137           0x30
    	#define PASSIVEFILT_157           0x40
    	#define PASSIVEFILT_184           0x50
    	#define PASSIVEFILT_211           0x60
    	#define PASSIVEFILT_234           0x70
    	#define PASSIVEFILT_262           0x80
    	#define PASSIVEFILT_321           0x90
    	#define PASSIVEFILT_378           0xA0
    	#define PASSIVEFILT_414           0xB0
    	#define PASSIVEFILT_458           0xC0
    	#define PASSIVEFILT_514           0xD0
    	#define PASSIVEFILT_676           0xE0
    	#define PASSIVEFILT_987           0xF0
    	
    	// Butterworth filter (kHz)
    	#define RXFC_VALUE                  0x03
    	// !!! Values defined below only apply if XTAL frequency == 12.8MHz !!!
    	#define RXFC_FOPLUS25               0x00
    	#define RXFC_FOPLUS50               0x01
    	#define RXFC_FOPLUS75               0x02
    	#define RXFC_FOPLUS100              0x03
    	#define RXFC_FOPLUS125              0x04
    	#define RXFC_FOPLUS150              0x05
    	#define RXFC_FOPLUS175              0x06
    	#define RXFC_FOPLUS200              0x07
    	#define RXFC_FOPLUS225              0x08
    	#define RXFC_FOPLUS250              0x09
    	#define RXFC_FOPLUS275				0x0A
    	#define RXFC_FOPLUS300				0x0B
    	#define RXFC_FOPLUS325				0x0C
    	#define RXFC_FOPLUS350				0x0D
    	#define RXFC_FOPLUS375				0x0E
    	#define RXFC_FOPLUS400				0x0F
    
    #define REG_RXPARAM1                     17
    	// RX Param 1
    	#define DEF_RXPARAM1			  0x08
    	// Polyphase filter center value (kHz)
    	#define FO_VALUE                  0x30
    
    	// !!! Values defined below only apply if RFCLKREF = DEFAULT VALUE = 0x07 !!!
    	#define FO_50                     0x10
    	#define FO_75                     0x20
    	#define FO_100                    0x30
    	#define FO_125                    0x40
    	#define FO_150                    0x50
    	#define FO_175                    0x60
    	#define FO_200                    0x70
    	#define FO_225                    0x80
    	#define FO_250                    0x90
    	#define FO_275                    0xA0
    	#define FO_300                    0xB0
    	#define FO_325                    0xC0
    	#define FO_350                    0xD0
    	#define FO_375                    0xE0
    	#define FO_400                    0xF0
    
    #define REG_RXPARAM2                     18
    	// Rx Param 2
    	// Polyphase filter enable
    	#define POLYPFILT_ON                0x80
    	#define POLYPFILT_OFF               0x00
    
    	#define DEF_RXPARAM2				0x20
    	#define SYNC_ON						0x20	//[5] - 0 - off, 1 - on
    	#define SYNC_SIZE_8					0x00	//[4:3] - 00 - 8 bits 
    	#define SYNC_SIZE_16				0x08
    	#define SYNC_SIZE_24				0x10
    	#define SYNC_SIZE_32				0x18
    	#define SYNC_ERRORS_0				0x00	//[2:1] - 00 - 0 error
    	#define SYNC_ERRORS_1				0x02
    	#define SYNC_ERRORS_2				0x04
    	#define SYNC_ERROS_3				0x06
    
    #define REG_RXPARAM3                     19				//Reserved
    	#define DEF_RXPARAM3				0x07
    
    #define REG_RSSIVALUE                    20
    	//RSSI value (READ ONLY)
    
    #define REG_OOKSETTINGS                  21
    	// Rx Param 5
    	// Decrement step of RSSI threshold in OOK demodulator (peak mode)
    	#define OOK_THRESH_DECSTEP_000    0x00
    	#define OOK_THRESH_DECSTEP_001    0x20
    	#define OOK_THRESH_DECSTEP_010    0x40
    	#define OOK_THRESH_DECSTEP_011    0x60
    	#define OOK_THRESH_DECSTEP_100    0x80
    	#define OOK_THRESH_DECSTEP_101    0xA0
    	#define OOK_THRESH_DECSTEP_110    0xC0
    	#define OOK_THRESH_DECSTEP_111    0xE0
    	
    	// Decrement period of RSSI threshold in OOK demodulator (peak mode)
    	#define OOK_THRESH_DECPERIOD_000  0x00
    	#define OOK_THRESH_DECPERIOD_001  0x04
    	#define OOK_THRESH_DECPERIOD_010  0x08
    	#define OOK_THRESH_DECPERIOD_011  0x0C
    	#define OOK_THRESH_DECPERIOD_100  0x10
    	#define OOK_THRESH_DECPERIOD_101  0x14
    	#define OOK_THRESH_DECPERIOD_110  0x18
    	#define OOK_THRESH_DECPERIOD_111  0x1C
    	
    	// Cutoff freq of average function of RSSI threshold in OOK demodulator (average mode)
    	#define OOK_THRESH_AVERAGING_00   0x00
    	#define OOK_THRESH_AVERAGING_11   0x03
    
    #define REG_SYNCBYTE0                    22
    
    #define REG_SYNCBYTE1                    23
    
    #define REG_SYNCBYTE2                    24
    
    #define REG_SYNCBYTE3                    25
    
    #define REG_TXPARAM                      26
    	// TX Param 
    	// Interpolator filter Tx (kHz)
    	#define FC_VALUE                   0x70
    	// !!! Values defined below only apply if RFCLKREF = DEFAULT VALUE = 0x07 !!!
    	#define FC_25                      0x00
    	#define FC_50                      0x10
    	#define FC_75                      0x20
    	#define FC_100                     0x30
    	#define FC_125                     0x40
    	#define FC_150                     0x50
    	#define FC_175                     0x60
    	#define FC_200                     0x70
    	#define FC_225                     0x80
    	#define FC_250                     0x90
    	#define FC_275                     0xA0
    	#define FC_300                     0xB0
    	#define FC_325                     0xC0
    	#define FC_350                     0xD0
    	#define FC_375                     0xE0
    	#define FC_400                     0xF0
    
    	#define TXPOWER_13					0x00	//[3:1] - 13dB
    	#define TXPOWER_10					0x02	
    	#define TXPOWER_7                   0x04
    	#define TXPOWER_4					0x06
    	#define TXPOWER_1					0x08
    	#define TXPOWER_2					0x0A
    	#define TXPOWER_5					0x0C
    	#define TXPOWER_8					0x0E
    
    #define REG_OSCPARAM                     27
    	// OSC Param
    	// CLKOUT enable
    	#define CLKOUT_ON                 0x80
    	#define CLKOUT_OFF                0x00
    	
    	// CLKOUT frequency (kHz)
    	#define CLKOUT_12800              0x00
    	#define CLKOUTint64_t00           0x04
    	#define CLKOUT_3200               0x08
    	#define CLKOUT_2133               0x0C
    	#define CLKOUT_1600               0x10
    	#define CLKOUT_1280               0x14
    	#define CLKOUT_1067               0x18
    	#define CLKOUT_914                0x1C
    	#define CLKOUT_800                0x20
    	#define CLKOUT_711                0x24
    	#define CLKOUT_64		          0x28
    	#define CLKOUT_582                0x2C
    	#define CLKOUT_533                0x30
    	#define CLKOUT_492                0x34
    	#define CLKOUT_457                0x38
    	#define CLKOUT_427                0x3C
    
    #define REG_PKTPARAM0                    28
    	#define MANCHESTER_ON				0x80	//[7] 0 - off, 1 - on
    	#define MANCHESTER_OFF				0x00
    
    #define REG_NODEADDRESS                  29
    
    #define REG_PKTPARAM2                    30
    	#define PKT_FORMAT_FIXED			0x00	//[7] 0 - fixed length, 1- variable length
    	#define PKT_FORMAT_VARIABLE			0x80
    	#define PREAMBLE_SIZE_1				0x00 	//[6:5] 00 - 1 byte
    	#define PREAMBLE_SIZE_2				0x20
    	#define PREAMBLE_SIZE_3				0x40
    	#define PREAMBLE_SIZE_4				0x60
    	
    	#define WHITENING_ON				0x10	//[4] 0 - off, 1 - On
    	#define WHITENING_OFF				0x00	
    	
    	#define CRC_ON						0x08	//[3] 0 - off, 1 - On
    	#define CRC_OFF						0x00	
    	// Address filtering
    	#define ADRSFILT_NONE				0x00	/* no filtering */
    	#define ADRSFILT_ME_ONLY			0x02	/* only Node_adrs accepted (register 29) */
    	#define ADRSFILT_ME_AND_00			0x04	/* Node_adrs and 0x00 accepted */
    	#define ADRSFILT_ME_AND_00_AND_FF	0x06	/* Node_adrs and 0x00 and 0xff accepted */
    
    
    #define REG_PKTPARAM3                    31
    	#define FIFO_AUTOCLR_ON				0x00	//[7] 0 - On, 1 - Off
    	#define FIFO_AUTOCLR_OFF			0x80
    
    	#define FIFO_STBY_ACCESS_WRITE		0x00	//[6] 0 - Write, 1 - Read
    	#define FIFO_STBY_ACCESS_READ		0x40
    
    #endif	/* CONFIGER_H */
    Les registres et leur defines viennent de la MLA de micochip.
    Fichiers attachés Fichiers attachés

Sur le même thème :

Discussions similaires

  1. [Programmation] Configuration du module Nrf24l01+
    Par webscience dans le forum Électronique
    Réponses: 17
    Dernier message: 18/08/2017, 19h03
  2. Réponses: 6
    Dernier message: 10/10/2015, 18h43
  3. Configuration module bluetooth HCI commands
    Par comptet dans le forum Électronique
    Réponses: 3
    Dernier message: 29/04/2015, 12h14
  4. [PIC24FJ] - Configuration du module ADC
    Par jorg1n dans le forum Électronique
    Réponses: 5
    Dernier message: 05/10/2011, 21h40
  5. PIC18F6722 - Configuration (INIBITION Module CCP)
    Par jorg1n dans le forum Électronique
    Réponses: 7
    Dernier message: 16/09/2008, 23h42
Découvrez nos comparatifs produits sur l'informatique et les technologies.