Changelist

2.8.3

• 387749: Revamped Features and rail_features.h, providing runtime RAIL_SupportsSomeFeature() APIs for each of the features as some features may be restricted to certain chips within a family. Also added more consistent RAIL_SUPPORTS_ compile-time synonyms for the features while retaining the existing RAIL_FEAT_ defines for backwards compatibility. These defines can now be used in C code and not just preprocessor #if statements.
• 442248: Updated the pa_customer_curve_fits.py helper script to work with Python 3 as well as Python 2.
• 464735: Closed tiny timing window on EFR32xG13 that might corrupt PTI appended info when idling the radio.
• 464774: * Calling RAIL_ConfigSleep() with RAIL_SLEEP_CONFIG_TIMERSYNC_ENABLED on chips that use the PRORTC for synchronization (EFR32xG13 and newer) will now only configure the choose the LF clock source if the PRORTC IRQ is disabled. This allows for other code to safely configure the PRORTC like the Silicon Labs generic sleep timer.
• 466396: Added support for new BGM220 modules.
• 469015: Fixed an issue on the EFR32xG21 that could cause the RAIL_GetRadioEntropy() function to return the same first 4 bytes when called with the radio off after a reset.

2.8.2

• 456338: Fixed an issue with RAIL state transitions where an internal timer wrapping could cause incorrect transition times. This error would previously affect a maximum of one packet every 15 minutes.
• 460062: Fixed a RAIL_ScheduleRx() issue where RAIL_EVENT_RX_SCHEDULED_RX_END might not be posted when the Rx RAIL_StateTransitions_t::error transition is to RAIL_RF_STATE_IDLE and the Rx window ended during receipt of an erroneous packet.

2.8.1

• 251720: Added the new RAIL_STREAM_10_STREAM RAIL_StreamMode_t to allow you to send a 1010 stream for debugging.
• 316106: Added a new function, RAIL_StartTxStreamAlt, which allows the specific antenna to be specified for a stream transmit.
• 383197: Added new RAIL_RX_PACKET_HANDLE_OLDEST_COMPLETE packet handle to allow the user to get a reference to the oldest unreleased complete packet.
• 435689: Added a new External Thermistor interface to RAIL. This allows access the user to connect and read the impedance of an external thermistor on supported chips.
• 444205: Fixed a transmit-from-idle issue with RAIL_StartCcaCsmaTx() or RAIL_StartCcaLbtTx() which would always fail when the RAIL_StateTiming_t::idleToRx is configured below the minimum the radio is capable of achieving (typically 65-100 microseconds depending on platform).
• 450750: The RAIL_GetRadioEntropy() API will now ensure a valid radio configuration has been loaded using RAIL_ConfigChannels() since it can cause problems if the radio is used before this.
• 452628: Fixed an issue where idling the radio from an Rx antenna diversity mode would consume extra power.
• 452690: Fixed an issue where Rx antenna diversity could be left enabled after switching to a radio configuration that lacks diversity support.
• 455495: Added RAIL_IEEE802154_ConvertRssiToEd() and RAIL_IEEE802154_ConvertRssiToLqi() to assist Zigbee 802.15.4 certification testing.
• 456225: Changed the value of RAIL_FREQUENCY_OFFSET_INVALID from -1 to -32768 since -1 is a reasonable frequency offset to pass to RAIL_SetFreqOffset(). Also added convenience definitions RAIL_FREQUENCY_OFFSET_MIN and RAIL_FREQUENCY_OFFSET_MAX to specify the valid range of offset values the radio supports.

2.8.0

• 197573: Suppressed extraneous RAIL_EVENT_TX_START_CCA events that might occur during long CCA durations. Now only one such event should occur per CCA try.
• 295265: Added two new APIs, RAIL_GetSyncWords and RAIL_ConfigSyncWords(), to allow getting and setting the sync word configuration of your PHY at runtime.
• 301472: On EFR32xG12 thru EFR32xG14, added support for 802.15.4G-2012 SUN PHY dynamic frame payload whitening on reception and transmit based on the PHY header's Data Whitening flag setting. This feature is automatically enabled when RAIL_IEEE802154_ConfigGOptions()' RAIL_IEEE802154_G_OPTION_GB868 is enabled, and assumes the radio configuration specifies the appropriate whitening algorithm and settings.
• 301488: On EFR32xG12 thru EFR32xG14, added support for 802.15.4G-2012 SUN PHY dynamic frame payload 2/4-byte FCS (CRC) on reception and transmit based on the PHY header's FCS Type flag setting. This feature is automatically enabled when RAIL_IEEE802154_ConfigGOptions()' RAIL_IEEE802154_G_OPTION_GB868 is enabled. The radio configuration's (single) CRC algorithm settings are ignored, overridden by RAIL.
• 301501: On EFR32xG12 thru EFR32xG14, 802.15.4 AutoACK behavior has also been updated so transmitted immediate ACKs reflect the Whitening and 2/4-byte FCS of the received frame being acknowledged.
• 369722: Added RAIL_TX_OPTION_CCA_ONLY to just perform CCA (CSMA/LBT), stopping short of automatically transmitting when the channel is clear.
• 369727: Added support for a new RAIL_EVENT_TX_STARTED, triggered when the first preamble bit is about to go on-air. Also included the ability to retrieve the equivalent RAIL_PACKET_TIME_AT_PREAMBLE_START timestamp of that event from the event's handler via RAIL_GetTxTimePreambleStart(). Note: This new event shifted the bit positions of some events in RAIL_Events_t.
• 369727: Also changed RAIL_GetRxTimePreambleStartAlt(), RAIL_GetRxTimeSyncWordEndAlt(), and RAIL_GetRxTimeFrameEndAlt() to properly update its pPacketDetails' RAIL_PacketTimeStamp_t::timePosition to reflect the adjusted RAIL_PacketTimeStamp_t::packetTime rather than leaving it as RAIL_PACKET_TIME_DEFAULT.
• 384878: Clarified documentation of the RAIL_EVENT_RX_ACK_TIMEOUT event and RAIL_AutoAckConfig_t::ackTimeout period which extends only to packet sync word detection of an expected ACK, not packet completion of that ACK.
• 397072: Added an API, RAIL_StopInfinitePreambleTx, that can stop an infinite preamble on PHYs configured to use infinite preambles.
• 402991: Added additional information to the packet trace stream for the Z-Wave protocol to indicate what region is currently active to help with decoding.
• 406080: Added support for RFSENSE Selective (OOK) mode for supported chips, which currently includes only EFR32xG22 devices. Please refer to RAIL internal chip specific documentation for more details.
• 406871: Documented RAIL's internal 16-packet metadata FIFO which exists on EFR32 platforms supplementing the receive FIFO of packet data. Refer to Data Management and EFR32 for details. Included is support for a new RAIL_EVENT_RX_FIFO_FULL, triggered with any packet completion event in which the receive FIFO or packet metadata FIFO are full. This tells the application it must free up the oldest packets/data ASAP to reduce the chance of RAIL_EVENT_RX_FIFO_OVERFLOW (however, overflow may already have occurred). Note: This new event shifted the bit positions of some events in RAIL_Events_t.
• 411498: RAIL_StartAverageRssi() now returns RAIL_STATUS_INVALID_STATE if called when the radio is not idle, enforcing its documented behavior.
• 414114: Added a new PA mode which will attempt to automatically choose the PA which consumes the least amount of current to reliably produce the requested output power. See RAIL_EnablePaAutoMode() for details.
• 417340: Fixed an issue where RAIL_RxPacketDetails_t::isAck would incorrectly be set true for non-ACK or unexpected ACK packets received successfully (e.g. when RAIL_IEEE802154_ACCEPT_ACK_FRAMES is enabled) or aborted while waiting for the expected ACK. Note that when RAIL_RX_OPTION_IGNORE_CRC_ERRORS is in effect, an expected ACK includes one that fails CRC, and will have isAck set true.
• 418493: RAIL_ConfigRadio will now return RAIL_STATUS_INVALID_STATE if called from the inactive config in dynamic multiprotocol instead of returning success but not applying the change.
• 427934: Fixed a race condition that could cause a device to not re- enable frame detection after an Rx overflow event if the overflow was processed and cleared very quickly.
• 430026: Enforced and clarified that RAIL_Init() should not be called more than once per protocol.
• 430081: Fixed an issue where the first Clear Channel Assessment (CCA) of a CSMA/LBT transmit from radio idle state would consistently fail when the RAIL_CsmaConfig_t::ccaBackoff or RAIL_LbtConfig_t::lbtBackoff time is smaller than the RAIL_StateTiming_t::idleToRx time.
• 436163: Fixed a post-receive transition timing issue for received packets that were on the air longer than 32 milliseconds. AutoACK turnaround timing should now behave properly at low data rates.
• 437054: Fixed an issue with the pa_customer_curve_fits.py that caused values below -12 to not be considered when computing the fit. Re-generated default, Silicon Labs-provided curves to consume this fix, resulting in minor changes to the lowest-power segment in curve-fit based PA's. If using a custom power curve created using the documentation in AN1127 customers should re-run the script on the already collected output data to get slightly more accurate curves.
• 441635: Return the correct RAIL_TxPowerMode_t value of RAIL_TX_POWER_MODE_NONE from RAIL_GetTxPowerConfig if called before RAIL_ConfigTxPower.
• 446289: Fixed RAIL_IDLE_ABORT to idle the radio sooner when in RAIL_RF_STATE_RX, especially now that RAIL_RxChannelHoppingConfigEntry_t::delay can extend the time in that state.
• 447578: Fixed an issue where setting a transmit power over the maximum allowed for a given channel would result in no change in the output power instead of using the maximum allowed value.
• 450187: Fixed an issue where calling RAIL_Idle() with RAIL_IDLE_FORCE_SHUTDOWN while in receive with channel hopping enabled could corrupt some internal channel hopping state and trigger a bus fault or other radio problems.

