Added support for WNC M14A2A Cellular LTE Data Module.
Dependencies: WNC14A2AInterface
Dependents: http-example-wnc http-example-wnc-modified
SPIRIT_PktStack.c
00001 /** 00002 ****************************************************************************** 00003 * @file SPIRIT_PktStack.c 00004 * @author VMA division - AMS 00005 * @version 3.2.2 00006 * @date 08-July-2015 00007 * @brief Configuration and management of SPIRIT STack packets. 00008 * @details 00009 * 00010 * @attention 00011 * 00012 * <h2><center>© COPYRIGHT(c) 2015 STMicroelectronics</center></h2> 00013 * 00014 * Redistribution and use in source and binary forms, with or without modification, 00015 * are permitted provided that the following conditions are met: 00016 * 1. Redistributions of source code must retain the above copyright notice, 00017 * this list of conditions and the following disclaimer. 00018 * 2. Redistributions in binary form must reproduce the above copyright notice, 00019 * this list of conditions and the following disclaimer in the documentation 00020 * and/or other materials provided with the distribution. 00021 * 3. Neither the name of STMicroelectronics nor the names of its contributors 00022 * may be used to endorse or promote products derived from this software 00023 * without specific prior written permission. 00024 * 00025 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 00026 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 00027 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 00028 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE 00029 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 00030 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 00031 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 00032 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 00033 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 00034 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 00035 * 00036 ****************************************************************************** 00037 */ 00038 00039 /* Includes ------------------------------------------------------------------*/ 00040 #include "SPIRIT_PktStack.h" 00041 #include "MCU_Interface.h" 00042 00043 00044 /** 00045 * @addtogroup SPIRIT_Libraries 00046 * @{ 00047 */ 00048 00049 00050 /** 00051 * @addtogroup SPIRIT_PktStack 00052 * @{ 00053 */ 00054 00055 00056 /** 00057 * @defgroup PktStack_Private_TypesDefinitions Pkt STack Private Types Definitions 00058 * @{ 00059 */ 00060 00061 /** 00062 *@} 00063 */ 00064 00065 00066 /** 00067 * @defgroup PktStack_Private_Defines Pkt STack Private Defines 00068 * @{ 00069 */ 00070 00071 /** 00072 *@} 00073 */ 00074 00075 00076 /** 00077 * @defgroup PktStack_Private_Macros Pkt STack Private Macros 00078 * @{ 00079 */ 00080 00081 /** 00082 *@} 00083 */ 00084 00085 00086 /** 00087 * @defgroup PktStack_Private_Variables Pkt STack Private Variables 00088 * @{ 00089 */ 00090 00091 /** 00092 *@} 00093 */ 00094 00095 00096 /** 00097 * @defgroup PktStack_Private_FunctionPrototypes Pkt STack Private Function Prototypes 00098 * @{ 00099 */ 00100 00101 /** 00102 *@} 00103 */ 00104 00105 00106 /** 00107 * @defgroup PktStack_Private_Functions Pkt STack Private Functions 00108 * @{ 00109 */ 00110 00111 00112 /** 00113 * @brief Initializes the SPIRIT STack packet according to the specified 00114 * parameters in the PktStackInit. 00115 * @param pxPktStackInit STack packet init structure. 00116 * This parameter is a pointer to @ref PktStackInit. 00117 * @retval None. 00118 */ 00119 void SpiritPktStackInit(PktStackInit* pxPktStackInit) 00120 { 00121 uint8_t tempRegValue[4], i; 00122 00123 /* Check the parameters */ 00124 s_assert_param(IS_STACK_PREAMBLE_LENGTH(pxPktStackInit->xPreambleLength)); 00125 s_assert_param(IS_STACK_SYNC_LENGTH(pxPktStackInit->xSyncLength)); 00126 s_assert_param(IS_STACK_CRC_MODE(pxPktStackInit->xCrcMode)); 00127 s_assert_param(IS_STACK_LENGTH_WIDTH_BITS(pxPktStackInit->cPktLengthWidth)); 00128 s_assert_param(IS_STACK_FIX_VAR_LENGTH(pxPktStackInit->xFixVarLength)); 00129 s_assert_param(IS_SPIRIT_FUNCTIONAL_STATE(pxPktStackInit->xFec)); 00130 s_assert_param(IS_SPIRIT_FUNCTIONAL_STATE(pxPktStackInit->xDataWhitening)); 00131 s_assert_param(IS_STACK_CONTROL_LENGTH(pxPktStackInit->xControlLength)); 00132 00133 00134 /* Reads the PROTOCOL1 register */ 00135 g_xStatus = SpiritSpiReadRegisters(PROTOCOL1_BASE, 1, &tempRegValue[0]); 00136 00137 /* Mask a reserved bit */ 00138 tempRegValue[0] &= ~0x20; 00139 00140 /* Always (!) set the automatic packet filtering */ 00141 tempRegValue[0] |= PROTOCOL1_AUTO_PCKT_FLT_MASK; 00142 00143 /* Writes the value on register */ 00144 g_xStatus = SpiritSpiWriteRegisters(PROTOCOL1_BASE, 1, &tempRegValue[0]); 00145 00146 /* Reads the PCKT_FLT_OPTIONS register */ 00147 g_xStatus = SpiritSpiReadRegisters(PCKT_FLT_OPTIONS_BASE, 1, &tempRegValue[0]); 00148 00149 /* Always reset the control and source filtering */ 00150 tempRegValue[0] &= ~(PCKT_FLT_OPTIONS_SOURCE_FILTERING_MASK | PCKT_FLT_OPTIONS_CONTROL_FILTERING_MASK); 00151 00152 /* Writes the value on register */ 00153 g_xStatus = SpiritSpiWriteRegisters(PCKT_FLT_OPTIONS_BASE, 1, &tempRegValue[0]); 00154 00155 00156 /* Address and control length setting: source and destination address are always present so ADDRESS_LENGTH=2 */ 00157 tempRegValue[0] = 0x10 | ((uint8_t) pxPktStackInit->xControlLength); 00158 00159 00160 /* Packet format and width length setting */ 00161 pxPktStackInit->cPktLengthWidth == 0 ? pxPktStackInit->cPktLengthWidth=1 : pxPktStackInit->cPktLengthWidth; 00162 tempRegValue[1] = ((uint8_t) PCKTCTRL3_PCKT_FRMT_STACK) | ((uint8_t)(pxPktStackInit->cPktLengthWidth-1)); 00163 00164 /* Preamble, sync and fixed or variable length setting */ 00165 tempRegValue[2] = ((uint8_t) pxPktStackInit->xPreambleLength) | ((uint8_t) pxPktStackInit->xSyncLength) | 00166 ((uint8_t) pxPktStackInit->xFixVarLength); 00167 00168 /* CRC length, whitening and FEC setting */ 00169 tempRegValue[3] = (uint8_t) pxPktStackInit->xCrcMode; 00170 00171 if(pxPktStackInit->xDataWhitening == S_ENABLE) 00172 { 00173 tempRegValue[3] |= PCKTCTRL1_WHIT_MASK; 00174 } 00175 00176 if(pxPktStackInit->xFec == S_ENABLE) 00177 { 00178 tempRegValue[3] |= PCKTCTRL1_FEC_MASK; 00179 } 00180 00181 /* Writes registers */ 00182 SpiritSpiWriteRegisters(PCKTCTRL4_BASE, 4, tempRegValue); 00183 00184 /* Sync words setting */ 00185 for(i=0;i<4;i++) 00186 { 00187 if(i<3-(pxPktStackInit->xSyncLength >>1)) 00188 { 00189 tempRegValue[i]=0; 00190 } 00191 else 00192 { 00193 tempRegValue[i] = (uint8_t)(pxPktStackInit->lSyncWords>>(8*i)); 00194 } 00195 } 00196 00197 /* Enables or disables the CRC check */ 00198 if(pxPktStackInit->xCrcMode == PKT_NO_CRC) 00199 { 00200 SpiritPktStackFilterOnCrc(S_DISABLE); 00201 } 00202 else 00203 { 00204 SpiritPktStackFilterOnCrc(S_ENABLE); 00205 } 00206 00207 /* Writes registers */ 00208 g_xStatus = SpiritSpiWriteRegisters(SYNC4_BASE, 4, tempRegValue); 00209 00210 } 00211 00212 00213 /** 00214 * @brief Returns the SPIRIT STack packet structure according to the specified parameters in the registers. 00215 * @param pxPktStackInit STack packet init structure. 00216 * This parameter is a pointer to @ref PktStackInit. 00217 * @retval None. 00218 */ 00219 void SpiritPktStackGetInfo(PktStackInit* pxPktStackInit) 00220 { 00221 uint8_t tempRegValue[10]; 00222 00223 /* Reads registers */ 00224 g_xStatus = SpiritSpiReadRegisters(PCKTCTRL4_BASE, 10, tempRegValue); 00225 00226 /* Length width */ 00227 pxPktStackInit->cPktLengthWidth=(tempRegValue[1] & 0x0F)+1; 00228 00229 /* Control length */ 00230 pxPktStackInit->xControlLength=(StackControlLength)(tempRegValue[0] & 0x07); 00231 00232 /* CRC mode */ 00233 pxPktStackInit->xCrcMode=(StackCrcMode)(tempRegValue[3] & 0xE0); 00234 00235 /* Whitening */ 00236 pxPktStackInit->xDataWhitening=(SpiritFunctionalState)((tempRegValue[3] >> 4) & 0x01); 00237 00238 /* FEC */ 00239 pxPktStackInit->xFec=(SpiritFunctionalState)(tempRegValue[3] & 0x01); 00240 00241 /* FIX or VAR bit */ 00242 pxPktStackInit->xFixVarLength=(StackFixVarLength)(tempRegValue[2] & 0x01); 00243 00244 /* Preamble length */ 00245 pxPktStackInit->xPreambleLength=(StackPreambleLength)(tempRegValue[2] & 0xF8); 00246 00247 /* Sync length */ 00248 pxPktStackInit->xSyncLength=(StackSyncLength)(tempRegValue[2] & 0x06); 00249 00250 /* sync Words */ 00251 pxPktStackInit->lSyncWords=0; 00252 for(uint8_t i=0 ; i<4 ; i++) 00253 { 00254 if(i>2-(pxPktStackInit->xSyncLength >>1)) 00255 { 00256 pxPktStackInit->lSyncWords |= tempRegValue[i+6]<<(8*i); 00257 } 00258 } 00259 00260 } 00261 00262 00263 /** 00264 * @brief Initializes the SPIRIT STack packet addresses according to the specified 00265 * parameters in the PktStackAddresses struct. 00266 * @param pxPktStackAddresses STack packet addresses init structure. 00267 * This parameter is a pointer to @ref PktStackAddressesInit . 00268 * @retval None. 00269 */ 00270 void SpiritPktStackAddressesInit(PktStackAddressesInit* pxPktStackAddresses) 00271 { 00272 uint8_t tempRegValue[3]; 00273 00274 /* Check the parameters */ 00275 s_assert_param(IS_SPIRIT_FUNCTIONAL_STATE(pxPktStackAddresses->xFilterOnMyAddress)); 00276 s_assert_param(IS_SPIRIT_FUNCTIONAL_STATE(pxPktStackAddresses->xFilterOnMulticastAddress)); 00277 s_assert_param(IS_SPIRIT_FUNCTIONAL_STATE(pxPktStackAddresses->xFilterOnBroadcastAddress)); 00278 00279 /* Reads the filtering options ragister */ 00280 g_xStatus = SpiritSpiReadRegisters(PCKT_FLT_OPTIONS_BASE, 1, &tempRegValue[0]); 00281 00282 /* Enables or disables filtering on my address */ 00283 if(pxPktStackAddresses->xFilterOnMyAddress == S_ENABLE) 00284 { 00285 tempRegValue[0] |= PCKT_FLT_OPTIONS_DEST_VS_TX_ADDR_MASK; 00286 } 00287 else 00288 { 00289 tempRegValue[0] &= ~PCKT_FLT_OPTIONS_DEST_VS_TX_ADDR_MASK; 00290 } 00291 00292 /* Enables or disables filtering on multicast address */ 00293 if(pxPktStackAddresses->xFilterOnMulticastAddress == S_ENABLE) 00294 { 00295 tempRegValue[0] |= PCKT_FLT_OPTIONS_DEST_VS_MULTICAST_ADDR_MASK; 00296 } 00297 else 00298 { 00299 tempRegValue[0] &= ~PCKT_FLT_OPTIONS_DEST_VS_MULTICAST_ADDR_MASK; 00300 } 00301 00302 /* Enables or disables filtering on broadcast address */ 00303 if(pxPktStackAddresses->xFilterOnBroadcastAddress == S_ENABLE) 00304 { 00305 tempRegValue[0] |= PCKT_FLT_OPTIONS_DEST_VS_BROADCAST_ADDR_MASK; 00306 } 00307 else 00308 { 00309 tempRegValue[0] &= ~PCKT_FLT_OPTIONS_DEST_VS_BROADCAST_ADDR_MASK; 00310 } 00311 00312 /* Writes value on the register */ 00313 g_xStatus = SpiritSpiWriteRegisters(PCKT_FLT_OPTIONS_BASE, 1, &tempRegValue[0]); 00314 00315 /* Fills array with the addresses passed in the structure */ 00316 tempRegValue[0] = pxPktStackAddresses->cBroadcastAddress; 00317 tempRegValue[1] = pxPktStackAddresses->cMulticastAddress; 00318 tempRegValue[2] = pxPktStackAddresses->cMyAddress; 00319 00320 /* Writes them on the addresses registers */ 00321 g_xStatus = SpiritSpiWriteRegisters(PCKT_FLT_GOALS_BROADCAST_BASE, 3, tempRegValue); 00322 00323 } 00324 00325 00326 /** 00327 * @brief Returns the SPIRIT STack packet addresses structure according to the specified 00328 * parameters in the registers. 00329 * @param pxPktStackAddresses STack packet addresses init structure. 00330 * This parameter is a pointer to @ref PktStackAddresses. 00331 * @retval None. 00332 */ 00333 void SpiritPktStackGetAddressesInfo(PktStackAddressesInit* pxPktStackAddresses) 00334 { 00335 uint8_t tempRegValue[3]; 00336 00337 /* Reads values on the PCKT_FLT_GOALS registers */ 00338 g_xStatus = SpiritSpiReadRegisters(PCKT_FLT_GOALS_BROADCAST_BASE, 3, tempRegValue); 00339 00340 /* Fit the structure with the read addresses */ 00341 pxPktStackAddresses->cBroadcastAddress = tempRegValue[0]; 00342 pxPktStackAddresses->cMulticastAddress = tempRegValue[1]; 00343 pxPktStackAddresses->cMyAddress = tempRegValue[2]; 00344 00345 g_xStatus = SpiritSpiReadRegisters(PCKT_FLT_OPTIONS_BASE, 1, &tempRegValue[0]); 00346 00347 /* Fit the structure with the read filtering bits */ 00348 pxPktStackAddresses->xFilterOnBroadcastAddress = (SpiritFunctionalState)((tempRegValue[0] >> 1) & 0x01); 00349 pxPktStackAddresses->xFilterOnMulticastAddress = (SpiritFunctionalState)((tempRegValue[0] >> 2) & 0x01); 00350 pxPktStackAddresses->xFilterOnMyAddress = (SpiritFunctionalState)((tempRegValue[0] >> 3) & 0x01); 00351 00352 } 00353 00354 00355 /** 00356 * @brief Initializes the SPIRIT STack packet LLP options according to the specified 00357 * parameters in the PktStackLlpInit struct. 00358 * @param pxPktStackLlpInit STack packet LLP init structure. 00359 * This parameter is a pointer to @ref PktStackLlpInit. 00360 * @retval None. 00361 */ 00362 void SpiritPktStackLlpInit(PktStackLlpInit* pxPktStackLlpInit) 00363 { 00364 uint8_t tempRegValue[2]; 00365 00366 /* Check the parameters */ 00367 s_assert_param(IS_SPIRIT_FUNCTIONAL_STATE(pxPktStackLlpInit->xPiggybacking)); 00368 s_assert_param(IS_SPIRIT_FUNCTIONAL_STATE(pxPktStackLlpInit->xAutoAck)); 00369 s_assert_param(IS_STACK_NMAX_RETX(pxPktStackLlpInit->xNMaxRetx)); 00370 /* check if piggybacking is enabled and autoack is disabled */ 00371 s_assert_param(!(pxPktStackLlpInit->xPiggybacking==S_ENABLE && pxPktStackLlpInit->xAutoAck==S_DISABLE)); 00372 00373 /* Piggybacking mechanism setting on the PROTOCOL1 register */ 00374 g_xStatus = SpiritSpiReadRegisters(PROTOCOL1_BASE, 2, tempRegValue); 00375 if(pxPktStackLlpInit->xPiggybacking == S_ENABLE) 00376 { 00377 tempRegValue[0] |= PROTOCOL1_PIGGYBACKING_MASK; 00378 } 00379 else 00380 { 00381 tempRegValue[0] &= ~PROTOCOL1_PIGGYBACKING_MASK; 00382 } 00383 00384 /* RX and TX autoack mechanisms setting on the PROTOCOL0 register */ 00385 if(pxPktStackLlpInit->xAutoAck == S_ENABLE) 00386 { 00387 tempRegValue[1] |= PROTOCOL0_AUTO_ACK_MASK; 00388 } 00389 else 00390 { 00391 tempRegValue[1] &= ~PROTOCOL0_AUTO_ACK_MASK; 00392 } 00393 00394 /* Max number of retransmission setting */ 00395 tempRegValue[1] &= ~PROTOCOL0_NMAX_RETX_MASK; 00396 tempRegValue[1] |= pxPktStackLlpInit->xNMaxRetx; 00397 00398 /* Writes registers */ 00399 g_xStatus = SpiritSpiWriteRegisters(PROTOCOL1_BASE, 2, tempRegValue); 00400 00401 } 00402 00403 00404 /** 00405 * @brief Returns the SPIRIT STack packet LLP options according to the specified 00406 * values in the registers. 00407 * @param pxPktStackLlpInit STack packet LLP structure. 00408 * This parameter is a pointer to @ref PktStackLlpInit. 00409 * @retval None. 00410 */ 00411 void SpiritPktStackLlpGetInfo(PktStackLlpInit* pxPktStackLlpInit) 00412 { 00413 uint8_t tempRegValue[2]; 00414 00415 /* Piggybacking mechanism setting on the PROTOCOL1 register */ 00416 g_xStatus = SpiritSpiReadRegisters(PROTOCOL1_BASE, 2, tempRegValue); 00417 00418 /* Fit the structure with the read values */ 00419 pxPktStackLlpInit->xPiggybacking = (SpiritFunctionalState)((tempRegValue[0] >> 6) & 0x01); 00420 pxPktStackLlpInit->xAutoAck = (SpiritFunctionalState)((tempRegValue[1] >> 2) & 0x01); 00421 pxPktStackLlpInit->xNMaxRetx = (StackNMaxReTx)(tempRegValue[1] & PROTOCOL0_NMAX_RETX_MASK); 00422 00423 } 00424 00425 00426 /** 00427 * @brief Configures the STack packet format for SPIRIT. 00428 * @param None. 00429 * @retval None. 00430 */ 00431 void SpiritPktStackSetFormat(void) 00432 { 00433 uint8_t tempRegValue; 00434 00435 /* Reads the PCKTCTRL3 register value */ 00436 g_xStatus = SpiritSpiReadRegisters(PCKTCTRL3_BASE, 1, &tempRegValue); 00437 00438 /* Build value to be written. Also set to 0 the direct RX mode bits */ 00439 tempRegValue &= 0x0F; 00440 tempRegValue |= ((uint8_t)PCKTCTRL3_PCKT_FRMT_STACK); 00441 00442 /* Writes the value on the PCKTCTRL3 register. */ 00443 g_xStatus = SpiritSpiWriteRegisters(PCKTCTRL3_BASE, 1, &tempRegValue); 00444 00445 /* Reads the PCKTCTRL1 register value */ 00446 g_xStatus = SpiritSpiReadRegisters(PCKTCTRL1_BASE, 1, &tempRegValue); 00447 00448 /* Build the new value. Set to 0 the direct TX mode bits */ 00449 tempRegValue &= 0xF3; 00450 00451 /* Writes the PCKTCTRL1 value on register */ 00452 g_xStatus = SpiritSpiWriteRegisters(PCKTCTRL1_BASE, 1, &tempRegValue); 00453 00454 /* Reads the PROTOCOL1 register */ 00455 g_xStatus = SpiritSpiReadRegisters(PROTOCOL1_BASE, 1, &tempRegValue); 00456 00457 /* Mask a reserved bit */ 00458 tempRegValue &= ~0x20; 00459 00460 /* Writes the value on the PROTOCOL1 register */ 00461 g_xStatus = SpiritSpiWriteRegisters(PROTOCOL1_BASE, 1, &tempRegValue); 00462 00463 } 00464 00465 00466 /** 00467 * @brief Sets the address length for SPIRIT STack packets (always 2). 00468 * @param None. 00469 * @retval None. 00470 */ 00471 void SpiritPktStackSetAddressLength(void) 00472 { 00473 uint8_t tempRegValue; 00474 00475 /* Reads the PCKTCTRL4 register value */ 00476 g_xStatus = SpiritSpiReadRegisters(PCKTCTRL4_BASE, 1, &tempRegValue); 00477 00478 /* Build the new value */ 00479 tempRegValue &= ~PCKTCTRL4_ADDRESS_LEN_MASK; 00480 tempRegValue |= ((uint8_t)0x10); 00481 00482 /* Writes the value on the PCKTCTRL4 register */ 00483 g_xStatus = SpiritSpiWriteRegisters(PCKTCTRL4_BASE, 1, &tempRegValue); 00484 00485 } 00486 00487 00488 /** 00489 * @brief Sets the payload length for SPIRIT STack packets. Since the packet length 00490 * depends from the address (always 2 for this packet format) 00491 * and the control field size, this function reads the control length register 00492 * content in order to determine the correct packet length to be written. 00493 * @param nPayloadLength payload length in bytes. 00494 * This parameter can be any value of uint16_t. 00495 * @retval None. 00496 */ 00497 void SpiritPktStackSetPayloadLength(uint16_t nPayloadLength) 00498 { 00499 uint8_t tempRegValue[2]; 00500 00501 /* Computes the oversize (address + control) size */ 00502 uint16_t overSize = 2 + (uint16_t) SpiritPktStackGetControlLength(); 00503 00504 /* Computes PCKTLEN0 value from lPayloadLength */ 00505 tempRegValue[1]=STACK_BUILD_PCKTLEN0(nPayloadLength+overSize); 00506 /* Computes PCKTLEN1 value from lPayloadLength */ 00507 tempRegValue[0]=STACK_BUILD_PCKTLEN1(nPayloadLength+overSize); 00508 00509 /* Writes the value on the PCKTLENx registers */ 00510 g_xStatus = SpiritSpiWriteRegisters(PCKTLEN1_BASE, 2, tempRegValue); 00511 00512 } 00513 00514 00515 /** 00516 * @brief Returns the payload length for SPIRIT STack packets. Since the 00517 * packet length depends from the address and the control 00518 * field size, this function reads the correspondent 00519 * registers in order to determine the correct payload length 00520 * to be returned. 00521 * @param None. 00522 * @retval uint16_t Payload length. 00523 */ 00524 uint16_t SpiritPktStackGetPayloadLength(void) 00525 { 00526 uint8_t tempRegValue[2]; 00527 /* Computes the oversize (address + control) size */ 00528 uint16_t overSize = 2 + (uint16_t) SpiritPktStackGetControlLength(); 00529 00530 /* Reads the PCKTLEN1 registers value */ 00531 g_xStatus = SpiritSpiReadRegisters(PCKTLEN1_BASE, 2, tempRegValue); 00532 00533 /* Rebuild and return the payload length value */ 00534 return ((((uint16_t) tempRegValue[1])<<8) + (uint16_t) tempRegValue[0] - overSize); 00535 00536 } 00537 00538 00539 /** 00540 * @brief Computes and sets the variable payload length for SPIRIT STack packets. 00541 * @param nMaxPayloadLength payload length in bytes. 00542 * This parameter is an uint16_t. 00543 * @param xControlLength control length in bytes. 00544 * This parameter can be any value of @ref StackControlLength. 00545 * @retval None. 00546 */ 00547 void SpiritPktStackSetVarLengthWidth(uint16_t nMaxPayloadLength, StackControlLength xControlLength) 00548 { 00549 uint8_t tempRegValue, 00550 i; 00551 uint32_t packetLength; 00552 00553 00554 /* packet length = payload length + address length (2) + control length */ 00555 packetLength=nMaxPayloadLength+2+xControlLength; 00556 00557 /* Computes the number of bits */ 00558 for(i=0;i<16;i++) 00559 { 00560 if(packetLength == 0) 00561 { 00562 break; 00563 } 00564 packetLength >>= 1; 00565 } 00566 i==0 ? i=1 : i; 00567 00568 /* Reads the PCKTCTRL3 register value */ 00569 g_xStatus = SpiritSpiReadRegisters(PCKTCTRL3_BASE, 1, &tempRegValue); 00570 00571 /* Build the register value */ 00572 tempRegValue &= ~PCKTCTRL3_LEN_WID_MASK; 00573 tempRegValue |= ((uint8_t)(i-1)); 00574 00575 /* Writes the PCKTCTRL3 register value */ 00576 g_xStatus = SpiritSpiWriteRegisters(PCKTCTRL3_BASE, 1, &tempRegValue); 00577 00578 } 00579 00580 00581 /** 00582 * @brief Rx packet source mask. Used to mask the address of the accepted packets. If 0 -> no filtering. 00583 * @param cMask Rx source mask. 00584 * This parameter is an uint8_t. 00585 * @retval None. 00586 */ 00587 void SpiritPktStackSetRxSourceMask(uint8_t cMask) 00588 { 00589 /* Writes value on the register PCKT_FLT_GOALS_SOURCE_MASK */ 00590 g_xStatus = SpiritSpiWriteRegisters(PCKT_FLT_GOALS_SOURCE_MASK_BASE, 1, &cMask); 00591 00592 } 00593 00594 00595 /** 00596 * @brief Returns the Rx packet source mask. Used to mask the address of the accepted packets. If 0 -> no filtering. 00597 * @param None. 00598 * @retval uint8_t Rx source mask. 00599 */ 00600 uint8_t SpiritPktStackGetRxSourceMask(void) 00601 { 00602 uint8_t tempRegValue; 00603 00604 /* Writes value on the PCKT_FLT_GOALS_SOURCE_MASK register */ 00605 g_xStatus = SpiritSpiReadRegisters(PCKT_FLT_GOALS_SOURCE_MASK_BASE, 1, &tempRegValue); 00606 00607 /* Return the read value */ 00608 return tempRegValue; 00609 00610 } 00611 00612 /** 00613 * @brief Returns the packet length field of the received packet. 00614 * @param None. 00615 * @retval uint16_t Packet length. 00616 */ 00617 uint16_t SpiritPktStackGetReceivedPktLength(void) 00618 { 00619 uint8_t tempRegValue[2]; 00620 uint16_t tempLength; 00621 00622 /* Reads the RX_PCKT_LENx registers value */ 00623 g_xStatus = SpiritSpiReadRegisters(RX_PCKT_LEN1_BASE, 2, tempRegValue); 00624 00625 /* Rebuild and return the the length field */ 00626 tempLength = ((((uint16_t) tempRegValue[0]) << 8) + (uint16_t) tempRegValue[1]); 00627 00628 /* Computes the oversize (address + control) size */ 00629 tempLength -= 2 + (uint16_t) SpiritPktStackGetControlLength(); 00630 00631 return tempLength; 00632 00633 } 00634 00635 00636 /** 00637 * @brief If enabled RX packet is accepted only if the masked source address field matches the 00638 * masked source address field reference (SOURCE_MASK & SOURCE_FIELD_REF == SOURCE_MASK & RX_SOURCE_FIELD). 00639 * @param xNewState new state for Source address filtering enable bit. 00640 * This parameter can be S_ENABLE or S_DISABLE. 00641 * @retval None. 00642 * @note This filtering control is enabled by default but the source address mask is by default set to 0. 00643 * As a matter of fact the user has to enable the source filtering bit after the packet initialization 00644 * because the PktInit routine disables it. 00645 */ 00646 void SpiritPktStackFilterOnSourceAddress(SpiritFunctionalState xNewState) 00647 { 00648 uint8_t tempRegValue; 00649 00650 /* Check the parameters */ 00651 s_assert_param(IS_SPIRIT_FUNCTIONAL_STATE(xNewState)); 00652 00653 00654 /* Modify the register value: set or reset the source bit filtering */ 00655 g_xStatus = SpiritSpiReadRegisters(PCKT_FLT_OPTIONS_BASE, 1, &tempRegValue); 00656 00657 /* Set or reset the SOURCE ADDRESS filtering enabling bit */ 00658 if(xNewState == S_ENABLE) 00659 { 00660 tempRegValue |= PCKT_FLT_OPTIONS_SOURCE_FILTERING_MASK; 00661 } 00662 else 00663 { 00664 tempRegValue &= ~PCKT_FLT_OPTIONS_SOURCE_FILTERING_MASK; 00665 } 00666 00667 /* Writes the new value on the PCKT_FLT_OPTIONS register */ 00668 g_xStatus = SpiritSpiWriteRegisters(PCKT_FLT_OPTIONS_BASE, 1, &tempRegValue); 00669 00670 } 00671 00672 /** 00673 *@} 00674 */ 00675 00676 /** 00677 *@} 00678 */ 00679 00680 00681 /** 00682 *@} 00683 */ 00684 00685 00686 00687 /******************* (C) COPYRIGHT 2015 STMicroelectronics *****END OF FILE****/
Generated on Tue Jul 12 2022 17:40:25 by 1.7.2