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.
Fixed an issue causing the receive antenna to always be reported as antenna 0 when using receive antenna diversity.
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 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.
Worked around a BLE longrange problem where Rx abort could cause deafness.
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.
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().
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 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).
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.
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 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.
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.
Removed unimplemented functions RAIL_GetActiveChannelConfig() and RAIL_GetActiveChannelConfigEntry().
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.
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 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().
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.
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.
All API names were updated to follow a strictly VerbNoun convention.
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().
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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 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.
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
Added ability to reset demod.
Fixed register settings for BER testing.
Fixed packet buffer for contents larger than 170 bytes.
Presented worst case RfSense wake period
Optimized address filtering code for operation at higher data rates.
Clarified data rate limitations of address filtering.
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.
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.
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.
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.
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.