2.7.4

• 436215: Fixed an issue on the EFR32xg13 parts that caused the 2Mbps BLE IFS time to be incorrect when receiving very short packets.
• 443144: Fixed the module specific config libraries for the xGM210xA modules: BGM210LA22JIF, BGM210LA22JNF, BGM210PA22JIA, BGM210PA22JNA, BGM210PA32JIA, BGM210PA32JNA, MGM210LA22JIF, MGM210LA22JNF, MGM210PA22JIA, MGM210PA22JNA, MGM210PA32JIA, MGM210PA32JNA. Without this change these modules would assert with RAIL_ASSERT_INVALID_MODULE_ACTION.

2.7.3

• 425464: Improved interoperability with many common devices for the 1Mbps Viterbi BLE PHY on the EFR32xG13 chips. Note that this does revert a previous change to improve interoperability from changelist_2_6_4 that attempted to improve interoperability with a few specific devices. For best interoperability we recommend using the RAIL_BLE_ConfigPhy1Mbps() standard PHY.
• 431229: Resolved an issue on EFR32xG1x devices which could cause the transmit power to be incorrect when using the low power 2.4GHz PA (RAIL_TX_POWER_MODE_2P4_LP).

2.7.2

• 336739: Added new RAIL_EVENT_RX_SCHEDULED_RX_MISSED and RAIL_EVENT_TX_SCHEDULED_TX_MISSED events to inform the user when these are missed after waking from RAIL_Sleep(). This can happen if the specified wakeup time is not long enough.
• 421410: Fixed an issue introduced in 2.7.1 with TX PTI on EFR32XG13 including an extra byte of appended information, confusing the network analyzer.

2.7.1

• 337468: Fixed an issue where calling RAIL_Sleep() if there were no RAIL events pended would not stop and synchronize the clock source as requested but would return success indicating it had. The clock source will now be properly stopped and synchronized even if there are no events pending and it will be the user's responsibility to wake up on time.
• 337468: Fixed an issue where calling RAIL_Wake() without a successful call to RAIL_Sleep() first could cause the clock source to drift even when using RAIL_SLEEP_CONFIG_TIMERSYNC_ENABLED.
• 389462: Fixed an issue with RAIL_Calibrate() in multiprotocol, which would return RAIL_STATUS_INVALID_STATE if it is called with an inactive railHandle. Now, RAIL_Calibrate() will make the given railHandle active, if not already, and perform calibration.
• 389462: Fixed an issue with RAIL_Calibrate() where after completing calibration the radio would no longer be able to receive any packets, sometimes, until it was reset.
• 396786: Added support for the following EFR32xG21-based modules: BGM210L022JIF1, BGM210L022JIF2, BGM210L022JNF1, BGM210L022JNF2, BGM210LA22JIF1, BGM210LA22JIF2, BGM210LA22JNF1, BGM210LA22JNF2, BGM210P022JIA1, BGM210P022JIA2, BGM210P022JNA2, BGM210P032JIA1, BGM210P032JIA2, BGM210P032JNA2, BGM210PA22JIA1, BGM210PA22JIA2, BGM210PA22JNA2, BGM210PA32JIA1, BGM210PA32JIA2, BGM210PA32JNA2, MGM210L022JIF1, MGM210L022JIF2, MGM210L022JNF1, MGM210L022JNF2, MGM210LA22JIF1, MGM210LA22JIF2, MGM210LA22JNF1, MGM210LA22JNF2, MGM210P022JIA1, MGM210P022JIA2, MGM210P022JNA2 MGM210P032JIA1, MGM210P032JIA2, MGM210P032JNA2 MGM210PA22JIA1, MGM210PA22JIA2, MGM210PA22JNA2 MGM210PA32JIA1, MGM210PA32JIA2, MGM210PA32JNA2
• 401826: Fixed several issues and race conditions with RAIL_ScheduleRx() window end handling and event reporting to conform to its intended design:
  • When the RX window ends with no RAIL_EVENTS_RX_COMPLETION imminent, RAIL_EVENT_RX_SCHEDULED_RX_END is posted.
  • When the RX window is implicitly ended by one of the RAIL_EVENTS_RX_COMPLETION, e.g. because it results in an RX transition to Idle or because RAIL_ScheduleRxConfig_t::rxTransitionEndSchedule is non-zero, the event(s) posted depend on that setting:
    • When zero, both events are posted simultaneously.
    • When non-zero, only the appropriate RAIL_EVENTS_RX_COMPLETION is posted, unless that event is not enabled, in which case RAIL_EVENT_RX_SCHEDULED_RX_END is substituted instead.
  • When the RX window ends while receiving a packet, it is deferred to the expected RX completion event (which includes aborting that packet when RAIL_ScheduleRxConfig_t::hardWindowEnd is non-zero). Event(s) reported at that time are the same as in the previous case.
