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