void SpiritManagementWaCmdStrobeTx(void) { //__IO uint32_t xtal_frequency; if(s_cCommunicationState != COMMUNICATION_STATE_TX) { // xtal_frequency = SpiritRadioGetXtalFrequency(); SpiritVersion spirit_version = SpiritGeneralGetSpiritVersion(); /* To achive the max output power */ if(s_nDesiredFrequency>=150000000 && s_nDesiredFrequency<=470000000) { /* Optimal setting for Tx mode only */ SpiritRadioSetPACwc(LOAD_3_6_PF); } else { if(spirit_version == SPIRIT_VERSION_3_0_D1 && s_nDesiredFrequency>=863000000 && s_nDesiredFrequency<=870000000) { /* Optimal setting for Tx mode only */ SpiritRadioSetPACwc(LOAD_2_4_PF); } else { /* Optimal setting for Tx mode only */ SpiritRadioSetPACwc(LOAD_0_PF); } } uint8_t tmp = 0x11; SpiritSpiWriteRegisters(0xa9, 1, &tmp); /* Enable VCO_L buffer */ tmp = 0x20; SpiritSpiWriteRegisters(PM_CONFIG1_BASE, 1, &tmp); /* Set SMPS switching frequency */ s_cCommunicationState = COMMUNICATION_STATE_TX; } }
/** * @brief Enables or Disables the output of temperature sensor on SPIRIT GPIO_0. * @param xNewState new state for temperature sensor. * This parameter can be: S_ENABLE or S_DISABLE. * @retval None. */ void SpiritGpioTemperatureSensor(SpiritFunctionalState xNewState) { uint8_t tempRegValue = 0x00; uint8_t gpio0tempRegValue = 0x00; /* Check the parameters */ s_assert_param(IS_SPIRIT_FUNCTIONAL_STATE(xNewState)); /* Reads the ANA_FUNC_CONF0 register and mask the result to enable or disable the temperature sensor */ g_xStatus = SpiritSpiReadRegisters(ANA_FUNC_CONF0_BASE, 1, &tempRegValue); if(xNewState == S_ENABLE) { tempRegValue |= TEMPERATURE_SENSOR_MASK; } else { tempRegValue &= (~TEMPERATURE_SENSOR_MASK); gpio0tempRegValue = 0x0A; /* Default value */ } g_xStatus = SpiritSpiWriteRegisters(ANA_FUNC_CONF0_BASE, 1, &tempRegValue); /* Sets the SPIRIT GPIO_0 according to input request */ g_xStatus = SpiritSpiWriteRegisters(GPIO0_CONF_BASE, 1, &gpio0tempRegValue); }
/** * @brief Configures the MBUS packet format as the one used by SPIRIT. * @param None. * @retval None. */ void SpiritPktMbusSetFormat(void) { uint8_t tempRegValue; /* Reads the PCKTCTRL3 register value */ g_xStatus = SpiritSpiReadRegisters(PCKTCTRL3_BASE, 1, &tempRegValue); /* Sets format bits. Also set to 0 the direct RX mode bits */ tempRegValue &= 0x0F; tempRegValue |= ((uint8_t)PCKTCTRL3_PCKT_FRMT_MBUS); /* Writes value on the PCKTCTRL3 register */ g_xStatus = SpiritSpiWriteRegisters(PCKTCTRL3_BASE, 1, &tempRegValue); /* Reads the PCKTCTRL1 register value */ g_xStatus = SpiritSpiReadRegisters(PCKTCTRL1_BASE, 1, &tempRegValue); /* Build the new value. Set to 0 the direct TX mode bits */ tempRegValue &= 0xF3; /* Writes the value on the PCKTCTRL1 register */ g_xStatus = SpiritSpiWriteRegisters(PCKTCTRL1_BASE, 1, &tempRegValue); /* Reads the PROTOCOL1 register */ g_xStatus = SpiritSpiReadRegisters(PROTOCOL1_BASE, 1, &tempRegValue); /* Mask a reserved bit */ tempRegValue &= ~0x20; /* Writes the value on the PROTOCOL1 register */ g_xStatus = SpiritSpiWriteRegisters(PROTOCOL1_BASE, 1, &tempRegValue); }
void SpiritManagementWaExtraCurrent(void) { uint8_t tmp= 0xCA;SpiritSpiWriteRegisters(0xB2, 1, &tmp); tmp= 0x04;SpiritSpiWriteRegisters(0xA8, 1, &tmp); /* just a read to loose some microsecs more */ SpiritSpiReadRegisters(0xA8, 1, &tmp); tmp= 0x00;SpiritSpiWriteRegisters(0xA8, 1, &tmp); }
/** * @brief Forces SPIRIT GPIO_x configured as digital output, to VDD or GND. * @param xGpioX Specifies the GPIO to be configured. * This parameter can be one of following parameters: * @arg SPIRIT_GPIO_0: SPIRIT GPIO_0 * @arg SPIRIT_GPIO_1: SPIRIT GPIO_1 * @arg SPIRIT_GPIO_2: SPIRIT GPIO_2 * @arg SPIRIT_GPIO_3: SPIRIT GPIO_3 * @param xLevel Specifies the level. * This parameter can be: HIGH or LOW. * @retval None. */ void SpiritGpioSetLevel(SpiritGpioPin xGpioX, OutputLevel xLevel) { uint8_t tempRegValue = 0x00; /* Check the parameters */ s_assert_param(IS_SPIRIT_GPIO(xGpioX)); s_assert_param(IS_SPIRIT_GPIO_LEVEL(xLevel)); /* Reads the SPIRIT_GPIOx register and mask the GPIO_SELECT field */ g_xStatus = SpiritSpiReadRegisters(xGpioX, 1, &tempRegValue); tempRegValue &= 0x04; /* Sets the value of the SPIRIT GPIO register according to the specified level */ if(xLevel == HIGH) { tempRegValue |= (uint8_t)SPIRIT_GPIO_DIG_OUT_VDD | (uint8_t)SPIRIT_GPIO_MODE_DIGITAL_OUTPUT_HP; } else { tempRegValue |= (uint8_t)SPIRIT_GPIO_DIG_OUT_GND | (uint8_t)SPIRIT_GPIO_MODE_DIGITAL_OUTPUT_HP; } /* Writes the SPIRIT GPIO register */ g_xStatus = SpiritSpiWriteRegisters(xGpioX, 1, &tempRegValue); }
/** * @defgroup RANGE_EXT_MANAGEMENT_FUNCTIONS SDK SPIRIT Management Range Extender Functions * @{ */ void SpiritManagementRangeExtInit(void) { RangeExtType range_type = SpiritManagementGetRangeExtender(); if(range_type==RANGE_EXT_SKYWORKS_169) { /* TCXO optimization power consumption */ SpiritGeneralSetExtRef(MODE_EXT_XIN); uint8_t tmp = 0x01; SpiritSpiWriteRegisters(0xB6,1,&tmp); /* CSD control */ SpiritGpioInit(&(SGpioInit){SPIRIT_GPIO_0, SPIRIT_GPIO_MODE_DIGITAL_OUTPUT_HP, SPIRIT_GPIO_DIG_OUT_TX_RX_MODE}); /* CTX/BYP control */ SpiritGpioInit(&(SGpioInit){SPIRIT_GPIO_1, SPIRIT_GPIO_MODE_DIGITAL_OUTPUT_HP, SPIRIT_GPIO_DIG_OUT_TX_STATE}); /* Vcont control */ SpiritGpioInit(&(SGpioInit){SPIRIT_GPIO_2, SPIRIT_GPIO_MODE_DIGITAL_OUTPUT_HP, SPIRIT_GPIO_DIG_OUT_RX_STATE}); } else if(range_type==RANGE_EXT_SKYWORKS_868) { /* CSD control */ SpiritGpioInit(&(SGpioInit){SPIRIT_GPIO_0, SPIRIT_GPIO_MODE_DIGITAL_OUTPUT_HP, SPIRIT_GPIO_DIG_OUT_TX_RX_MODE}); /* CTX/BYP control */ SpiritGpioInit(&(SGpioInit){SPIRIT_GPIO_1, SPIRIT_GPIO_MODE_DIGITAL_OUTPUT_HP, SPIRIT_GPIO_DIG_OUT_RX_STATE}); /* Vcont control */ SpiritGpioInit(&(SGpioInit){SPIRIT_GPIO_2, SPIRIT_GPIO_MODE_DIGITAL_OUTPUT_HP, SPIRIT_GPIO_DIG_OUT_TX_STATE}); } }
/** * @brief Sets a specific SYNC word for SPIRIT packets. * @param xSyncX SYNC word number to be set. * This parameter can be any value of @ref PktSyncX. * @param cSyncWord SYNC word. * This parameter is an uint8_t. * @retval None. */ void SpiritPktCommonSetSyncxWord(PktSyncX xSyncX , uint8_t cSyncWord) { uint8_t tempRegAddress; /* Check the parameters */ s_assert_param(IS_PKT_SYNCx(xSyncX)); /* Set the specified address */ switch(xSyncX){ case PKT_SYNC_WORD_1: tempRegAddress=SYNC1_BASE; break; case PKT_SYNC_WORD_2: tempRegAddress=SYNC2_BASE; break; case PKT_SYNC_WORD_3: tempRegAddress=SYNC3_BASE; break; case PKT_SYNC_WORD_4: tempRegAddress=SYNC4_BASE; break; } /* Writes value on the selected register */ g_xStatus = SpiritSpiWriteRegisters(tempRegAddress, 1, &cSyncWord); }
/** * @brief If enabled RX packet is accepted if its destination address matches with My address. * @param xNewState new state for DEST_VS_SOURCE_ADDRESS. * This parameter can be S_ENABLE or S_DISABLE. * @retval None. */ void SpiritPktCommonFilterOnMyAddress(SpiritFunctionalState xNewState) { uint8_t tempRegValue; /* Check the parameters */ s_assert_param(IS_SPIRIT_FUNCTIONAL_STATE(xNewState)); /* Modify the register value: set or reset the TX source address control */ g_xStatus = SpiritSpiReadRegisters(PCKT_FLT_OPTIONS_BASE, 1, &tempRegValue); /* Set or reset the DESTINATION vs TX enabling bit */ if(xNewState == S_ENABLE) { tempRegValue |= PCKT_FLT_OPTIONS_DEST_VS_TX_ADDR_MASK; } else { tempRegValue &= ~PCKT_FLT_OPTIONS_DEST_VS_TX_ADDR_MASK; } /* Writes the new value on the PCKT_FLT_OPTIONS register */ g_xStatus = SpiritSpiWriteRegisters(PCKT_FLT_OPTIONS_BASE, 1, &tempRegValue); }
/** * @brief Sets the battery level. * @param xBatteryLevel new state for battery level. * This parameter can be a value of @ref BatteryLevel. * @retval None. */ void SpiritGeneralSetBatteryLevel(BatteryLevel xBatteryLevel) { uint8_t tempRegValue; /* Check the parameters */ s_assert_param(IS_BLD_LVL(xBatteryLevel)); /* Reads the ANA_FUNC_CONF1_BASE register value */ g_xStatus = SpiritSpiReadRegisters(ANA_FUNC_CONF1_BASE, 1, &tempRegValue); /* Build the value to be stored */ tempRegValue &= ~ANA_FUNC_CONF1_SET_BLD_LVL_MASK; switch(xBatteryLevel) { case BLD_LVL_2_7_V: tempRegValue |= BLD_LVL_2_7; break; case BLD_LVL_2_5_V: tempRegValue |= BLD_LVL_2_5; break; case BLD_LVL_2_3_V: tempRegValue |= BLD_LVL_2_3; break; case BLD_LVL_2_1_V: tempRegValue |= BLD_LVL_2_1; break; } /* Writes the new value */ g_xStatus = SpiritSpiWriteRegisters(ANA_FUNC_CONF1_BASE, 1, &tempRegValue); }
/** * @brief If enabled RX packet is accepted only if the masked control field matches the * masked control field reference (CONTROL_MASK & CONTROL_FIELD_REF == CONTROL_MASK & RX_CONTROL_FIELD). * @param xNewState new state for Control filtering enable bit. * This parameter can be S_ENABLE or S_DISABLE. * @retval None. * @note This filtering control is enabled by default but the control mask is by default set to 0. * As a matter of fact the user has to enable the control filtering bit after the packet initialization * because the PktInit routine disables it. */ void SpiritPktCommonFilterOnControlField(SpiritFunctionalState xNewState) { uint8_t tempRegValue; /* Check the parameters */ s_assert_param(IS_SPIRIT_FUNCTIONAL_STATE(xNewState)); /* Modify the register value: set or reset the control bit filtering */ g_xStatus = SpiritSpiReadRegisters(PCKT_FLT_OPTIONS_BASE, 1, &tempRegValue); /* Set or reset the CONTROL filtering enabling bit */ if(xNewState == S_ENABLE) { tempRegValue |= PCKT_FLT_OPTIONS_CONTROL_FILTERING_MASK; } else { tempRegValue &= ~PCKT_FLT_OPTIONS_CONTROL_FILTERING_MASK; } /* Writes the new value on the PCKT_FLT_OPTIONS register */ g_xStatus = SpiritSpiWriteRegisters(PCKT_FLT_OPTIONS_BASE, 1, &tempRegValue); }
/** * @brief Sets the RX timeout timer initialization registers with the values of COUNTER and PRESCALER according to the formula: Trx=PRESCALER*COUNTER*Tck. * Remember that it is possible to have infinite RX_Timeout writing 0 in the RX_Timeout_Counter and/or RX_Timeout_Prescaler registers. * @param cCounter value for the timer counter. * This parameter must be an uint8_t. * @param cPrescaler value for the timer prescaler. * This parameter must be an uint8_t. * @retval None. */ void SpiritTimerSetRxTimeout(uint8_t cCounter , uint8_t cPrescaler) { uint8_t tempRegValue[2]={cPrescaler,cCounter}; /* Writes the prescaler and counter value for RX timeout in the corresponding register */ g_xStatus = SpiritSpiWriteRegisters(TIMERS5_RX_TIMEOUT_PRESCALER_BASE, 2, tempRegValue); }
/** * @brief Sets the LDCR wake up timer reloading registers with the values of * COUNTER and PRESCALER according to the formula: Twu=(PRESCALER +1)*(COUNTER+1)*Tck, where * Tck = 28.818 us. The minimum vale of the wakeup timeout is 28.818us (PRESCALER and * COUNTER equals to 0) and the maximum value is about 1.89 s (PRESCALER anc COUNTER equals * to 255). * @param cCounter reload value for the timer counter. * This parameter must be an uint8_t. * @param cPrescaler reload value for the timer prescaler. * This parameter must be an uint8_t. * @retval None. */ void SpiritTimerSetWakeUpTimerReload(uint8_t cCounter , uint8_t cPrescaler) { uint8_t tempRegValue[2]={cPrescaler,cCounter}; /* Writes the counter and prescaler value of reload wake-up timer in the corresponding register */ g_xStatus = SpiritSpiWriteRegisters(TIMERS1_LDC_RELOAD_PRESCALER_BASE, 2, tempRegValue); }
void SpiritManagementWaCmdStrobeRx(void) { if(s_cCommunicationState != COMMUNICATION_STATE_RX) { uint8_t tmp = 0x90; SpiritSpiWriteRegisters(PM_CONFIG1_BASE, 1, &tmp); /* Set SMPS switching frequency */ SpiritRadioSetPACwc(LOAD_0_PF); /* Set the correct CWC parameter */ s_cCommunicationState = COMMUNICATION_STATE_RX; } }
void SpiritTimerSetRxTimeoutMs(float fDesiredMsec) { uint8_t tempRegValue[2]; /* Computes the counter and prescaler value */ SpiritTimerComputeRxTimeoutValues(fDesiredMsec , &tempRegValue[1] , &tempRegValue[0]); /* Writes the prescaler and counter value for RX timeout in the corresponding register */ g_xStatus = SpiritSpiWriteRegisters(TIMERS5_RX_TIMEOUT_PRESCALER_BASE, 2, tempRegValue); }
/** * @brief Sets the LDCR wake up reload timer counter and prescaler from the desired value in ms, * according to the formula: Twu=(PRESCALER +1)*(COUNTER+1)*Tck, where Tck = 28.818 us. * The minimum vale of the wakeup timeout is 28.818us (PRESCALER and COUNTER equals to 0) * and the maximum value is about 1.89 s (PRESCALER anc COUNTER equals to 255). * @param fDesiredMsec desired timer value. * This parameter must be a float. * @retval None. */ void SpiritTimerSetWakeUpTimerReloadMs(float fDesiredMsec) { uint8_t tempRegValue[2]; /* Computes counter and prescaler */ SpiritTimerComputeWakeUpValues(fDesiredMsec , &tempRegValue[1] , &tempRegValue[0]); /* Writes the counter and prescaler value of reload wake-up timer in the corresponding register */ g_xStatus = SpiritSpiWriteRegisters(TIMERS1_LDC_RELOAD_PRESCALER_BASE, 2, tempRegValue); }
/** * @brief Sets the RSSI threshold from its dBm value according to the formula: (RSSI[Dbm] + 130)/0.5. * @param nDbmValue RSSI threshold reported in dBm. * This parameter must be a sint16_t. * @retval None. */ void SpiritQiSetRssiThresholddBm(int nDbmValue) { uint8_t tempRegValue=2*(nDbmValue+130); /* Check the parameters */ s_assert_param(IS_RSSI_THR_DBM(nDbmValue)); /* Writes the new value on the RSSI_TH register */ g_xStatus = SpiritSpiWriteRegisters(RSSI_TH_BASE, 1, &tempRegValue); }
/** * @brief Sets the payload length for SPIRIT MBUS packets. * @param nPayloadLength payload length in bytes. * This parameter is an uint16_t. * @retval None. */ void SpiritPktMbusSetPayloadLength(uint16_t nPayloadLength) { uint8_t tempRegValue[2]; /* Computes PCKTLEN0 value from nPayloadLength */ tempRegValue[1]=BUILD_PCKTLEN0(nPayloadLength);//(uint8_t)nPayloadLength; /* Computes PCKTLEN1 value from nPayloadLength */ tempRegValue[0]=BUILD_PCKTLEN1(nPayloadLength);//(uint8_t)(nPayloadLength>>8); /* Writes data on the PCKTLEN1/0 register */ g_xStatus = SpiritSpiWriteRegisters(PCKTLEN1_BASE, 2, tempRegValue); }
/** * @brief Sets the almost empty threshold for the Rx FIFO. When the number of elements in RX FIFO reaches this value an interrupt can be generated to the MCU. * @param cThrRxFifo almost empty threshold. * This parameter is an uint8_t. * @retval None. */ void SpiritLinearFifoSetAlmostEmptyThresholdRx(uint8_t cThrRxFifo) { uint8_t tempRegValue; /* Check the parameters */ s_assert_param(IS_FIFO_THR(cThrRxFifo)); /* Build the register value */ tempRegValue = cThrRxFifo & 0x7F; /* Writes the Almost Empty threshold for RX in the corresponding register */ g_xStatus = SpiritSpiWriteRegisters(FIFO_CONFIG2_RXAETHR_BASE, 1, &tempRegValue); }
/** * @brief Sets the TX control field. * @param lField Tx contro field. * This parameter is an uint32_t. * @retval None. */ void SpiritPktCommonSetTransmittedCtrlField(uint32_t lField) { uint8_t tempRegValue[4]; /* Split the 32-bit value in 4 8-bit values */ tempRegValue[3] = (uint8_t) lField; tempRegValue[2] = (uint8_t)(lField >> 8); tempRegValue[1] = (uint8_t)(lField >> 16); tempRegValue[0] = (uint8_t)(lField >> 24); /* Writes value on the TX_CTRL_FIELDx register */ g_xStatus = SpiritSpiWriteRegisters(TX_CTRL_FIELD3_BASE, 4, tempRegValue); }
/** * @brief Sets the control field reference. If the bits enabled by the CONTROL_MASK * match the ones of the control fields extracted from the received packet * then the packet is accepted. * @param lReference Control reference. * This parameter is an uint32_t. * @retval None. */ void SpiritPktCommonSetCtrlReference(uint32_t lReference) { uint8_t tempRegValue[4]; /* Split the 32-bit value in 4 8-bit values */ tempRegValue[0] = (uint8_t) lReference; tempRegValue[1] = (uint8_t)(lReference >> 8); tempRegValue[2] = (uint8_t)(lReference >> 16); tempRegValue[3] = (uint8_t)(lReference >> 24); /* Writes values on the CKT_FLT_GOALS_CONTROLx_FIELD registers */ g_xStatus = SpiritSpiWriteRegisters(PCKT_FLT_GOALS_CONTROL0_FIELD_BASE, 4, tempRegValue); }
/** * @brief Sets the control mask. The 1 bits of the CONTROL_MASK indicate the * bits to be used in filtering. (All 0s no filtering) * @param lMask Control mask. * This parameter is an uint32_t. * @retval None. */ void SpiritPktCommonSetCtrlMask(uint32_t lMask) { uint8_t tempRegValue[4]; /* Split the 32-bit value in 4 8-bit values */ tempRegValue[0] = (uint8_t) lMask; tempRegValue[1] = (uint8_t)(lMask >> 8); tempRegValue[2] = (uint8_t)(lMask >> 16); tempRegValue[3] = (uint8_t)(lMask >> 24); /* Writes values on the CKT_FLT_GOALS_CONTROLx_MASK registers */ g_xStatus = SpiritSpiWriteRegisters(PCKT_FLT_GOALS_CONTROL0_MASK_BASE, 4, tempRegValue); }
/** * @brief Initializes the SPIRIT GPIOx according to the specified * parameters in the pxGpioInitStruct. * @param pxGpioInitStruct pointer to a SGpioInit structure that * contains the configuration information for the specified SPIRIT GPIO. * @retval None. */ void SpiritGpioInit(SGpioInit* pxGpioInitStruct) { uint8_t tempRegValue = 0x00; /* Check the parameters */ s_assert_param(IS_SPIRIT_GPIO(pxGpioInitStruct->xSpiritGpioPin)); s_assert_param(IS_SPIRIT_GPIO_MODE(pxGpioInitStruct->xSpiritGpioMode)); s_assert_param(IS_SPIRIT_GPIO_IO(pxGpioInitStruct->xSpiritGpioIO)); tempRegValue = ((uint8_t)(pxGpioInitStruct->xSpiritGpioMode) | (uint8_t)(pxGpioInitStruct->xSpiritGpioIO)); g_xStatus = SpiritSpiWriteRegisters(pxGpioInitStruct->xSpiritGpioPin, 1, &tempRegValue); }
/** * @brief De initializate the SpiritIrqs structure setting all the bitfield to 0. * Moreover, it sets the IRQ mask registers to 0x00000000, disabling all IRQs. * @param pxIrqInit pointer to a variable of type @ref SpiritIrqs, in which all the * bitfields will be settled to zero. * @retval None. */ void SpiritIrqDeInit(SpiritIrqs* pxIrqInit) { uint8_t tempRegValue[4]={0x00,0x00,0x00,0x00}; if(pxIrqInit!=NULL) { uint32_t tempValue = 0x00000000; /* Sets the bitfields of passed structure to one */ *pxIrqInit = (*(SpiritIrqs*)(&tempValue)); } /* Writes the IRQ_MASK registers */ g_xStatus = SpiritSpiWriteRegisters(IRQ_MASK3_BASE, 4, tempRegValue); }
/** * @brief Enables all the IRQs according to the user defined pxIrqInit structure. * @param pxIrqInit pointer to a variable of type @ref SpiritIrqs, through which the * user enable specific IRQs. This parameter is a pointer to a SpiritIrqs. * For example suppose to enable only the two IRQ Low Battery Level and Tx Data Sent: * @code * SpiritIrqs myIrqInit = {0}; * myIrqInit.IRQ_LOW_BATT_LVL = 1; * myIrqInit.IRQ_TX_DATA_SENT = 1; * SpiritIrqInit(&myIrqInit); * @endcode * @retval None. */ void SpiritIrqInit(SpiritIrqs* pxIrqInit) { uint8_t tempRegValue[4]; uint8_t* tmpPoint; /* Cast the bitfields structure in an array of char using */ tmpPoint = (uint8_t*)(pxIrqInit); for(uint8_t i=0; i<4; i++) { tempRegValue[3-i]= tmpPoint[i]; } /* Writes the IRQ_MASK registers */ g_xStatus = SpiritSpiWriteRegisters(IRQ_MASK3_BASE, 4, tempRegValue); }
/** * @brief Sets the TX sequence number to be used to start counting. * @param cSeqNumberReload new value for Tx seq number reload. * @retval None. */ void SpiritPktCommonSetTransmittedSeqNumberReload(uint8_t cSeqNumberReload){ uint8_t tempRegValue; /* Check the parameters */ s_assert_param(IS_PKT_SEQ_NUMBER_RELOAD(cSeqNumberReload)); /* Reads value on the PROTOCOL2 register */ g_xStatus = SpiritSpiReadRegisters(PROTOCOL2_BASE, 1, &tempRegValue); tempRegValue &= 0xE7; tempRegValue |= (cSeqNumberReload << 3); /* Writes value on the PROTOCOL2 register */ g_xStatus = SpiritSpiWriteRegisters(PROTOCOL2_BASE, 1, &tempRegValue); }
/** * @brief Sets multiple SYNC words for SPIRIT packets. * @param lSyncWords SYNC words to be set with format: 0x|SYNC1|SYNC2|SYNC3|SYNC4|. * This parameter is a uint32_t. * @param xSyncLength SYNC length in bytes. The 32bit word passed will be stored in the SYNCx registers from the MSb * until the number of bytes in xSyncLength has been stored. * This parameter is a @ref PktSyncLength. * @retval None. */ void SpiritPktCommonSetSyncWords(uint32_t lSyncWords, PktSyncLength xSyncLength) { uint8_t tempRegValue[4]; uint8_t i; /* Split the 32-bit value in 4 8-bit values */ for(i=0 ; i<4 ; i++){ if(i<3-xSyncLength>>1) tempRegValue[i]=0; else tempRegValue[i]=(uint8_t)(lSyncWords>>(8*i)); } /* Writes SYNC value on the SYNCx registers */ g_xStatus = SpiritSpiWriteRegisters(SYNC4_BASE, 4, tempRegValue); }
/** * @brief Initializes the SPIRIT Clock Output according to the specified * parameters in the xClockOutputInitStruct. * @param pxClockOutputInitStruct pointer to a ClockOutputInit structure that * contains the configuration information for the SPIRIT Clock Output. * @retval None. * @note The function SpiritGpioClockOutput() must be called in order to enable * or disable the MCU clock dividers. */ void SpiritGpioClockOutputInit(ClockOutputInit* pxClockOutputInitStruct) { uint8_t tempRegValue = 0x00; /* Check the parameters */ s_assert_param(IS_SPIRIT_CLOCK_OUTPUT_XO(pxClockOutputInitStruct->xClockOutputXOPrescaler)); s_assert_param(IS_SPIRIT_CLOCK_OUTPUT_RCO(pxClockOutputInitStruct->xClockOutputRCOPrescaler)); s_assert_param(IS_SPIRIT_CLOCK_OUTPUT_EXTRA_CYCLES(pxClockOutputInitStruct->xExtraClockCycles)); /* Calculates the register value to write according to the specified configuration */ tempRegValue = ((uint8_t)(pxClockOutputInitStruct->xClockOutputXOPrescaler) | (uint8_t)(pxClockOutputInitStruct->xClockOutputRCOPrescaler) | \ (uint8_t)(pxClockOutputInitStruct->xExtraClockCycles)); /* Writes the MCU_CLOCK register */ g_xStatus = SpiritSpiWriteRegisters(MCU_CK_CONF_BASE, 1, &tempRegValue); }
/** * @brief Sets the almost empty threshold for the Tx FIFO. When the number of elements in Tx FIFO reaches this value an interrupt can can be generated to the MCU. * @param cThrTxFifo: almost empty threshold. * This parameter is an uint8_t. * @retval None. */ void SpiritLinearFifoSetAlmostEmptyThresholdTx(uint8_t cThrTxFifo) { uint8_t tempRegValue; /* Check the parameters */ s_assert_param(IS_FIFO_THR(cThrTxFifo)); /* Reads the register value */ g_xStatus = SpiritSpiReadRegisters(FIFO_CONFIG0_TXAETHR_BASE, 1, &tempRegValue); /* Build the register value */ tempRegValue &= 0x80; tempRegValue |= cThrTxFifo; /* Writes the Almost Empty threshold for Tx in the corresponding register */ g_xStatus = SpiritSpiWriteRegisters(FIFO_CONFIG0_TXAETHR_BASE, 1, &tempRegValue); }
/** * @brief Sets the CRC mode for SPIRIT packets. * @param xCrcMode length of CRC field in bytes. * This parameter can be any value of @ref PktCrcMode. * @retval None. */ void SpiritPktCommonSetCrcMode(PktCrcMode xCrcMode) { uint8_t tempRegValue; /* Check the parameters */ s_assert_param(IS_PKT_CRC_MODE(xCrcMode)); /* Reads the PCKTCTRL1 register value */ g_xStatus = SpiritSpiReadRegisters(PCKTCTRL1_BASE, 1, &tempRegValue); /* Build data to write setting the CRC mode */ tempRegValue &= ~PCKTCTRL1_CRC_MODE_MASK; tempRegValue |= (uint8_t)xCrcMode; /* Writes the new value on the PCKTCTRL1 register */ g_xStatus = SpiritSpiWriteRegisters(PCKTCTRL1_BASE, 1, &tempRegValue); }
/** * @brief Sets fixed or variable payload length mode for SPIRIT packets. * @param xFixVarLength variable or fixed length. * PKT_FIXED_LENGTH_VAR -> variable (the length is extracted from the received packet). * PKT_FIXED_LENGTH_FIX -> fix (the length is set by PCKTLEN0 and PCKTLEN1). * @retval None. */ void SpiritPktCommonSetFixVarLength(PktFixVarLength xFixVarLength) { uint8_t tempRegValue; /* Check the parameters */ s_assert_param(IS_PKT_FIX_VAR_LENGTH(xFixVarLength)); /* Reads the PCKTCTRL2 register value */ g_xStatus = SpiritSpiReadRegisters(PCKTCTRL2_BASE, 1, &tempRegValue); /* Set fixed or variable address mode */ tempRegValue &= ~PCKTCTRL2_FIX_VAR_LEN_MASK; tempRegValue |= (uint8_t)xFixVarLength; /* Writes the new value on the PCKTCTRL2 register */ g_xStatus = SpiritSpiWriteRegisters(PCKTCTRL2_BASE, 1, &tempRegValue); }