• 406276: Restored ability for RAIL_StartCcaCsmaTx() and RAIL_StartCcaLbtTx() to perform an immediate transmit when their respective RAIL_CsmaConfig_t::csmaTries or RAIL_LbtConfig_t::lbtTries is 0. This functionality was improperly removed in 2.6.0.
• 407047: Fixed an EFR32xG21 issue where CSMA/LBT CCA durations were significantly shorter than specified.
• 408096: Fixed the 802.15.4 ACK turnaround time on the EFR32xG21 platform. Due to a calculation error this was actually 18us too short which could cause interoperability problems.
• 414257: Added RAIL_TX_POWER_LEVEL_MAX which can be used to set the max PA power level across PA's. RAIL_TX_POWER_LEVEL_INVALID was added in 2.7.0 as the value 255. Some customers were using 255 to set max power across PA's with RAIL_SetTxPower, which previously worked, but will now return an error.

2.7.0

• 379150: Added support to RAIL_Sleep() for the PLFRCO on EFR32xG13 Rev D parts.
• 357922: Changed the LQI metric for the 2.4GHz IEEE802.15.4 PHY configurations to be scaled from 0 - 255 and to include more data to make it more stable. This can impact existing applications that are using the LQI values returned in prior RAIL versions.
• 378035: Use of the unsafe enum GPIO_Port_TypeDef within RAIL aggregate types RAIL_PtiConfig_t and RAIL_AntennaConfig_t has been replaced by safe uint8_t.
• 376229: Fixed an issue with Rx antenna diversity operation that prevented CCA from working, causing CSMA failures.
• 315849: Reduced switch time overhead for dynamic multiprotocol applications. The new switch times as well as information about them are documented at Understanding the Protocol Switch Time.
• 370805: Fixed an issue with the EFR32xG21 reporting a phantom packet on PTI after reset.
• 377026: Improved documentation of RAIL_RxPacketStatus_t values and their corresponding RAIL_Events_t events.
• 400303: Corrected an issue where RAIL_EVENT_TX_CHANNEL_BUSY due to RAIL_CsmaConfig_t::csmaTimeout or RAIL_LbtConfig_t::lbtTimeout would prevent further transmits.
• 400303: Corrected an issue where an invalid RAIL_CsmaConfig_t::ccaDuration or RAIL_LbtConfig_t::lbtDuration too large for the radio configuration to handle would not fail the respective transmit; this now returns RAIL_STATUS_INVALID_PARAMETER.
• 400303: Clarified that RAIL_EVENT_TX_BLOCKED and RAIL_EVENT_TX_CHANNEL_BUSY leave the TX FIFO intact without consuming any of its packet data.
• 392350: Corrected an issue where the radio might be left in receive after a RAIL_EVENT_TX_BLOCKED or RAIL_EVENT_TX_CHANNEL_BUSY when the transmit RAIL_StateTransitions_t::error is RAIL_RF_STATE_IDLE.
• 251786: Added new 802.15.4 RAIL APIs RAIL_IEEE802154_EnableEarlyFramePending() and RAIL_IEEE802154_EnableDataFramePending() to support Thread Basil-Hayden Enhanced Frame Pending feature.
• 369736: Added new 802.15.4 RAIL APIs RAIL_IEEE802154_ConfigGOptions() and RAIL_IEEE802154_ConfigEOptions() for configuring certain 802.15.4E-2012 and G-2012 features needed by GB868. Also, RAIL may now suppress the RAIL_EVENT_IEEE802154_DATA_REQUEST_COMMAND when latency has delayed the handling of that event too late to influence the outgoing ACK for it.
• 385960: Added information to packet trace for every protocol switch in dynamic multiprotocol telling the user what protocol RAIL has changed to as well the radio event that triggered this switch. This information is visible in Network Analyzer for better debugging of DMP applications.
• 389439: The EFR32xG13 AoX RAIL library is no longer present as that functionality has been merged into the standard RAIL library for EFR32xG13.
• 360371: Fixed an issue where calling RAIL_GetTxPowerDbm prior to calling RAIL_SetTxPower would return -500 i.e. -50dBm. As a part of the fix, we now return an invalid dBm value, RAIL_TX_POWER_MIN, if RAIL_SetTxPower was not called before calling RAIL_GetTxPowerDbm or if RAIL_SetTxPower it returns an error status.
• 382575: Added a new API RAIL_UseDma(), which can be used to enhance RAIL startup speed if called before RAIL_Init().
• 376711: Added support for Z-Wave node ID based packet filtering via the RAIL_ZWAVE_OPTION_NODE_ID_FILTERING option.
• 386163: Added support for the radio sending an ACK packet automatically when in Z-Wave mode as long as node ID filtering and Auto-ACK features are enabled and a packet requesting an ACK is sent to the device.

  ---

2.6.5

• Corrected the frequencies used by Z-Wave in the China, Malaysia, and India regions to match the specification. China was using the EU frequencies, Malaysia was using 868.10 MHz, and India was not applying the required 20 kHz offset to the R1 channel.

2.6.4

• Fix an issue on the EFR32xG21 where the medium power and low power PAs might not complete ramping and end up transmitting at a lower power than desired.
• Improved interoperability of the BLE 1Mbps PHY on EFR32xG13 devices.
• Improved performance of OOK PHYs.
• Updated packet trace format to include extra information for BLE packets.

2.6.3

• Fixed an issue introduced in 2.6.2 where issuing a RAIL_Idle() with mode RAIL_IDLE_FORCE_SHUTDOWN_CLEAR_FLAGS could sometimes cause the receive FIFO to be corrupted and trigger a RAIL assert with code (RAIL_ASSERT_FAILED_ILLEGAL_RXLEN_ENTRY_STATUS).
• Various bug fixes and improvements for the EFR32xG21 parts.

2.6.2

• Updated the PA curves on the EFR32xG21 chips to slightly improve transmit power accuracy.
• Resolved an issue where RAIL_GetChannelHoppingRssi would return an RSSI value even if receive was disabled.
• Resolved an issue where RAIL_GetChannelHoppingRssi would not update the RSSI value while receiving packets.
• Resolved an issue in multiprotocol where an absolute event with a non zero slip time would always work even if scheduled in the past.

2.6.1

• Resolved an issue on the EFR32xG21 platform that could cause the chip to hang when coming out of a reset if RAIL_Idle() was called at the wrong time.
• Added RAIL_GetChannelHoppingRssi API to allow the user to read the RSSI from each channel when channel hopping is enabled.
• Fixed an issue where CRC-failed packets received with RAIL_RX_OPTION_IGNORE_CRC_ERRORS would be reported with RAIL_RX_PACKET_READY_SUCCESS instead of RAIL_RX_PACKET_READY_CRC_ERROR when the RAIL_EVENT_RX_FRAME_ERROR event isn't enabled.
• Fixed an issue on the EFR32xG21 platform that caused the chip to incorrectly compute the PA ramp time at high power levels. If this happened, the ramp time would be higher than expected and cause large delays in the RAIL_StateTiming_t::rxToTx time which is used for sending ACK packets.
• Fixed an issue on the EFR32xG21 platform that could cause erroneous Rx overflow events and failed receives when using the 125Kbps BLE coded PHY.

2.6.0

• Fixed an issue causing the receive antenna to always be reported as antenna 0 when using receive antenna diversity.
• Added alternative APIs for calculating receive timestamps, which give correct results for Long-Range BLE: RAIL_GetRxTimeFrameEndAlt, RAIL_GetRxTimePreambleStartAlt, RAIL_GetRxTimeSyncWordEndAlt.
• Fixed an issue where receive events could corrupt the transmit packet length in frame type based length mode if they came in between the start transmit call and the actual transmit.
• Fixed an Auto-ACK problem where ACKs were being sent for CRC error frames when RAIL_RX_OPTION_IGNORE_CRC_ERRORS is in effect.
• Fixed a math error that could cause the RAIL_CsmaConfig_t::ccaDuration to be shorter than requested. This would happen whenever the (ccaDuration * rx_baudrate) exceeded the size of a 32 bit integer.
• Fixed an issue in the multiprotocol RAIL library where the RAIL_GetTxPower() function could return the wrong output power if called with any RAIL handle other than the active one. We will now return the actual power that would be set if that protocol is active.
• Fixed the PA conversion code so that it better handles error conditions and will not trigger a fault when given NULL parameters.
• Added new API to retrieve the channel index of the most recent Beam packet accepted: RAIL_ZWAVE_GetBeamChannelIndex.
• Added a new RAIL_DelayUs() API for short blocking delays using the RAIL time base.
• Fixed a problem where state timings would not properly be updated when switching if both protocols used the same channel configuration structure.
• Fixed an issue on the EFR32xG14 series that prevented Rx antenna diversity from functioning properly. This was introduced in the RAIL 2.5.0 release.
• Restored pre-2.5.0 behavior with RAIL_SetRxFifoThreshold() to disable threshold events from occurring when passed an rxThreshold of the FIFO's size or larger. A 2.5.0 change allowed such rxThreshold settings to cause the event to fire when the buffer became full, though it's been mis-documented as one byte away from becoming full for quite a while – something that was never actually implemented and is now removed from the documentation.
• Fixed RAIL_StartCcaCsmaTx() and RAIL_StartCcaLbtTx() to return RAIL_STATUS_INVALID_PARAMETER when passed invalid configuration parameters in their respective RAIL_CsmaConfig_t or RAIL_LbtConfig_t, whose documentation has been updated accordingly. In earlier releases the requested operation would proceed with an invalid or incomplete hardware configuration, resulting in undefined behavior.

  ---

2.5.1

• Worked around a BLE longrange problem where Rx abort could cause deafness.

2.5.0

• Added a channel hopping feature with RAIL_ConfigRxChannelHopping and RAIL_EnableRxChannelHopping. This feature allows users to specify a list of channels to scan over during receive. This feature allows for much faster scanning with less delay (about 100us) than simply repeatedly calling RAIL_StartRx() with different channels.
• Included two default transmit power curves in the library: RAIL_TxPowerCurvesDcdc and RAIL_TxPowerCurvesVbat. When the pa-conversions plugin is used, one of these can be passed to the plugin, based on the way the power amplifier is powered.
• Added the ability to specify a Link Quality Indicator (LQI) conversion callback with RAIL_ConvertLqi such that the hardware's LQI value can be changed before application consumption of that value.
• Fixed an issue where RAIL_StopTxStream() was taking an extended amount of time to complete.
• Certain received packet details in RAIL_RxPacketDetails_t, which were formerly available only for successfully received packets, are now also available for unsuccessfully received packets.
• RAIL_DataMethod_t and related documentation have been updated to reflect that many FIFO_MODE concepts can now be used in PACKET_MODE, and the distinction between these modes has become nearly invisible for transmit. Also eliminated the previous restriction that both receive and transmit RAIL_DataMethod_t must match in the RAIL_DataConfig_t passed to RAIL_ConfigData().
• RAIL_ConfigData() no longer resets the receive FIFO when switching to RAIL_DataMethod_t::FIFO_MODE.
• Added a new RAIL_TxOptions_t option RAIL_TX_OPTION_CCA_PEAK_RSSI to allow the user to use the peak RSSI instead of the average RSSI over the CCA period during CSMA and LBT transmits. This is only supported on EFR32xG12 and newer silicon.
• Added a new RAIL_TxOptions_t option RAIL_TX_OPTION_ALT_PREAMBLE_LEN to allow the user to transmit with a runtime-specified preamble length. This alternate preamble length is set with RAIL_SetTxAltPreambleLength.
• Added Z-Wave PHY configurations and functionality to the RAIL library.
• Fixed an issue that could cause register corruption in very rare conditions due to a bus access race condition. The specific registers impacted were limited to those related to the radio and the corruption was most likely when running the coherent IEEE802.15.4 PHY on the EFR32xG12 and EFR32xG13 platforms. On other platforms and PHY configurations the issue is possible though very unlikely and never observed (id: 317234).
• Resolved a multiprotocol scheduler issue that could cause some interrupted events to not be reported to the caller. Since these events never run there are no other related events either so state machines relying on RAIL events could get stuck in invalid states (id: 341124).
• Enhanced RAIL_SetRxFifoThreshold() and RAIL_SetTxFifoThreshold() to now support a threshold value of RAIL_FIFO_THRESHOLD_DISABLED to explicitly disable a threshold previously established.
• Fixed a documentation issue where a variety of RAIL APIs were incorrectly shown as "Referenced by RAIL_CopyRxPacket()".

  ---

2.4.1

• Fixed an issue with RAIL_Sleep() that could cause the wake event to be set very far in the future. This would prevent waking at the proper time and cause problems for the application.
• Fixed an issue in the multiprotocol library where the txToRxSearch time set by RAIL_SetStateTiming() would be lost after a protocol switch if there were no timings stored in the channel configuration.
• Fixed an issue preventing radio coexistence transmit abort counter from incrementing.
• Fixed radio coexistence HAL_CONFIG support for shared priority and shared request.

2.4.0

• Added ability to set custom receive FIFO sizes via the RAIL_SetRxFifo() function. The new RAILCb_SetupRxFifo() callback may be used to override the default FIFO initialization to save RAM.
• Added alternate functions to get packet details, in a way that helps lower code size: RAIL_GetRxPacketDetailsAlt() and RAIL_GetTxPacketDetailsAlt(). These come with functions to adjust the returned time stamp to different places in the packet: RAIL_GetRxTimePreambleStart(), RAIL_GetRxTimeSyncWordEnd(), RAIL_GetRxTimeFrameEnd(), RAIL_GetTxTimePreambleStart(), RAIL_GetTxTimeSyncWordEnd(), and RAIL_GetTxTimeFrameEnd().
• Broke up the IR calibration code to save code size for Zigbee and BLE where the results are stored on chip.
• Added a new RAIL_SetRssiOffset() command to offset all RSSIs used by RAIL to match any hardware offsets on a given board.
• Added a new RAIL_StopTx() function to stop only pending or current transmits without impacting receive.
• For multiprotocol, added the ability to update a task's priority after it started with RAIL_SetTaskPriority().
• Added the ability to pre-apply a radio configuration to hardware before a TX or RX operation begins via RAIL_PrepareChannel().
• Added the ability to query RAIL for the channel configuration currently configured for use via RAIL_GetChannel().
• Fixed an issue where relative tasks with a non-zero slip time could start a few hundred microseconds earlier than they were supposed to.
• Fixed an issue that could cause antenna diversity to not function correctly.
• Fixed an issue where RAIL_Idle() with RAIL_IDLE_FORCE_SHUTDOWN could cause an erroneous RAIL_EVENT_TX_ABORTED event to fire.

2.3.1

• Fixed one case where calling RAIL_Idle() with the mode set to RAIL_IDLE_FORCE_SHUTDOWN could cause us to output partial packet trace appended information.
• Deferred multiprotocol event failures until just before the event must start when the expected runtime of a task causes it to not fit. These were previously reported immediately even though future tasks could change.

  ---

2.3.0

• Added a RAIL_CopyRxPacket() helper for use after RAIL_GetRxPacketInfo().
• Added a fast, but inconsistent, transition times mode. This can be activated by setting state timings to 0.
• Resolved a potential receive FIFO corruption that could occur when calling RAIL_HoldRxPacket() or RAIL_PeekRxPacket().
• A multi-timer API was added that allows for multiple software timers all driven off the one hardware timer. This must be explicitly enabled and will use more code than the standard APIs, but can be done through RAIL_ConfigMultiTimer(). Once in use, all timer APIs must use the multi timer versions to prevent conflicts with the hardware timer.
• Added diagnostic functions RAIL_Verify() and RAIL_ConfigVerification() to provide a means of verifying internal radio memory contents.
• Added alternative calibration APIs to RAIL_Calibrate, for potential code size savings: RAIL_CalibrateTemp, RAIL_CalibrateIr, and RAIL_ApplyIrCalibration.
• Fixed an issue where requesting a small fixed CSMA backoff could result in a very large value from being selected instead.
• Made PHY configuration improvements for BLE and Zigbee on the efr32xg14 platform.

  ---

2.2.0

• In FIFO mode on the EFR32 the FIFO could only be read after 8 bytes were received. This restriction has now been lifted though the user must be careful and understand that in certain cases they could be reading appended information and not packet bytes.
• On the EFR32XG14 some BLE packets showed up with invalid timestamps. These are now filtered and reported as aborted to the user so that the stack does not time sync to an invalid timestamp and lose the connection.
• Fixed an issue where state transition times would not be recomputed when changing the PA ramp time on the fly.
• Fixed a regression in 2.1.1 that caused Frame Type based length configurations to lock up the receiver. There was an issue where bits in the byte that were not supposed to be a part of the frame type were being included some times and could cause problems in the receive processing logic.
• Prevented RAIL_StartRx() from resetting the receive FIFO. This was a legacy feature that was not documented and, though it generally worked, would cause problems to users processing deferred receive events or users that called RAIL_StartRx() in an interrupt disabled context. If this behavior was required it can be replicated by idling the radio and then calling RAIL_ResetFifo() with rxFifo set to true before any calls to RAIL_StartRx().
• Fixed an issue in the RAIL_IEEE802154_SetAddresses() function that caused it to never set any long address except for the first one and to set that one to the value given in the final long address entry.
• Updated the documentation for the IEEE 802.15.4 and BLE protocol functions to show properly usage with the new RAIL 2.0 API.
• Dynamic Multiprotocol fixes:
  • Added support for each protocol having auto ACK enabled by allocating space for independent ACK buffers.
  • Ensured that the sync word is properly output in BLE Long Range no matter when the packet data is loaded into the transmit FIFO.
  • Prevented the sync word in packet trace feature from being turned on in Zigbee when it's enabled by BLE.

    ---

2.1.2

• Removed unimplemented functions RAIL_GetActiveChannelConfig() and RAIL_GetActiveChannelConfigEntry().

2.1.1

• RAIL_PauseTxAutoAck() was internally pausing the Rx AutoAck logic. This has now been corrected.
• EFR32XG12 and EFR32XG13 devices were detecting a high number of false 15.4 sync words. Even though these packets were eventually filtered they would show up on PTI. In 2.1.1 there should be significantly fewer of these packets as some of this was caused by a bug in a configuration algorithm.
• Channel power limits for BLE PHYs were not always being respected. This could have caused us to use a power which might result in certification issues.
• The RAIL_StateBuffer_t type was incorrectly sized resulting in a waste of RAM for RAIL applications. This has now been trimmed down to the actual size required.

2.1.0

• Packet receive APIs were totally revamped to allow faster and out-of-order deferred processing of received packets and their data outside of interrupt/callback context. Gone are RAIL_GetRxPacketHandle(), RAIL_ReadRxFifoAppendedInfo(), and the memory management RAILCb_ callbacks, replaced with RAIL_GetRxPacketInfo() that provides pointers directly to the received data held in RAIL's internal receive FIFO buffer allowing for zero-copy operation. See other RAIL 2.x porting documentation and new routines RAIL_GetRxPacketInfo(), RAIL_GetRxPacketDetails(), RAIL_HoldRxPacket(), and RAIL_ReleaseRxPacket(), along with updated RAIL_PeekRxPacket() and RAIL_ReadRxFifo() behavior.
• On the transmit side, zero-copy is also now supported by allowing applications to specify their own buffers for the transmit FIFO, eliminating RAIL's former internal fixed-size 512-byte one. See new RAIL_SetTxFifo().
• The former RAIL_LoadTxData() has been merged into an updated RAIL_WriteTxFifo() API.
• The RAIL_Event_t type was renamed RAIL_Events_t now that multiple events can be presented to the application simultaneously in RAIL's generic events callback, rather than relying on the internal arbitrary order that RAIL imposed previously, which may not match the application's or protocol's expectations.
• Event/callback configuration is now managed entirely by RAIL_ConfigEvents(), eliminating the old RAIL_ConfigTx() and RAIL_SetCallbackConfig() APIs.
• Channel numbers were increased in range from 8 bits to 16 bits, and channel configurations made much more flexible allowing for multi-band radio configurations and an easy way to specify TX power limits on certain channels that otherwise share a common configuration. See new APIs RAIL_GetActiveChannelConfig() and RAIL_GetActiveChannelConfigEntry() along with changes to RAIL_ConfigChannels().
• Power levels were given a formal RAIL_TxPowerLevel_t type, and RAIL_SetTxPower() now returns a RAIL_Status_t not the power level actually achieved – must now use RAIL_GetTxPower() to get that.
• PA power curves and the conversion between RAIL power level and dBm have been fully abstracted to live outside of RAIL, allowing customers complete flexibility to characterize their designs and PA selection. See new APIs RAIL_ConfigTxPower(), RAIL_ConvertDbmToRaw(), RAIL_ConvertRawToDbm(), RAIL_GetTxPowerConfig(), RAIL_GetTxPowerDbm(), RAIL_SetTxPowerDbm(), and RAIL_EnablePaCal().
• Protocols using Frame Types to determine packet length are better integrated into the Studio radio configurator and channel configuration. Gone are APIs like RAIL_ConfigFrameTypeLength() and RAIL_EnableAddressFilterByFrameType() whose functionality is now subsumed within channel configurations.
• APIs to support RAIL timebase synchronization across sleep/wake were added: RAIL_ConfigSleep(), RAIL_Sleep(), and RAIL_Wake().
• State transitions for success and error are now encapsulated in a new RAIL_StateTransitions_t structure. This affected the RAIL_SetRxTransitions() and RAIL_SetTxTransitions() routines.
• The former RAIL_EVENT_TX_BUFFER_UNDERFLOW has been broken out into non-ACK (RAIL_EVENT_TX_UNDERFLOW) and ACK (RAIL_EVENT_TXACK_UNDERFLOW) flavors like the other transmit completion events.
• Diagnostic toning APIs were merged into the streaming APIs as the RAIL_StreamMode_t::RAIL_STREAM_CARRIER_WAVE.
• RAIL_ConfigCal() was revamped to use RAIL_CalMask_t.
• RAIL_Calibrate()'s bool calSave argument was removed, being redundant with a NULL vs. non-NULL calValues argument.
• Support for Packet Traffic Arbitration (PTA) or Coexistence was added in the form of an API to prevent transmits from going on the air: RAIL_EnableTxHoldOff(), along with RAIL_IsTxHoldOffEnabled() to check the current state.
• The former RAIL_AutoAckDisable() was merged into RAIL_ConfigAutoAck() by means of its RAIL_AutoAckConfig_t::enable parameter field.
• The former RAIL_EnableRxFifoThreshold() was replaced by using RAIL_ConfigEvents() to enable/disable the RAIL_EVENT_RX_FIFO_ALMOST_FULL event.
• The former blocking RAIL_PollAverageRssi() was eliminated; use the non-blocking RAIL_StartAverageRssi() instead.
• Several APIs were renamed for consistency and updated accordingly:
  • former RAIL_GetTxPacketInfo() is now RAIL_GetTxPacketDetails();
  • former RAIL_UseTxBufferForAutoAck() is now RAIL_UseTxFifoForAutoAck();
  • former RAIL_LoadAutoAckBuffer() is now RAIL_WriteAutoAckFifo().
• More API functions were updated to take a RAIL_Handle_t argument: RAIL_SetFreqOffset(), RAIL_GetRxFreqOffset(), and the RAIL_IEEE802154_ protocol APIs.
• RAIL_IEEE802154_GetAddress() was updated to return RAIL_Status_t rather than RAIL_IEEE802154_Address_t which is now passed as an output argument.
• RAIL_EnableDirectMode() and RAIL_SetTune() now return RAIL_Status_t rather than void.
• A multiprotocol scheduler API was added to get its status: RAIL_GetSchedulerStatus().
• The RAILCb_AssertFailed() callback returns with a RAIL_Handle_t parameter that might be NULL since assert conditions might occur during initialization prior to handle assignment or during multiprotocol switching.
• Many APIs with pointer arguments were clarified to use const pointers where the API doesn't modify the data pointed to.

  ---

2.0.0

• All API names were updated to follow a strictly VerbNoun convention.
• RAIL_SetAbortScheduledTxDuringRx() is no longer a separate API, rather it was added to RAIL_ScheduleTxConfig_t. Set the desired TX during RX behavior when that struct is passed to RAIL_StartScheduledTx().
• Add support for building single-prototocol, multi-protocol, and core RAIL libraries.
• Changed RAIL_RadioState_t to a bitmask. Supported RAIL_RadioState_t bits are: RAIL_RF_STATE_ACTIVE, RAIL_RF_STATE_RX, and RAIL_RF_STATE_TX; combinations of these bits yield the additional states RAIL_RF_STATE_INACTIVE, RAIL_RF_STATE_IDLE, RAIL_RF_STATE_RX_ACTIVE, and RAIL_RF_STATE_TX_ACTIVE.
• Added RAIL_RX_OPTION_TRACK_ABORTED_FRAMES to configure seeing full packets via Packet Trace, even after they have been aborted.
• Added RAIL 15.4 PTI Rx error code UNDESIRED_ACK to indicate an ACK filtered because it did not have the desired sequence number matching that in the recently-transmitted ACK-requesting frame.
• Updated return type from uint8_t to RAIL_Status_t for many functions.
• Removed deprecated bit error-rate APIs RAIL_BerConfigSet(), RAIL_BerRxStart(), RAIL_BerRxStop(), RAIL_BerStatusGet(), along with deprecated types RAIL_BerConfig_t and RAIL_BerStatus_t.
• TX related events are now broken out to specify whether the event is relevant to an ACK packet or user-initiated TX. Specifically those are RAIL_EVENT_TX_ABORTED and RAIL_EVENT_TXACK_ABORTED, RAIL_EVENT_TX_BLOCKED and RAIL_EVENT_TXACK_BLOCKED, and RAIL_EVENT_TX_PACKET_SENT and RAIL_EVENT_TXACK_PACKET_SENT. One of each type (i.e. one ACK, one non-ACK) can occur before being handled.
• RAIL_StartTx() no longer takes a pre-TX operation function pointer to do scheduled or CCA transmits. Instead, there are now separate API's for each type of transmit: RAIL_StartTx(), RAIL_StartScheduledTx(), RAIL_StartCcaLbtTx(), RAIL_StartCcaCsmaTx().
• RAIL_TxOptions_t has been converted to a 32-bit bitmask, so that RX and TX options are both represented as bitmasks. A single TX option mask is passed into each TX call.
• RAIL_ConfigEvents() now also takes two bitmasks, one to indicate which events should be affected, and the second indicating which of those events should be enabled.
• Similarly, RAIL_ConfigRxOptions() takes two bitmasks, one to indicate which options to update, and the second indicating the desired value of those options, which affect all future receives.
• Options for removing RX appended info and ignoring CRC are now controlled exclusively by RAIL_ConfigRxOptions().

  ---

1.6.1

• Added new BLE radio configurations for EFR32xG13 parts to fix a transmit overshoot issue on the coded PHY configurations for BLE Long Range.
• Fixed DCDC voltage droop during RAIL_RfInit()
• Added an API (RAIL_EnablePaCal()) that enables loading of chip to chip PA calibration data.

1.6.0

• Fixed an issue where RAIL_RfStateGet() would mistakenly return RAIL_RF_STATE_IDLE instead of RAIL_RF_STATE_TX when a Transmit operation's LBT is active.
• Added an API (RAIL_SetAbortScheduledTxDuringRx) that sets the behavior when a scheduled TX fires during an RX or ACK. If the API is passed false, TX's will be delayed until the RX (or ACK to the RX) is complete. That behavior is the default and what always happened previously. Passing the function true however will abort scheduled TX's that fire during the RX (or ACK to the RX) and fire the RAILCb_TxRadioStatus callback.
• Added new RAILCb_AssertFailed callback to give the flexible handling of asserts within RAIL. This includes defines of assert codes and error reasons in rail_assert_error_codes.h. The default implementation hangs in an infinite loop.
• Added RAIL_ENUM define to override enum size ambuiguity in the ARM EABI by making them actually a uint8_t. For documentation purposes they are still shown as enums.
• Added new TX options: removeCrc, to override whether CRC is sent; and syncWordId, to choose which SYNC word to transmit when multiple SYNC words are configured.
• Added new RX option: RAIL_RX_OPTION_ENABLE_DUALSYNC, which allows multiple SYNC words to be searched for on PHYs that support it.
• Added RAIL_PeekRxPacket to allow reading part of a packet before it has been fully received.
• Changed BER Test functionality in RAILTest such that if a RX overflow is detected (due to the incoming datarate being too high), the test now aborts and displays an appropriate status message.
• Fixed an issue where the code could hang in a RX overflow state when receiving incoming data streams.
• RAIL_TxToneStart() and RAIL_TxStreamStart() now idle the radio before transmitting.
• Fixed an issue where calling RAIL_TimerSet() while in the middle of a stream or tone transmission could lock up the radio.
• Added new frequency offset related functions, RAIL_GetRxFreqOffset and RAIL_SetFreqOffset, and the associated RAIL_FrequencyOffset_t type definition.

  ---

1.5.2

• Fixed an issue in 1.5.1 that would cause scheduled receive, scheduled transmit, and RAIL timer operations to fail on EFR32xG12 with a relative delay of 0.
• Fixed an issue in 1.5.1 that would cause scheduled receive and scheduled transmit to fail if called with an absolute time from [0, rxWarmTime) or [0, txWarmTime) respectively.
• Fixed an issue where a failed scheduled transmit operation would prevent any transmit from succeeding until RAIL_RfIdle() or RAIL_RfIdleExt() were called.
• Fixed an issue in 1.5.1 where calling idle while looking for an ACK could cause the radio to get stuck in the receive state.

1.5.1

• Added official support for the EFR32xG12 parts through a new librail_efr32xg12.a version of the library.
• Added RAIL_SetRxOptions API for configuration of receive options, such as RAIL_RX_OPTION_STORE_CRC.
• Increase transmit and receive fifo sizes to 512 bytes for all EFR32xG1 parts. This impacts both packet and fifo modes.
• Added RAIL_RxDataSource_t::RX_DEMOD_DATA in order to receive demodulated data via FIFO method.
• Shortened the duration that the transmit buffer lock in RAIL_TxDataLoad() is held, as it was overprotective. RAIL will still report an error if the application attempts to manipulate the transmit buffer while actively transmitting data.
• Improved state transition timings for enhanced precision and accuracy. To improve precision we have switched to a more stable receive complete event since our previous trigger could jitter for certain radio configurations. To improve accuracy we measured and removed PHY specific overhead for BLE applications. Note that this measurement was BLE specific and does not completely correct accuracy on any arbitrary PHY configuration. For custom PHY configurations you will still have to manually calibrate out any offsets by measurement and any previous measurements are likely different now.
• Moved BER test implementation out of the RAIL library and into RAILTest. Deprecated the existing BER test functions in the RAIL API. With BER test code now existing in RAILTest, you must use version 2.2.1 or later of the radio configurator.
• Disabled receive buffer overflow and transmit buffer underflow as BUFC_IRQHandler() events. These events now only occur in FRC_IRQHandler().
• Sped up RAIL transmit and receive buffer read/write operations.
• Fixed a race condition that could cause the receive packet callback to be delayed until the next receive packet event.

1.5.0

• Added other methods of Data Management. The application can configure RAIL to provide/retrieve data via FIFO method.
• The new FIFO method of data management brings with it two new callbacks: RAILCb_TxFifoAlmostEmpty(), and RAILCb_RxFifoAlmostFull(). Note that you must implement these new callbacks or stub them out if you do not intend to use them.

  ---

1.4.2

• Fixed a bug in how we handled IEEE 802.15.4 data request packets. Specifically, we were not issuing the RAILCb_IEEE802154_DataRequestCommand() callback for data request packets that were sent with MAC security enabled.
• Fixed a bug where calling RAIL_TxDataLoad() at an inopportune time could cause that and all subsequent such calls to fail.

1.4.1

• Implemented LQI measurement. The field in RAIL_AppendedInfo_t is now populated on every packet receive.
• Allow transmit while receive is active, if the channel is the same. After transmitting, the radio will follow the configured state transitions as before.
• Allow shorter ccaBackoff times if receive is active during the CSMA or LBT process.
• Allow calling RAIL_RxConfig while receiving.
• Added new receive event: RAIL_RX_CONFIG_PACKET_ABORTED
• Added new RAIL_TxConfig API, along with more transmit events: RAIL_TX_CONFIG_CHANNEL_CLEAR, RAIL_TX_CONFIG_CCA_RETRY, RAIL_TX_CONFIG_START_CCA
• Fixed a filtering bug in the IEEE 802.15.4 code. We were incorrectly filtering packets with a 0xFFFF source PANID while the coordinator which caused problems in the joining process. The new logic will only use the source PANID for filtering if we are the coordinator, there is no destination address, and the frame type is MAC command or Data.
• Migrated to Gecko SDK 5.0, including the new em_core APIs for interrupt enabling and disabling. This adds required dependencies on the CORE_EnterCritical() and CORE_ExitCritical() functions.
• Added new RSSI functions for hardware and software averaging: RAIL_StartAverageRSSI(), RAIL_GetAverageRSSI(), RAIL_AverageRSSIReady(), RAIL_PollAverageRSSI().
• Added new RSSI callback: RAILCb_RssiAverageDone().
• Added the ability to switch between multiple BLE phys, including 2Mbps phys, on chips that support the new phys.

1.4.0

• Added support for the EFR32MG12P part family with larger RAM and Flash size variants along with some new chip features.
• Renamed anything that was just efr32 in the previous releases to efr32xg1 to differentiate it from the new efr32xg12 family of parts.
• Add support for the new BLE 2MBit PHY to the BLE acceleration and configuration APIs on EFR32xG12 chips.
• Better optimize IR Calibration run times for all EFR32xG1 parts. You must use version 0.69 or later of the radio configurator.

  ---

1.3.2

• Added RAIL_SetPtiProtocol() and RAIL_PtiProtocol_t. This function allows the application to configure RAIL's packet trace interface to output protocol specific data.
• Fix BER functions to operate at 1Mbps data rates.
• RAIL_RfIdle() does not clear the transmit buffer anymore. RAIL_TxDataLoad() resets the transmit buffer with every packet set. This fixes the case where RAIL_RfIdle() is called after RAIL_TxDataLoad().
• Fixed bug when using fixed packet lengths configured via the Radio Configurator. RAIL_TxStart() will not overwrite the configured fixed length to the amount of data loaded by RAIL_TxDataLoad().
• Fixed bug in RADIO_PA_Init() where ramp times greater than 11.2 ms would be truncated to a very short ramp.

1.3.1

• Added IEEE 802.15.4 hardware acceleration. The new APIs can be found in protocol/ieee802154/rail_ieee802154.h. Documentation for these APIs can be found in IEEE 802.15.4. This includes a new callback: RAILCb_IEEE802154_DataRequestCommand().
• Added Auto Ack hardware acceleration. Documentation for these APIs can be found in Auto-ACK.
• Added RAIL_TxStartWithOptions(). This new API takes a pointer to RAIL_TxOptions_t that contains options to modify the upcoming transmit.
• Increased minimum state transition time to 100 us.
• Added RAIL_STATUS_INVALID_CALL
• Added RAIL_AppendedInfo_t::isAck

1.3.0

• Added BLE hardware acceleration. The new APIs can be found in protocol/ble/rail_ble.h. Documentation for these APIs can be found in BLE.
• Added RAIL_ScheduleRx() and RAIL_ScheduleRxConfig_t. This allows the application to schedule a RX window using the RAIL timebase.
• Added RAIL_TIME_DISABLED enum to RAIL_TimeMode_t.
• Added an extended idle function which gives you more control of how the radio is idled. See RAIL_RfIdleExt() and RAIL_RfIdleMode_t for more details.
• Added RAIL_RX_CONFIG_TIMEOUT and RAIL_RX_CONFIG_SCHEDULED_RX_END
• Added RAIL_TX_CONFIG_TX_ABORTED and RAIL_TX_CONFIG_TX_BLOCKED
• Added an extended radio status callback that supports up to 32 different status reasons (RAILCb_RxRadioStatusExt()). You may implement this instead of RAILCb_RxRadioStatus() or continue using the old version if you do not need access to more than the first 8 status values.

  ---

1.2.7

• Added FEM control signals
• Added RAIL_SetPaCTune in order to tune the PA capacitor value for TX and RX.
• Fix typo in RAIL_StreamMode_t : PSUEDO_RANDOM_STREAM to PSEUDO_RANDOM_STREAM

1.2.6

• Added ability to reset demod.

1.2.5

• Fixed register settings for BER testing.
• Fixed packet buffer for contents larger than 170 bytes.

1.2.4

• Presented worst case RfSense wake period

1.2.3

• Optimized address filtering code for operation at higher data rates.
• Clarified data rate limitations of address filtering.

1.2.2

• Added RAIL_SetTime() in order to allow the user to change the RAIL timebase with microsecond granularity.
• Removed sprurious calls to RAIL_RxRadioStatus() with the RAIL_RX_CONFIG_BUFFER_OVERFLOW argument, which were happening when receive was aborted due to events such as address filtering failures.
• Fixed incorrect PA output power calculations.

1.2.1

• Allow RAIL_RxStart() and RAIL_TxStart() to not error if the radio is heading to idle after a call to RAIL_RfIdle(). Application code does not have to wait until the radio is completely idle before calling a receive or transmit operation as long as the radio is heading to idle.

1.2.0

• Fixed IR calibration such that calibration values are more accurate for radio configurations with datarates below 10Kbps.
• Fixed IR calibration such that the default calibration value is applied when a better calibration value is unable to be calculated.
• Added RAIL_CalInit() for calibration initialization.
• Added BER test API and structures for diagnostic use - RAIL_BerConfigSet(), RAIL_BerRxStart(), RAIL_BerRxStop(), RAIL_BerStatusGet(), RAIL_BerConfig_t, RAIL_BerStatus_t.
• Enabled DC Calibration during initialization.

  ---

1.1.1

• Fixed CCA timing to prevent invalid CCA failures when starting out of IDLE state.
• Fixed RX state transitions to TX when ignoring CRC errors. Will properly take the success route when a CRC error occurs while ignoring CRC errors.
• Fixed TX error state transition after CCA failure.

1.1.0

• RAIL_RX_CONFIG_INVALID_CRC changed to RAIL_RX_CONFIG_FRAME_ERROR
  • This now accurately represents the callback flag.
  • A frame error is either an invalid crc, a frame coding error, or a variable length error. On detection of a frame error, the radio will proceed to the defined error state.
• RAIL_SetRxTransitions() and RAIL_SetTxTransitions() APIs added
  • Add ability to configure radio to automatically to transition to a given radio state on completion of a receive or transmit event.
• RAIL_SetStateTiming() API added
  • State transition times can be configured. The given timestamps will not perfectly match on-air times, due to the RX and TX chain delays, which are dependent on the radio configuration.
• RAIL_AddressFilterByFrameType() added
  • If address filtering and frame type length decoding are both enabled, this gives the ability to enable or disable address filtering per frame type

1.0.0

• Return quarter dBm resolution from RAIL_RxGetRSSI(). This changes the return value to an int16_t from an int8_t.
• Added calibration APIs (Calibration)
  • The RAIL library will notify the application via callback, RAILCb_CalNeeded(), whenever it detects a calibration is needed.
  • An API is provided allowing the application to choose when to calibrate the radio, to pass in a known calibration value, or force a calibration to occur.
• RAIL_TxPowerSet() returns the power level that can be set which might not match the requested power level.

  ---

Beta 1 - November 16, 2015

• Exposed EFR32 RF Energy Sensing capability via a RAIL API.
  • This functionality allows the radio to be woken from sleep by a large amount of energy over the air.
• Added new RAIL Timer APIs (System Timing)
  • This provides access to a hardware timer running at the RAIL timebase. You can use this to implement simple protocol timing that may be needed by your low level radio code.
  • This change also adds a new RAILCb_TimerExpired() that must be implemented by your application.
• Added APIs to access the bit rate and symbol rate for the current PHY (RAIL_BitRateGet(), RAIL_SymbolRateGet()).
• Cleaned up RAIL type names so that they all begin with the RAIL_ prefix. This will require updates to existing application code.
• Initial integration with Simplicity Studio's application builder tools

Alpha 2 - September 14, 2015

• Filtering of receive packets based on defined address fields and compare values. See Address Filtering for more details.
• Added different Pre-Transmit options for the Tx function.
  • Scheduling of packet transmission at an absolute time or after a defined delay.
  • Packet transmission conditional on Clear Channel Assessment (CSMA, LBT).
• The ability to read RSSI manually with RAIL_RxGetRSSI().
• Support for building RAIL applications using both GCC and IAR toolchains.

Alpha 1

• Initial release with support for transmit receive and basic radio configuration.