├── LICENSE.md
├── README.md
├── keywords.txt
├── library.properties
└── src
├── S2LP.cpp
├── S2LP.h
├── S2LP_Commands.cpp
├── S2LP_Commands.h
├── S2LP_Config.h
├── S2LP_Csma.cpp
├── S2LP_Csma.h
├── S2LP_Fifo.cpp
├── S2LP_Fifo.h
├── S2LP_General.cpp
├── S2LP_General.h
├── S2LP_Gpio.cpp
├── S2LP_Gpio.h
├── S2LP_PacketHandler.cpp
├── S2LP_PacketHandler.h
├── S2LP_PktBasic.cpp
├── S2LP_PktBasic.h
├── S2LP_PktStack.cpp
├── S2LP_PktStack.h
├── S2LP_PktWMbus.cpp
├── S2LP_PktWMbus.h
├── S2LP_Qi.cpp
├── S2LP_Qi.h
├── S2LP_Radio.cpp
├── S2LP_Radio.h
├── S2LP_Regs.h
├── S2LP_Timer.cpp
├── S2LP_Timer.h
├── S2LP_Timer_ex.cpp
├── S2LP_Timer_ex.h
├── S2LP_Types.cpp
└── S2LP_Types.h
/LICENSE.md:
--------------------------------------------------------------------------------
1 | COPYRIGHT(c) 2017 STMicroelectronics
2 |
3 | Redistribution and use in source and binary forms, with or without modification,
4 | are permitted provided that the following conditions are met:
5 | 1. Redistributions of source code must retain the above copyright notice,
6 | this list of conditions and the following disclaimer.
7 | 2. Redistributions in binary form must reproduce the above copyright notice,
8 | this list of conditions and the following disclaimer in the documentation
9 | and/or other materials provided with the distribution.
10 | 3. Neither the name of STMicroelectronics nor the names of its contributors
11 | may be used to endorse or promote products derived from this software
12 | without specific prior written permission.
13 |
14 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
15 | AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 | IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
17 | DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
18 | FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 | DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
20 | SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
21 | CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
22 | OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # S2-LP
2 | Arduino library to support the S2-LP sub-1GHz transceiver
3 |
4 | ## API
5 |
6 | This sensor uses SPI to communicate.
7 |
8 | For SPI it is then required to create a SPI interface before accessing to the sensors:
9 |
10 | dev_spi = new SPIClass(SPI_MOSI, SPI_MISO, SPI_SCK);
11 | dev_spi->begin();
12 |
13 | An instance can be created and enabled with SPI bus following the procedure below:
14 |
15 | myS2LP = new S2LP(devSPI, A1, D7, A5, 868000000, 50000000, paInfo, S2LP_GPIO_3, 0x44, 0xEE, 0xFF);
16 | myS2LP->begin();
17 |
18 | In order to be notified when a new packet is received we must register a callback function
19 |
20 | myS2LP->attachS2LPReceive(callback_func);
21 |
22 | In order to send a packet to another node with address 0x44 you can use the folowing API:
23 |
24 | myS2LP->send(send_buf, (strlen((char *)send_buf) + 1), 0x44, true);
25 |
26 | In order to read a packet after having received a notification you can use the procedure below:
27 |
28 | uint8_t data_size = myS2LP->getRecvPayloadLen();
29 | myS2LP->read(read_buf, data_size);
30 |
31 | ## Documentation
32 |
33 | You can find the source files at
34 | https://github.com/stm32duino/S2-LP
35 |
36 | The S2-LP sub-1GHz transceiver datasheet is available at
37 | https://www.st.com/content/st_com/en/products/wireless-transceivers-mcus-and-modules/sub-1ghz-rf/s2-lp.html
38 |
--------------------------------------------------------------------------------
/keywords.txt:
--------------------------------------------------------------------------------
1 | #######################################
2 | # Syntax Coloring Map For S2-LP
3 | #######################################
4 |
5 | #######################################
6 | # Datatypes (KEYWORD1)
7 | #######################################
8 |
9 | S2LP KEYWORD1
10 |
11 | #######################################
12 | # Methods and Functions (KEYWORD2)
13 | #######################################
14 |
15 | begin KEYWORD2
16 | end KEYWORD2
17 | attachS2LPReceive KEYWORD2
18 | send KEYWORD2
19 | getRecvPayloadLen KEYWORD2
20 | read KEYWORD2
21 | setRadioChannel KEYWORD2
22 | getRadioChannel KEYWORD2
23 | setRadioChannelSpace KEYWORD2
24 | getRadioChannelSpace KEYWORD2
25 |
26 | #######################################
27 | # Constants (LITERAL1)
28 | #######################################
29 |
30 | FIFO_SIZE LITERAL1
31 |
--------------------------------------------------------------------------------
/library.properties:
--------------------------------------------------------------------------------
1 | name=STM32duino S2-LP
2 | version=1.1.4
3 | author=SRA
4 | maintainer=stm32duino
5 | sentence=This library includes drivers for ST S2-LP sub-1GHz transceiver.
6 | paragraph=This library is built for STM32 microcontrollers and comes with an example of implementation of the S2-LP driver.
7 | category=Communication
8 | url=https://github.com/stm32duino/S2-LP
9 | architectures=stm32, sam
10 |
--------------------------------------------------------------------------------
/src/S2LP.h:
--------------------------------------------------------------------------------
1 | /**
2 | ******************************************************************************
3 | * @file S2LP.h
4 | * @author SRA
5 | * @version V1.0.0
6 | * @date March 2020
7 | * @brief Abstract Class of a S2-LP sub-1GHz transceiver
8 | ******************************************************************************
9 | * @attention
10 | *
11 | * © COPYRIGHT(c) 2020 STMicroelectronics
12 | *
13 | * Redistribution and use in source and binary forms, with or without modification,
14 | * are permitted provided that the following conditions are met:
15 | * 1. Redistributions of source code must retain the above copyright notice,
16 | * this list of conditions and the following disclaimer.
17 | * 2. Redistributions in binary form must reproduce the above copyright notice,
18 | * this list of conditions and the following disclaimer in the documentation
19 | * and/or other materials provided with the distribution.
20 | * 3. Neither the name of STMicroelectronics nor the names of its contributors
21 | * may be used to endorse or promote products derived from this software
22 | * without specific prior written permission.
23 | *
24 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
25 | * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
27 | * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
28 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
30 | * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
31 | * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
32 | * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
33 | * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
34 | *
35 | ******************************************************************************
36 | */
37 |
38 |
39 | /* Prevent recursive inclusion -----------------------------------------------*/
40 |
41 | #ifndef __S2LP_H__
42 | #define __S2LP_H__
43 |
44 | /* Includes ------------------------------------------------------------------*/
45 |
46 | #include "SPI.h"
47 | #include "S2LP_Commands.h"
48 | #include "S2LP_Config.h"
49 | #include "S2LP_Csma.h"
50 | #include "S2LP_Fifo.h"
51 | #include "S2LP_General.h"
52 | #include "S2LP_Gpio.h"
53 | #include "S2LP_PacketHandler.h"
54 | #include "S2LP_PktBasic.h"
55 | #include "S2LP_PktStack.h"
56 | #include "S2LP_PktWMbus.h"
57 | #include "S2LP_Qi.h"
58 | #include "S2LP_Radio.h"
59 | #include "S2LP_Regs.h"
60 | #include "S2LP_Timer.h"
61 | #include "S2LP_Timer_ex.h"
62 | #include "S2LP_Types.h"
63 | #include
64 |
65 | /* Defines -------------------------------------------------------------------*/
66 | #define FIFO_SIZE 128
67 |
68 | /* Typedefs ------------------------------------------------------------------*/
69 | template
70 | struct Callback;
71 |
72 | template
73 | struct Callback {
74 | template
75 | static Ret callback(Args... args) {
76 | return func(args...);
77 | }
78 | static std::function func;
79 | };
80 |
81 | template
82 | std::function Callback::func;
83 |
84 | typedef void (*S2LPEventHandler)(void);
85 |
86 | typedef struct PAInfo_s {
87 | RangeExtType paRfRangeExtender;
88 | SGpioInit paSignalCSD_S2LP;
89 | SGpioInit paSignalCPS_S2LP;
90 | SGpioInit paSignalCTX_S2LP;
91 | int paSignalCSD_MCU;
92 | int paSignalCPS_MCU;
93 | int paSignalCTX_MCU;
94 | uint8_t paLevelValue;
95 | } PAInfo_t;
96 |
97 | /* Class Declaration ---------------------------------------------------------*/
98 |
99 | /**
100 | * Abstract class of a S2-LP sub-1GHz transceiver
101 | */
102 | class S2LP
103 | {
104 | public:
105 | S2LP(SPIClass *spi, int csn, int sdn, int irqn, uint32_t frequency=868000000, uint32_t xtalFrequency=50000000, PAInfo_t paInfo={.paRfRangeExtender=RANGE_EXT_NONE, .paSignalCSD_S2LP={S2LP_GPIO_0, S2LP_GPIO_MODE_DIGITAL_OUTPUT_LP, S2LP_GPIO_DIG_OUT_TX_RX_MODE}, .paSignalCPS_S2LP={S2LP_GPIO_1, S2LP_GPIO_MODE_DIGITAL_OUTPUT_LP, S2LP_GPIO_DIG_OUT_RX_STATE}, .paSignalCTX_S2LP={S2LP_GPIO_2, S2LP_GPIO_MODE_DIGITAL_OUTPUT_LP, S2LP_GPIO_DIG_OUT_TX_STATE}, .paSignalCSD_MCU=A0, .paSignalCPS_MCU=A2, .paSignalCTX_MCU=A3, .paLevelValue=0x25}, S2LPGpioPin irq_gpio=S2LP_GPIO_3, uint8_t my_addr=0x44, uint8_t multicast_addr=0xEE, uint8_t broadcast_addr=0xFF);
106 | void begin(void);
107 | void end(void);
108 | void attachS2LPReceive(S2LPEventHandler func);
109 | uint8_t send(uint8_t *payload, uint8_t payload_len, uint8_t dest_addr, bool use_csma_ca = true);
110 | uint8_t getRecvPayloadLen(void);
111 | uint8_t read(uint8_t *payload, uint8_t payload_len);
112 | void setRadioChannel(uint8_t cChannel);
113 | uint8_t getRadioChannel(void);
114 | void setRadioChannelSpace(uint32_t lChannelSpace);
115 | uint32_t getRadioChannelSpace(void);
116 |
117 | protected:
118 | uint8_t S2LPSetReadyState(void);
119 | S2LPCutType S2LPManagementGetCut(void);
120 | /** S2-LP Irq Callback */
121 | void S2LPIrqHandler(void);
122 | void disableS2LPIrq(void);
123 | void enableS2LPIrq(void);
124 | void FEM_Operation_SKY66420(FEM_OperationType operation);
125 | S2LPStatus S2LPSpiWriteRegisters(uint8_t cRegAddress, uint8_t cNbBytes, uint8_t* pcBuffer);
126 | S2LPStatus S2LPSpiReadRegisters(uint8_t cRegAddress, uint8_t cNbBytes, uint8_t* pcBuffer);
127 | S2LPStatus S2LPSpiCommandStrobes(uint8_t cCommandCode);
128 | S2LPStatus S2LPSpiWriteFifo(uint8_t cNbBytes, uint8_t* pcBuffer);
129 | S2LPStatus S2LPSpiReadFifo(uint8_t cNbBytes, uint8_t* pcBuffer);
130 | void SpiSendRecv(uint8_t *pcHeader, uint8_t *pcBuffer, uint16_t cNbBytes);
131 | int32_t S2LPManagementRcoCalibration(void);
132 | void S2LPCmdStrobeCommand(S2LPCmd xCommandCode);
133 | void S2LPGeneralSetExtRef(ModeExtRef xExtMode);
134 | ModeExtRef S2LPGeneralGetExtRef(void);
135 | uint8_t S2LPGeneralGetDevicePN(void);
136 | uint8_t S2LPGeneralGetVersion(void);
137 | void S2LPRadioSetExternalSmpsMode(SFunctionalState xNewState);
138 | void S2LPRefreshStatus(void);
139 | void S2LPCsmaInit(SCsmaInit* pxSCsmaInit);
140 | void S2LPCsmaGetInfo(SCsmaInit* pxSCsmaInit);
141 | void S2LPCsma(SFunctionalState xNewState);
142 | SFunctionalState S2LPCsmaGetCsma(void);
143 | void S2LPCsmaPersistentMode(SFunctionalState xNewState);
144 | SFunctionalState S2LPCsmaGetPersistentMode(void);
145 | void S2LPCsmaSeedReloadMode(SFunctionalState xNewState);
146 | SFunctionalState S2LPCsmaGetSeedReloadMode(void);
147 | void S2LPCsmaSetBuCounterSeed(uint16_t nBuCounterSeed);
148 | uint16_t S2LPCsmaGetBuCounterSeed(void);
149 | void S2LPCsmaSetBuPrescaler(uint8_t cBuPrescaler);
150 | uint8_t S2LPCsmaGetBuPrescaler(void);
151 | void S2LPCsmaSetCcaPeriod(SCsmaPeriod xMultiplierTbit);
152 | uint8_t S2LPCsmaGetCcaPeriod(void);
153 | void S2LPCsmaSetCcaLength(uint8_t xCcaLength);
154 | uint8_t S2LPCsmaGetCcaLength(void);
155 | void S2LPCsmaSetMaxNumberBackoff(uint8_t cMaxNb);
156 | uint8_t S2LPCsmaGetMaxNumberBackoff(void);
157 | uint8_t S2LPFifoReadNumberBytesRxFifo(void);
158 | uint8_t S2LPFifoReadNumberBytesTxFifo(void);
159 | void S2LPFifoSetAlmostFullThresholdRx(uint8_t cThrRxFifo);
160 | uint8_t S2LPFifoGetAlmostFullThresholdRx(void);
161 | void S2LPFifoSetAlmostEmptyThresholdRx(uint8_t cThrRxFifo);
162 | uint8_t S2LPFifoGetAlmostEmptyThresholdRx(void);
163 | void S2LPFifoSetAlmostFullThresholdTx(uint8_t cThrTxFifo);
164 | uint8_t S2LPFifoGetAlmostFullThresholdTx(void);
165 | void S2LPFifoSetAlmostEmptyThresholdTx(uint8_t cThrTxFifo);
166 | uint8_t S2LPFifoGetAlmostEmptyThresholdTx(void);
167 | void S2LPFifoMuxRxFifoIrqEnable(SFunctionalState xNewState);
168 | void S2LPGpioInit(SGpioInit* pxGpioInitStruct);
169 | void S2LPGpioSetLevel(S2LPGpioPin xGpioX, OutputLevel xLevel);
170 | OutputLevel S2LPGpioGetLevel(S2LPGpioPin xGpioX);
171 | void S2LPGpioIrqDeInit(S2LPIrqs* pxIrqInit);
172 | void S2LPGpioIrqInit(S2LPIrqs* pxIrqInit);
173 | void S2LPGpioIrqConfig(IrqList xIrq, SFunctionalState xNewState);
174 | void S2LPGpioIrqGetMask(S2LPIrqs* pxIrqMask);
175 | void S2LPGpioIrqGetStatus(S2LPIrqs* pxIrqStatus);
176 | void S2LPGpioIrqClearStatus(void);
177 | SBool S2LPGpioIrqCheckFlag(IrqList xFlag);
178 | void S2LPSetPreambleLength(uint16_t cPreambleLength);
179 | uint16_t S2LPGetPreambleLength(void);
180 | void S2LPSetSyncLength(uint8_t cSyncLength);
181 | uint8_t S2LPGetSyncLength(void);
182 | void S2LPSetSyncWords(uint32_t lSyncWords, uint8_t xSyncLength);
183 | void S2LPGetSyncWords(uint32_t* lSyncWords, uint8_t* cSyncLength);
184 | void S2LPPacketHandlerWhitening(SFunctionalState xNewState);
185 | void S2LPPacketHandlerFec(SFunctionalState xNewState);
186 | void S2LPPacketHandler3OutOf6(SFunctionalState xNewState);
187 | void S2LPPacketHandlerManchester(SFunctionalState xNewState);
188 | uint8_t S2LPGetPacketFormat(void);
189 | void S2LPPktCommonFilterOnCrc(SFunctionalState xNewState);
190 | uint8_t S2LPGetReceivedDestinationAddress(void);
191 | uint8_t S2LPGetReceivedSourceAddress(void);
192 | uint8_t S2LPGetMyAddress(void);
193 | uint8_t S2LPGetBroadcastAddress(void);
194 | uint8_t S2LPGetMulticastAddress(void);
195 | uint8_t S2LPGetRxSourceMask(void);
196 | uint8_t S2LPGetRxSourceReferenceAddress(void);
197 | void S2LPPacketHandlerSetTxMode(DirectTx xNewState);
198 | void S2LPPacketHandlerSetRxMode(DirectRx xNewState);
199 | DirectTx S2LPPacketHandlerGetTxMode(void);
200 | DirectRx S2LPPacketHandlerGetRxMode(void);
201 | uint8_t S2LPPacketHandlerGetTransmittedSeqNumber(void);
202 | void S2LPPacketHandlerSetExtendedLenField(SFunctionalState xExtendedLenField);
203 | void S2LPPacketHandlerSwap4FSKSymbol(SFunctionalState xSwapSymbol);
204 | void S2LPPacketHandlerSwapFifoEndianess(SFunctionalState xEnableSwap);
205 | void S2LPPacketHandlerSwapPreamblePattern(SFunctionalState xEnableSwap);
206 | void S2LPPacketHandlerSetCrcMode(PktCrcMode xPktCrcMode);
207 | PktCrcMode S2LPPacketHandlerGetCrcMode(void);
208 | void S2LPPacketHandlerSelectSecondarySync(SFunctionalState xSecondarySync);
209 | void S2LPPacketHandlerSetAutoPcktFilter(SFunctionalState xNewState);
210 | void S2LPPacketHandlerSetRxPersistentMode(SFunctionalState xNewState);
211 | void S2LPPacketHandlerSetSrcAddrFlt(SFunctionalState xNewState);
212 | void S2LPPacketHandlerSetVariableLength(SFunctionalState xVarLen);
213 | void S2LPSetDualSyncWords(uint32_t lSyncWords);
214 | void S2LPGetDualSyncWords(uint32_t* lSyncWords);
215 | void S2LPSetRxSourceMask(uint8_t address);
216 | void S2LPSetRxSourceReferenceAddress(uint8_t address);
217 | void S2LPSetBroadcastAddress(uint8_t address);
218 | void S2LPSetMulticastAddress(uint8_t address);
219 | void S2LPSetMyAddress(uint8_t address);
220 | void S2LPPktBasicInit(PktBasicInit* pxPktBasicInit);
221 | void S2LPPktBasicGetInfo(PktBasicInit* pxPktBasicInit);
222 | void S2LPPktBasicAddressesInit(PktBasicAddressesInit* pxPktBasicAddresses);
223 | void S2LPPktBasicGetAddressesInfo(PktBasicAddressesInit* pxPktBasicAddresses);
224 | void S2LPPktBasicSetFormat(void);
225 | void S2LPPktBasicAddressField(SFunctionalState xAddressField);
226 | SFunctionalState S2LPPktBasicGetAddressField(void);
227 | void S2LPPktBasicSetPayloadLength(uint16_t nPayloadLength);
228 | uint16_t S2LPPktBasicGetPayloadLength(void);
229 | uint16_t S2LPPktBasicGetReceivedPktLength(void);
230 | void S2LPPktStackInit(PktStackInit* pxPktStackInit);
231 | void S2LPPktStackGetInfo(PktStackInit* pxPktStackInit);
232 | void S2LPPktStackAddressesInit(PktStackAddressesInit* pxPktStackAddresses);
233 | void S2LPPktStackGetAddressesInfo(PktStackAddressesInit* pxPktStackAddresses);
234 | void S2LPPktStackSetFormat(void);
235 | void S2LPPktStackSetPayloadLength(uint16_t nPayloadLength);
236 | uint16_t S2LPPktStackGetPayloadLength(void);
237 | uint16_t S2LPPktStackGetReceivedPktLength(void);
238 | void S2LPPktStackAckRequest(SFunctionalState xNewState);
239 | void S2LPPktStackAutoAck(SFunctionalState xNewState);
240 | void S2LPPktStackNRetx(uint8_t nRetx);
241 | void S2LPPktStackPiggybacking(SFunctionalState xNewState);
242 | void S2LPPktStackSeqNumForReload(uint8_t cReloadValue);
243 | SFlagStatus S2LPPktStackGetTXAckRequest(void);
244 | uint8_t S2LPPktStackGetNReTx(void);
245 | void S2LPPktWMbusInit(PktWMbusInit* pxPktWMbusInit);
246 | void S2LPPktWMbusGetInfo(PktWMbusInit* pxPktWMbusInit);
247 | void S2LPPktWMbusSetFormat(void);
248 | void S2LPPktWMbusSetPostamble(uint8_t cPostamble);
249 | uint8_t S2LPPktWMbusGetPostamble(void);
250 | void S2LPPktWMbusSetPostamblePattern(uint8_t cPostamble);
251 | uint8_t S2LPPktWMbusGetPostamblePattern(void);
252 | void S2LPPktWMbusSetSubmode(WMbusSubmode xWMbusSubmode);
253 | WMbusSubmode S2LPPktWMbusGetSubmode(void);
254 | void S2LPPktWMbusSetPayloadLength(uint16_t nPayloadLength);
255 | uint16_t S2LPPktWMbusGetPayloadLength(void);
256 | int32_t S2LPRadioGetRssidBm(void);
257 | int32_t S2LPRadioGetRssidBmRun(void);
258 | void S2LPRadioSetRssiThreshdBm(int32_t wRssiThrehsold);
259 | void S2LPRadioCsBlanking(SFunctionalState xCsBlank);
260 | void S2LPRadioRssiInit(SRssiInit* xSRssiInit);
261 | void S2LPRadioGetRssiInfo(SRssiInit* xSRssiInit);
262 | void S2LPRadioAntennaSwitching(SFunctionalState xAntennaSwitch);
263 | void S2LPRadioSetPqiCheck(uint8_t cPqiLevel);
264 | SFlagStatus S2LPQiGetCs(void);
265 | uint8_t S2LPRadioInit(SRadioInit* pxSRadioInitStruct);
266 | void S2LPRadioGetInfo(SRadioInit* pxSRadioInitStruct);
267 | void S2LPRadioSetSynthWord(uint32_t lSynthWord);
268 | uint32_t S2LPRadioGetSynthWord(void);
269 | void S2LPRadioSetChannel(uint8_t cChannel);
270 | uint8_t S2LPRadioGetChannel(void);
271 | void S2LPRadioSetRefDiv(SFunctionalState xNewState);
272 | SFunctionalState S2LPRadioGetRefDiv(void);
273 | void S2LPRadioSetDigDiv(SFunctionalState xNewState);
274 | SFunctionalState S2LPRadioGetDigDiv(void);
275 | void S2LPRadioSetChannelSpace(uint32_t lChannelSpace);
276 | uint32_t S2LPRadioGetChannelSpace(void);
277 | uint8_t S2LPRadioSetFrequencyBase(uint32_t lFBase);
278 | uint32_t S2LPRadioGetFrequencyBase(void);
279 | void S2LPRadioSetDatarate(uint32_t lDatarate);
280 | uint32_t S2LPRadioGetDatarate(void);
281 | void S2LPRadioSetFrequencyDev(uint32_t lFDev);
282 | uint32_t S2LPRadioGetFrequencyDev(void);
283 | void S2LPRadioSetChannelBW(uint32_t lBandwidth);
284 | uint32_t S2LPRadioGetChannelBW(void);
285 | void S2LPRadioSetModulation(ModulationSelect xModulation);
286 | ModulationSelect S2LPRadioGetModulation(void);
287 | void S2LPRadioSetXtalFrequency(uint32_t lXtalFrequency);
288 | uint32_t S2LPRadioGetXtalFrequency(void);
289 | void S2LPRadioSetIsiEqualizationMode(SIsiEqu xSIsiMode);
290 | SIsiEqu S2LPRadioGetIsiEqualizationMode(void);
291 | void S2LPRadioCalibrationVco(SFunctionalState xAmplitudeCalibration, SFunctionalState xFrequencyCalibration);
292 | void S2LPRadioSetTxCalibVcoAmpWord(uint8_t value);
293 | void S2LPRadioSetRxCalibVcoAmpWord(uint8_t value);
294 | void S2LPRadioSetTxCalibVcoFreqWord(uint8_t value);
295 | void S2LPRadioSetRxCalibVcoFreqWord(uint8_t value);
296 | void S2LPRadioSetMaxPALevel(SFunctionalState xNewState);
297 | void S2LPRadioSetPALeveldBm(uint8_t cIndex, int32_t wPowerdBm);
298 | int32_t S2LPRadioGetPALeveldBm(uint8_t cIndex);
299 | uint8_t S2LPRadioGetPALevelMaxIndex(void);
300 | void S2LPRadioSetPALevelMaxIndex(uint8_t cIndex);
301 | void S2LPRadioSetManualRampingMode(SFunctionalState xNewState);
302 | void S2LPRadioSetAutoRampingMode(SFunctionalState xNewState);
303 | void S2LPRadioAfcInit(SAfcInit* xSAfcInit);
304 | void S2LPRadioGetAfcInfo(SAfcInit* xSAfcInit);
305 | void S2LPRadioSymClkRecoverInit(SSymClkRecInit* xSSymClkRecInit);
306 | void S2LPRadioGetSymClkRecoverInfo(SSymClkRecInit* xSSymClkRecInit);
307 | void S2LPRadioSearchDatarateME(uint32_t lDatarate, uint16_t* pcM, uint8_t* pcE);
308 | void S2LPRadioSearchFreqDevME(uint32_t lFDev, uint8_t* pcM, uint8_t* pcE);
309 | void S2LPRadioSearchChannelBwME(uint32_t lBandwidth, uint8_t* pcM, uint8_t* pcE);
310 | uint32_t S2LPRadioComputeDatarate(uint16_t cM, uint8_t cE);
311 | uint32_t S2LPRadioComputeFreqDeviation(uint8_t cM, uint8_t cE, uint8_t bs, uint8_t refdiv);
312 | uint32_t S2LPRadioComputeChannelFilterBw(uint8_t cM, uint8_t cE);
313 | uint32_t S2LPRadioComputeFrequencyBase(uint32_t lSynthWord, uint8_t bs, uint8_t refdiv);
314 | uint32_t S2LPRadioComputeSynthWord(uint32_t frequency, uint8_t refdiv);
315 | uint8_t S2LPRadioComputeChannelSpacingRegValue(uint32_t lChannelSpace);
316 | uint32_t S2LPRadioComputeChannelSpacing(uint8_t cChSpaceRegVal);
317 | void S2LPRadioSearchWCP(uint8_t* cp_isel, uint8_t* pfd_split, uint32_t lFc, uint8_t refdiv);
318 | void S2LPRadioComputeIF(uint32_t nIF, uint8_t* pcAnaIf, uint8_t* pcPcDigIf);
319 | void S2LPTimerSetRxTimerStopCondition(RxTimeoutStopCondition xStopCondition);
320 | void S2LPTimerLdcrMode(SFunctionalState xNewState);
321 | void S2LPTimerLdcrAutoReload(SFunctionalState xNewState);
322 | SFunctionalState S2LPTimerLdcrGetAutoReload(void);
323 | void S2LpTimerFastRxTermTimer(SFunctionalState xNewState);
324 | void S2LpSetTimerFastRxTermTimer(uint8_t fast_rx_word);
325 | void S2LpSetTimerFastRxTermTimerUs(uint32_t fast_rx_us);
326 | void S2LPTimerSetRxTimer(uint8_t cCounter , uint8_t cPrescaler);
327 | void S2LPTimerSetRxTimerUs(uint32_t lDesiredUsec);
328 | void S2LPTimerSetRxTimerCounter(uint8_t cCounter);
329 | void S2LPTimerSetRxTimerPrescaler(uint8_t cPrescaler);
330 | void S2LPTimerGetRxTimerUs(uint32_t* plTimeoutUsec, uint8_t* pcCounter , uint8_t* pcPrescaler);
331 | void S2LPTimerSetWakeUpTimer(uint8_t cCounter , uint8_t cPrescaler);
332 | void S2LPTimerSetWakeUpTimerUs(uint32_t lDesiredUsec);
333 | void S2LPTimerSetWakeUpTimerCounter(uint8_t cCounter);
334 | void S2LPTimerSetWakeUpTimerPrescaler(uint8_t cPrescaler);
335 | void S2LPTimerSetWakeUpTimerReloadUs(uint32_t lDesiredUsec);
336 | void S2LPTimerGetWakeUpTimerUs(uint32_t* plWakeUpUsec, uint8_t* pcCounter, uint8_t* pcPrescaler, uint8_t* pcMulti);
337 | void S2LPTimerSetWakeUpTimerReload(uint8_t cCounter , uint8_t cPrescaler, uint8_t cMulti);
338 | void S2LPTimerSetWakeUpTimerReloadCounter(uint8_t cCounter);
339 | void S2LPTimerSetWakeUpTimerReloadPrescaler(uint8_t cPrescaler);
340 | void S2LPTimerGetWakeUpTimerReloadUs(uint32_t* plWakeUpReloadUsec, uint8_t* pcCounter, uint8_t* pcPrescaler, uint8_t* pcMulti);
341 | uint16_t S2LPTimerGetRcoFrequency(void);
342 | void S2LPTimerCalibrationRco(SFunctionalState xCalibration);
343 | void S2LPTimerSleepB(SFunctionalState en);
344 | void S2LPTimerLdcIrqWa(SFunctionalState en);
345 | void S2LPTimerComputeWakeupTimerValues(uint32_t* plWakeUpUsec , uint8_t cCounter , uint8_t cPrescaler, uint8_t cMulti);
346 | void S2LPTimerComputeRxTimerValues(uint32_t* plDesiredUsec, uint8_t pcCounter, uint8_t pcPrescaler);
347 | void S2LPTimerComputeRxTimerRegValues(uint32_t plDesiredUsec , uint8_t* pcCounter , uint8_t* pcPrescaler);
348 | void S2LPTimerComputeWakeupTimerRegValues(uint32_t plDesiredUsec , uint8_t* pcCounter , uint8_t* pcPrescaler, uint8_t* pcMulti);
349 | void S2LPTimerSetRxTimerMs(float fDesiredMsec);
350 | void S2LPTimerGetRxTimer(float* pfTimeoutMsec, uint8_t* pcCounter , uint8_t* pcPrescaler);
351 | void S2LPTimerSetWakeUpTimerMs(float fDesiredMsec);
352 | void S2LPTimerSetWakeUpTimerReloadMs(float fDesiredMsec);
353 | void S2LPTimerGetWakeUpTimer(float* pfWakeUpMsec, uint8_t* pcCounter , uint8_t* pcPrescaler, uint8_t* pcMulti);
354 | void S2LPTimerGetWakeUpTimerReload(float* pfWakeUpReloadMsec, uint8_t* pcCounter, uint8_t* pcPrescaler, uint8_t* pcMulti);
355 | void S2LPTimerComputeWakeUpValues(float fDesiredMsec , uint8_t* pcCounter , uint8_t* pcPrescaler);
356 |
357 | SPIClass *dev_spi;
358 | int csn_pin;
359 | int sdn_pin;
360 | int irq_pin;
361 | uint32_t lFrequencyBase;
362 | uint32_t s_lXtalFrequency;
363 | PAInfo_t s_paInfo;
364 | S2LPGpioPin irq_gpio_selected;
365 | uint8_t my_address;
366 | uint8_t multicast_address;
367 | uint8_t broadcast_address;
368 | S2LPStatus g_xStatus;
369 | WMbusSubmode s_cWMbusSubmode;
370 | S2LPEventHandler current_event_callback;
371 | S2LPEventHandler irq_handler;
372 | int nr_of_irq_disabled;
373 | volatile FlagStatus xTxDoneFlag;
374 | uint8_t vectcRxBuff[FIFO_SIZE];
375 | uint8_t vectcTxBuff[FIFO_SIZE];
376 | uint8_t cRxData;
377 | volatile bool is_waiting_for_read;
378 | bool is_bypass_enabled;
379 | };
380 |
381 | #endif /* __S2LP_H__ */
382 |
--------------------------------------------------------------------------------
/src/S2LP_Commands.cpp:
--------------------------------------------------------------------------------
1 | /**
2 | * @file S2LP_Commands.c
3 | * @author ST Microelectronics
4 | * @version 1.3.0
5 | * @date June, 2019
6 | * @brief Management of S2-LP Commands.
7 | * @details
8 | *
9 | * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
10 | * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
11 | * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
12 | * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
13 | * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
14 | * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
15 | *
16 | * THIS SOURCE CODE IS PROTECTED BY A LICENSE.
17 | * FOR MORE INFORMATION PLEASE CAREFULLY READ THE LICENSE AGREEMENT FILE LOCATED
18 | * IN THE ROOT DIRECTORY OF THIS FIRMWARE PACKAGE.
19 | *
20 | * © COPYRIGHT 2019 STMicroelectronics
21 | */
22 |
23 |
24 | /* Includes ------------------------------------------------------------------*/
25 | #include "S2LP.h"
26 |
27 |
28 |
29 | /**
30 | * @addtogroup S2LP_Libraries
31 | * @{
32 | */
33 |
34 |
35 | /**
36 | * @addtogroup S2LP_Commands
37 | * @{
38 | */
39 |
40 |
41 | /**
42 | * @defgroup Commands_Private_TypesDefinitions Commands Private TypesDefinitions
43 | * @{
44 | */
45 |
46 | /**
47 | *@}
48 | */
49 |
50 |
51 | /**
52 | * @defgroup Commands_Private_Defines Commands Private Defines
53 | * @{
54 | */
55 |
56 | /**
57 | *@}
58 | */
59 |
60 | /**
61 | * @defgroup Commands_Private_Macros Commands Private Macros
62 | * @{
63 | */
64 |
65 | #define IS_S2LP_CMD(CMD) (CMD == CMD_TX || \
66 | CMD == CMD_RX || \
67 | CMD == CMD_READY || \
68 | CMD == CMD_STANDBY || \
69 | CMD == CMD_SLEEP || \
70 | CMD == CMD_LOCKRX || \
71 | CMD == CMD_LOCKTX || \
72 | CMD == CMD_SABORT || \
73 | CMD == CMD_LDC_RELOAD || \
74 | CMD == CMD_SEQUENCE_UPDATE || \
75 | CMD == CMD_SRES || \
76 | CMD == CMD_FLUSHRXFIFO || \
77 | CMD == CMD_FLUSHTXFIFO \
78 | )
79 |
80 | /**
81 | *@}
82 | */
83 |
84 |
85 | /**
86 | * @defgroup Commands_Private_Variables Commands Private Variables
87 | * @{
88 | */
89 |
90 | /**
91 | *@}
92 | */
93 |
94 |
95 |
96 | /**
97 | * @defgroup Commands_Private_FunctionPrototypes Commands Private Function Prototypes
98 | * @{
99 | */
100 |
101 | /**
102 | *@}
103 | */
104 |
105 |
106 | /**
107 | * @defgroup Commands_Private_Functions Commands Private Functions
108 | * @{
109 | */
110 |
111 | /**
112 | * @brief Send a specific command to S2LP.
113 | * @param xCommandCode code of the command to send.
114 | This parameter can be any value of @ref S2LPCmd.
115 | * @retval None.
116 | */
117 | void S2LP::S2LPCmdStrobeCommand(S2LPCmd xCommandCode)
118 | {
119 | /* Check the parameters */
120 | s_assert_param(IS_S2LP_CMD(xCommandCode));
121 |
122 | g_xStatus = S2LPSpiCommandStrobes((uint8_t) xCommandCode);
123 | }
124 |
125 |
126 | /**
127 | *@}
128 | */
129 |
130 |
131 | /**
132 | *@}
133 | */
134 |
135 |
136 | /**
137 | *@}
138 | */
139 |
140 |
141 |
142 |
143 | /******************* (C) COPYRIGHT 2019 STMicroelectronics *****END OF FILE****/
144 |
--------------------------------------------------------------------------------
/src/S2LP_Commands.h:
--------------------------------------------------------------------------------
1 | /**
2 | * @file S2LP_Commands.h
3 | * @author LowPower RF BU - AMG
4 | * @version 1.3.0
5 | * @date April 12, 2017
6 | * @brief Management of S2-LP Commands.
7 | * @details
8 | *
9 | * In this module can be found all the API used to strobe commands to
10 | * S2LP.
11 | * Every command strobe is an SPI transaction with a specific command code.
12 | *
13 | * Example:
14 | * @code
15 | * ...
16 | *
17 | * S2LPCmdStrobeRx();
18 | *
19 | * ...
20 | * @endcode
21 | *
22 | * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
23 | * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
24 | * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
25 | * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
26 | * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
27 | * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
28 | *
29 | * THIS SOURCE CODE IS PROTECTED BY A LICENSE.
30 | * FOR MORE INFORMATION PLEASE CAREFULLY READ THE LICENSE AGREEMENT FILE LOCATED
31 | * IN THE ROOT DIRECTORY OF THIS FIRMWARE PACKAGE.
32 | *
33 | * © COPYRIGHT 2019 STMicroelectronics
34 | */
35 |
36 |
37 | /* Define to prevent recursive inclusion -------------------------------------*/
38 | #ifndef __S2LP_COMMANDS_H
39 | #define __S2LP_COMMANDS_H
40 |
41 |
42 | /* Includes ------------------------------------------------------------------*/
43 |
44 | #include "S2LP_Regs.h"
45 | #include "S2LP_Types.h"
46 |
47 | #ifdef __cplusplus
48 | extern "C" {
49 | #endif
50 |
51 |
52 | /**
53 | * @addtogroup S2LP_Libraries
54 | * @{
55 | */
56 |
57 |
58 | /**
59 | * @defgroup S2LP_Commands Commands
60 | * @brief Management of S2LP Commands.
61 | * @details See the file @ref S2LP_Commands.h for more details.
62 | * @{
63 | */
64 |
65 | /**
66 | * @defgroup Commands_Exported_Types Commands Exported Types
67 | * @{
68 | */
69 |
70 | /**
71 | * @brief S2LP Commands codes enumeration
72 | */
73 | typedef enum
74 | {
75 | CMD_TX = ((uint8_t)(0x60)), /*!< Start to transmit; valid only from READY */
76 | CMD_RX = ((uint8_t)(0x61)), /*!< Start to receive; valid only from READY */
77 | CMD_READY = ((uint8_t)(0x62)), /*!< Go to READY; valid only from STANDBY or SLEEP or LOCK */
78 | CMD_STANDBY = ((uint8_t)(0x63)), /*!< Go to STANDBY; valid only from READY */
79 | CMD_SLEEP = ((uint8_t)(0x64)), /*!< Go to SLEEP; valid only from READY */
80 | CMD_LOCKRX = ((uint8_t)(0x65)), /*!< Go to LOCK state by using the RX configuration of the synth; valid only from READY */
81 | CMD_LOCKTX = ((uint8_t)(0x66)), /*!< Go to LOCK state by using the TX configuration of the synth; valid only from READY */
82 | CMD_SABORT = ((uint8_t)(0x67)), /*!< Force exit form TX or RX states and go to READY state; valid only from TX or RX */
83 | CMD_LDC_RELOAD = ((uint8_t)(0x68)), /*!< LDC Mode: Reload the LDC timer with the value stored in the LDC_PRESCALER / COUNTER registers; valid from all states */
84 | CMD_RCO_CALIB = ((uint8_t)(0x69)), /*!< Start (or re-start) the RCO calibration */
85 | CMD_SRES = ((uint8_t)(0x70)), /*!< Reset of all digital part, except SPI registers */
86 | CMD_FLUSHRXFIFO = ((uint8_t)(0x71)), /*!< Clean the RX FIFO; valid from all states */
87 | CMD_FLUSHTXFIFO = ((uint8_t)(0x72)), /*!< Clean the TX FIFO; valid from all states */
88 | CMD_SEQUENCE_UPDATE = ((uint8_t)(0x73)), /*!< Autoretransmission: Reload the Packet sequence counter with the value stored in the PROTOCOL[2] register valid from all states */
89 | } S2LPCmd;
90 |
91 |
92 | /**
93 | * @}
94 | */
95 |
96 |
97 | /**
98 | * @defgroup Commands_Exported_Constants Commands Exported Constants
99 | * @{
100 | */
101 |
102 |
103 | /**
104 | * @}
105 | */
106 |
107 |
108 | /**
109 | * @defgroup Commands_Exported_Macros Commands Exported Macros
110 | * @{
111 | */
112 |
113 | #define S2LPCmdStrobeReady() S2LPCmdStrobeCommand(CMD_READY)
114 | #define S2LPCmdStrobeStandby() S2LPCmdStrobeCommand(CMD_STANDBY)
115 | #define S2LPCmdStrobeSleep() S2LPCmdStrobeCommand(CMD_SLEEP)
116 | #define S2LPCmdStrobeLockRx() S2LPCmdStrobeCommand(CMD_LOCKRX)
117 | #define S2LPCmdStrobeLockTx() S2LPCmdStrobeCommand(CMD_LOCKTX)
118 | #define S2LPCmdStrobeSabort() S2LPCmdStrobeCommand(CMD_SABORT)
119 | #define S2LPCmdStrobeLdcReload() S2LPCmdStrobeCommand(CMD_LDC_RELOAD)
120 | #define S2LPCmdStrobeSequenceUpdate() S2LPCmdStrobeCommand(CMD_SEQUENCE_UPDATE)
121 | #define S2LPCmdStrobeSres() S2LPCmdStrobeCommand(CMD_SRES)
122 | #define S2LPCmdStrobeFlushRxFifo() S2LPCmdStrobeCommand(CMD_FLUSHRXFIFO)
123 | #define S2LPCmdStrobeFlushTxFifo() S2LPCmdStrobeCommand(CMD_FLUSHTXFIFO)
124 |
125 |
126 | /**
127 | * @}
128 | */
129 |
130 |
131 | /**
132 | * @}
133 | */
134 |
135 |
136 | /**
137 | * @}
138 | */
139 |
140 |
141 |
142 |
143 | #ifdef __cplusplus
144 | }
145 | #endif
146 |
147 | #endif
148 |
149 | /******************* (C) COPYRIGHT 2019 STMicroelectronics *****END OF FILE****/
150 |
--------------------------------------------------------------------------------
/src/S2LP_Config.h:
--------------------------------------------------------------------------------
1 | /**
2 | * @file S2LP_Config.h
3 | * @author ST Microelectronics
4 | * @version 1.3.0
5 | * @date June, 2019
6 | * @brief S2LP Configuration and useful defines .
7 | * @details
8 | *
9 | * This file is used to include all or a part of the S2LP
10 | * libraries into the application program which will be used.
11 | * Moreover some important parameters are defined here and the
12 | * user is allowed to edit them.
13 | *
14 | * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
15 | * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
16 | * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
17 | * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
18 | * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
19 | * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
20 | *
21 | * THIS SOURCE CODE IS PROTECTED BY A LICENSE.
22 | * FOR MORE INFORMATION PLEASE CAREFULLY READ THE LICENSE AGREEMENT FILE LOCATED
23 | * IN THE ROOT DIRECTORY OF THIS FIRMWARE PACKAGE.
24 | *
25 | * © COPYRIGHT 2015 STMicroelectronics
26 | */
27 |
28 |
29 | /* Define to prevent recursive inclusion -------------------------------------*/
30 | #ifndef __S2LP_CONFIG_H
31 | #define __S2LP_CONFIG_H
32 |
33 |
34 | /* Includes ------------------------------------------------------------------*/
35 | #include "S2LP_Regs.h"
36 | #include "S2LP_Commands.h"
37 | #include "S2LP_Csma.h"
38 | #include "S2LP_General.h"
39 | #include "S2LP_Gpio.h"
40 | #include "S2LP_Timer.h"
41 | #include "S2LP_Fifo.h"
42 | #include "S2LP_PacketHandler.h"
43 | #include "S2LP_PktBasic.h"
44 | #include "S2LP_PktWMbus.h"
45 | #include "S2LP_PktStack.h"
46 | #include "S2LP_Radio.h"
47 | #include "S2LP_Qi.h"
48 | #include "S2LP_Types.h"
49 |
50 |
51 | #ifdef __cplusplus
52 | extern "C" {
53 | #endif
54 |
55 |
56 | /** @addtogroup S2LP_Libraries S2LP Libraries
57 | * @brief This firmware implements libraries which allow the user
58 | * to manage the features of S2LP without knowing the hardware details.
59 | * @details The S2LP_Libraries modules are totally platform independent. The library provides one
60 | * module for each device feature. Each module refers to some functions whose prototypes are located in the
61 | * header file @ref MCU_Interface.h. The user who want to use these libraries on a particular
62 | * platform has to implement these functions respecting them signatures.
63 | * @{
64 | */
65 |
66 | /** @defgroup S2LP_Configuration Configuration
67 | * @brief S2LP Configuration and useful defines.
68 | * @details See the file @ref S2LP_Config.h for more details.
69 | * @{
70 | */
71 |
72 |
73 | /** @defgroup Configuration_Exported_Types Configuration Exported Types
74 | * @{
75 | */
76 |
77 | /**
78 | * @}
79 | */
80 |
81 |
82 | /** @defgroup Configuration_Exported_Constants Configuration Exported Constants
83 | * @{
84 | */
85 | #define DIG_DOMAIN_XTAL_THRESH 30000000 /*!< Digital domain logic threshold for XTAL in MHz */
86 |
87 | /**
88 | * @}
89 | */
90 |
91 |
92 | /** @defgroup Configuration_Exported_Macros Configuration Exported Macros
93 | * @{
94 | */
95 |
96 |
97 | /**
98 | * @}
99 | */
100 |
101 |
102 | /** @defgroup Configuration_Exported_Functions Configuration Exported Functions
103 | * @{
104 | */
105 |
106 | /**
107 | * @}
108 | */
109 |
110 | /**
111 | * @}
112 | */
113 |
114 |
115 | /**
116 | * @}
117 | */
118 |
119 |
120 | #ifdef __cplusplus
121 | }
122 | #endif
123 |
124 | #endif
125 |
126 | /******************* (C) COPYRIGHT 2015 STMicroelectronics *****END OF FILE****/
127 |
--------------------------------------------------------------------------------
/src/S2LP_Csma.cpp:
--------------------------------------------------------------------------------
1 | /**
2 | * @file S2LP_Csma.c
3 | * @author ST Microelectronics
4 | * @version 1.3.0
5 | * @date June, 2019
6 | * @brief Configuration and management of S2-LP CSMA.
7 | * @details
8 | *
9 | * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
10 | * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
11 | * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
12 | * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
13 | * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
14 | * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
15 | *
16 | * THIS SOURCE CODE IS PROTECTED BY A LICENSE.
17 | * FOR MORE INFORMATION PLEASE CAREFULLY READ THE LICENSE AGREEMENT FILE LOCATED
18 | * IN THE ROOT DIRECTORY OF THIS FIRMWARE PACKAGE.
19 | *
20 | * © COPYRIGHT 2019 STMicroelectronics
21 | */
22 |
23 |
24 | /* Includes ------------------------------------------------------------------*/
25 | #include "S2LP.h"
26 |
27 |
28 |
29 | /**
30 | * @addtogroup S2LP_Libraries
31 | * @{
32 | */
33 |
34 |
35 | /**
36 | * @addtogroup S2LP_Csma
37 | * @{
38 | */
39 |
40 |
41 | /**
42 | * @defgroup Csma_Private_TypesDefinitions CSMA Private TypesDefinitions
43 | * @{
44 | */
45 |
46 |
47 | /**
48 | *@}
49 | */
50 |
51 |
52 | /**
53 | * @defgroup Csma_Private_Defines CSMA Private Defines
54 | * @{
55 | */
56 |
57 | /**
58 | *@}
59 | */
60 |
61 | /**
62 | * @defgroup Csma_Private_Macros CSMA Private Macros
63 | * @{
64 | */
65 | #define IS_CCA_PERIOD(PERIOD) (PERIOD == CSMA_PERIOD_64TBIT || \
66 | PERIOD == CSMA_PERIOD_128TBIT || \
67 | PERIOD == CSMA_PERIOD_256TBIT || \
68 | PERIOD == CSMA_PERIOD_512TBIT)
69 |
70 | #define IS_CSMA_LENGTH(LENGTH) (LENGTH < 16)
71 |
72 | #define IS_BU_COUNTER_SEED(SEED) (SEED!=0)
73 | #define IS_BU_PRESCALER(PRESCALER) (PRESCALER<64)
74 | #define IS_CMAX_NB(NB) (NB<8)
75 |
76 | /**
77 | *@}
78 | */
79 |
80 |
81 | /**
82 | * @defgroup Csma_Private_Variables CSMA Private Variables
83 | * @{
84 | */
85 |
86 | /**
87 | *@}
88 | */
89 |
90 |
91 |
92 | /**
93 | * @defgroup Csma_Private_FunctionPrototypes CSMA Private FunctionPrototypes
94 | * @{
95 | */
96 |
97 | /**
98 | *@}
99 | */
100 |
101 |
102 | /**
103 | * @defgroup Csma_Private_Functions CSMA Private Functions
104 | * @{
105 | */
106 |
107 |
108 | /**
109 | * @brief Initialize the S2LP CSMA according to the specified parameters in the SCsmaInit.
110 | * @param pxCsmaInit Csma init structure.
111 | * This parameter is a pointer to @ref SCsmaInit.
112 | * @retval None.
113 | */
114 | void S2LP::S2LPCsmaInit(SCsmaInit* pxCsmaInit)
115 | {
116 | uint8_t tmpBuffer[4];
117 |
118 | /* Check the parameters */
119 | s_assert_param(IS_SFUNCTIONAL_STATE(pxCsmaInit->xCsmaPersistentMode));
120 | s_assert_param(IS_CCA_PERIOD(pxCsmaInit->xMultiplierTbit));
121 | s_assert_param(IS_CSMA_LENGTH(pxCsmaInit->xCcaLength));
122 | s_assert_param(IS_BU_COUNTER_SEED(pxCsmaInit->nBuCounterSeed));
123 | s_assert_param(IS_BU_PRESCALER(pxCsmaInit->cBuPrescaler));
124 | s_assert_param(IS_CMAX_NB(pxCsmaInit->cMaxNb));
125 |
126 | /* CSMA BU counter seed (MSB) config */
127 | tmpBuffer[0] = (uint8_t)(pxCsmaInit->nBuCounterSeed >> 8);
128 |
129 | /* CSMA BU counter seed (LSB) config */
130 | tmpBuffer[1] = (uint8_t) pxCsmaInit->nBuCounterSeed;
131 |
132 | /* CSMA BU prescaler config and CCA period config */
133 | tmpBuffer[2] = (pxCsmaInit->cBuPrescaler << 2) | pxCsmaInit->xMultiplierTbit;
134 |
135 | /* CSMA CCA length config and max number of back-off */
136 | tmpBuffer[3] = (pxCsmaInit->xCcaLength<<4) | pxCsmaInit->cMaxNb;
137 |
138 | /* Reads the PROTOCOL1_BASE register value, to write the SEED_RELOAD and CSMA_PERS_ON fields */
139 | S2LPSpiWriteRegisters(CSMA_CONF3_ADDR, 4, tmpBuffer);
140 |
141 | S2LPSpiReadRegisters(PROTOCOL1_ADDR, 1, &tmpBuffer[0]);
142 |
143 | /* Writes the new value for persistent mode */
144 | if(pxCsmaInit->xCsmaPersistentMode==S_ENABLE) {
145 | tmpBuffer[0] |= CSMA_PERS_ON_REGMASK;
146 | }
147 | else {
148 | tmpBuffer[0] &= ~CSMA_PERS_ON_REGMASK;
149 | }
150 |
151 | /* Writes PROTOCOL1_BASE register */
152 | g_xStatus = S2LPSpiWriteRegisters(PROTOCOL1_ADDR, 1, &tmpBuffer[0]);
153 |
154 |
155 | }
156 |
157 |
158 | /**
159 | * @brief Return the fitted structure SCsmaInit starting from the registers values.
160 | * @param pxCsmaInit Csma structure to be fitted.
161 | * This parameter is a pointer to @ref SCsmaInit.
162 | * @retval None.
163 | */
164 | void S2LP::S2LPCsmaGetInfo(SCsmaInit* pxSCsmaInit)
165 | {
166 | uint8_t tmpBuffer[4];
167 |
168 | /* Reads PROTOCOL1_BASE register */
169 | S2LPSpiReadRegisters(PROTOCOL1_ADDR, 1, &tmpBuffer[0]);
170 |
171 | /* Reads the persistent mode enable bit */
172 | pxSCsmaInit->xCsmaPersistentMode = (SFunctionalState)((tmpBuffer[0]&CSMA_PERS_ON_REGMASK) >> 1);
173 |
174 | /* Reads CSMA_CONFIGx_BASE registers */
175 | g_xStatus = S2LPSpiReadRegisters(CSMA_CONF3_ADDR, 4, tmpBuffer);
176 |
177 | /* Reads the bu counter seed */
178 | pxSCsmaInit->nBuCounterSeed = (((uint16_t)tmpBuffer[0]) << 8) | (uint16_t)tmpBuffer[1];
179 |
180 | /* Reads the bu prescaler */
181 | pxSCsmaInit->cBuPrescaler = tmpBuffer[2]>>2;
182 |
183 | /* Reads the Cca period */
184 | pxSCsmaInit->xMultiplierTbit = (SCsmaPeriod)(tmpBuffer[2] & CCA_PERIOD_REGMASK);
185 |
186 | /* Reads the Cca length */
187 | pxSCsmaInit->xCcaLength = (tmpBuffer[3]&CCA_LEN_REGMASK)>>4;
188 |
189 | /* Reads the max number of back off */
190 | pxSCsmaInit->cMaxNb = tmpBuffer[3] & NBACKOFF_MAX_REGMASK;
191 |
192 | }
193 |
194 |
195 | /**
196 | * @brief Enable or Disables the CSMA.
197 | * @param xNewState the state of the CSMA mode.
198 | * This parameter can be: S_ENABLE or S_DISABLE.
199 | * @retval None.
200 | */
201 | void S2LP::S2LPCsma(SFunctionalState xNewState)
202 | {
203 | uint8_t tmp, tmp2;
204 | s_assert_param(IS_SFUNCTIONAL_STATE(xNewState));
205 |
206 | S2LPSpiReadRegisters(PROTOCOL1_ADDR, 1, &tmp);
207 |
208 | /* Set or reSet the CSMA enable bit */
209 | if(xNewState==S_ENABLE)
210 | {
211 | tmp |= CSMA_ON_REGMASK;
212 |
213 | S2LPSpiReadRegisters(PM_CONF0_ADDR, 1, &tmp2);
214 | tmp2 |= SLEEP_MODE_SEL_REGMASK;
215 | S2LPSpiWriteRegisters(PM_CONF0_ADDR, 1, &tmp2);
216 | }
217 | else
218 | {
219 | tmp &= ~CSMA_ON_REGMASK;
220 | }
221 |
222 | g_xStatus = S2LPSpiWriteRegisters(PROTOCOL1_ADDR, 1, &tmp);
223 |
224 | }
225 |
226 | /**
227 | * @brief Gets the CSMA mode. Says if it is enabled or disabled.
228 | * @param None.
229 | * @retval SFunctionalState: CSMA mode.
230 | */
231 | SFunctionalState S2LP::S2LPCsmaGetCsma(void)
232 | {
233 | uint8_t tmp;
234 |
235 | /* Reads the PROTOCOL1 register value */
236 | g_xStatus = S2LPSpiReadRegisters(PROTOCOL1_ADDR, 1, &tmp);
237 |
238 | /* Return if set or reset */
239 | if(tmp & CSMA_ON_REGMASK) {
240 | return S_ENABLE;
241 | }
242 | else {
243 | return S_DISABLE;
244 | }
245 |
246 | }
247 |
248 | /**
249 | * @brief Enables or Disables the persistent CSMA mode.
250 | * @param xNewState the state of the persistent CSMA mode.
251 | * This parameter can be: S_ENABLE or S_DISABLE.
252 | * @retval None.
253 | */
254 | void S2LP::S2LPCsmaPersistentMode(SFunctionalState xNewState)
255 | {
256 | uint8_t tmp;
257 | s_assert_param(IS_SFUNCTIONAL_STATE(xNewState));
258 |
259 | S2LPSpiReadRegisters(PROTOCOL1_ADDR, 1, &tmp);
260 |
261 | /* Enables/disables the CSMA persistent mode */
262 | if(xNewState==S_ENABLE) {
263 | tmp |= CSMA_PERS_ON_REGMASK;
264 | }
265 | else {
266 | tmp &= ~CSMA_PERS_ON_REGMASK;
267 | }
268 |
269 | g_xStatus = S2LPSpiWriteRegisters(PROTOCOL1_ADDR, 1, &tmp);
270 |
271 | }
272 |
273 |
274 | /**
275 | * @brief Gets the persistent CSMA mode.
276 | * @param None.
277 | * @retval SFunctionalState: CSMA persistent mode.
278 | */
279 | SFunctionalState S2LP::S2LPCsmaGetPersistentMode(void)
280 | {
281 | uint8_t tmp;
282 |
283 | g_xStatus = S2LPSpiReadRegisters(PROTOCOL1_ADDR, 1, &tmp);
284 |
285 | if(tmp & CSMA_PERS_ON_REGMASK) {
286 | return S_ENABLE;
287 | }
288 | else {
289 | return S_DISABLE;
290 | }
291 |
292 | }
293 |
294 |
295 | /**
296 | * @brief Enables or Disables the seed reload mode (if enabled it reloads the back-off generator seed using the value written in the BU_COUNTER_SEED register).
297 | * @param xNewState the state of the seed reload mode.
298 | * This parameter can be: S_ENABLE or S_DISABLE.
299 | * @retval None.
300 | */
301 | void S2LP::S2LPCsmaSeedReloadMode(SFunctionalState xNewState)
302 | {
303 | uint8_t tmp;
304 | s_assert_param(IS_SFUNCTIONAL_STATE(xNewState));
305 |
306 | S2LPSpiReadRegisters(PROTOCOL1_ADDR, 1, &tmp);
307 |
308 | /* Enables/disables the seed reload mode */
309 | if(xNewState==S_ENABLE) {
310 | tmp |= SEED_RELOAD_REGMASK;
311 | }
312 | else {
313 | tmp &= ~SEED_RELOAD_REGMASK;
314 | }
315 |
316 | g_xStatus = S2LPSpiWriteRegisters(PROTOCOL1_ADDR, 1, &tmp);
317 |
318 | }
319 |
320 |
321 | /**
322 | * @brief Gets the seed reload mode.
323 | * @param None.
324 | * @retval SFunctionalState: CSMA seed reload mode.
325 | */
326 | SFunctionalState S2LP::S2LPCsmaGetSeedReloadMode(void)
327 | {
328 | uint8_t tmp;
329 |
330 | g_xStatus = S2LPSpiReadRegisters(PROTOCOL1_ADDR, 1, &tmp);
331 |
332 | /* Return if set or reset */
333 | if(tmp & SEED_RELOAD_REGMASK) {
334 | return S_ENABLE;
335 | }
336 | else {
337 | return S_DISABLE;
338 | }
339 | }
340 |
341 |
342 | /**
343 | * @brief Set the BU counter seed (BU_COUNTER_SEED register). The CSMA back off time is given by the formula: BO = rand(2^NB)*BU.
344 | * @param nBuCounterSeed seed of the random number generator used to apply the BBE algorithm.
345 | * This parameter is an uint16_t.
346 | * @retval None.
347 | */
348 | void S2LP::S2LPCsmaSetBuCounterSeed(uint16_t nBuCounterSeed)
349 | {
350 | uint8_t tmpBuffer[2];
351 | s_assert_param(IS_BU_COUNTER_SEED(nBuCounterSeed));
352 |
353 | tmpBuffer[0] = (uint8_t)(nBuCounterSeed>>8);
354 | tmpBuffer[1] = (uint8_t)nBuCounterSeed;
355 |
356 | g_xStatus = S2LPSpiWriteRegisters(CSMA_CONF3_ADDR, 2, tmpBuffer);
357 |
358 | }
359 |
360 | /**
361 | * @brief Return the BU counter seed (BU_COUNTER_SEED register).
362 | * @param None.
363 | * @retval uint16_t Seed of the random number generator used to apply the BBE algorithm.
364 | */
365 | uint16_t S2LP::S2LPCsmaGetBuCounterSeed(void)
366 | {
367 | uint8_t tmpBuffer[2];
368 |
369 | g_xStatus = S2LPSpiReadRegisters(CSMA_CONF3_ADDR, 2, tmpBuffer);
370 |
371 | return ((((uint16_t)tmpBuffer[0])<<8) + (uint16_t)tmpBuffer[1]);
372 | }
373 |
374 |
375 | /**
376 | * @brief Set the BU prescaler. The CSMA back off time is given by the formula: BO = rand(2^NB)*BU.
377 | * @param cBuPrescaler used to program the back-off unit BU.
378 | * This parameter is an uint8_t.
379 | * @retval None.
380 | */
381 | void S2LP::S2LPCsmaSetBuPrescaler(uint8_t cBuPrescaler)
382 | {
383 | uint8_t tmp;
384 | s_assert_param(IS_BU_PRESCALER(cBuPrescaler));
385 |
386 | S2LPSpiReadRegisters(CSMA_CONF1_ADDR, 1, &tmp);
387 |
388 | tmp &= ~BU_PRSC_REGMASK;
389 | tmp |= (cBuPrescaler<<2);
390 |
391 | g_xStatus = S2LPSpiWriteRegisters(CSMA_CONF1_ADDR, 1, &tmp);
392 | }
393 |
394 |
395 | /**
396 | * @brief Return the BU prescaler.
397 | * @param None.
398 | * @retval uint8_t Value back-off unit (BU).
399 | */
400 | uint8_t S2LP::S2LPCsmaGetBuPrescaler(void)
401 | {
402 | uint8_t tmp;
403 |
404 | g_xStatus = S2LPSpiReadRegisters(CSMA_CONF1_ADDR, 1, &tmp);
405 |
406 | return (tmp >> 2);
407 | }
408 |
409 |
410 | /**
411 | * @brief Set the CCA period.
412 | * @param xMultiplierTbit value of CCA period to store.
413 | * This parameter can be a value of @ref CcaPeriod.
414 | * @retval None.
415 | */
416 | void S2LP::S2LPCsmaSetCcaPeriod(SCsmaPeriod xMultiplierTbit)
417 | {
418 | uint8_t tmp;
419 | s_assert_param(IS_CCA_PERIOD(xMultiplierTbit));
420 |
421 | S2LPSpiReadRegisters(CSMA_CONF1_ADDR, 1, &tmp);
422 |
423 | tmp &= ~CCA_PERIOD_REGMASK;
424 | tmp |= xMultiplierTbit;
425 |
426 | g_xStatus = S2LPSpiWriteRegisters(CSMA_CONF1_ADDR, 1, &tmp);
427 |
428 | }
429 |
430 |
431 | /**
432 | * @brief Return the CCA period.
433 | * @param None.
434 | * @retval CcaPeriod CCA period.
435 | */
436 | uint8_t S2LP::S2LPCsmaGetCcaPeriod(void)
437 | {
438 | uint8_t tmp;
439 |
440 | g_xStatus = S2LPSpiReadRegisters(CSMA_CONF1_ADDR, 1, &tmp);
441 |
442 | return (SCsmaPeriod)(tmp & CCA_PERIOD_REGMASK);
443 | }
444 |
445 |
446 | /**
447 | * @brief Set the CCA length.
448 | * @param xCcaLength the CCA length (a value between 1 and 15 that multiplies the CCA period).
449 | * This parameter can be any value of @ref CsmaLength.
450 | * @retval None.
451 | */
452 | void S2LP::S2LPCsmaSetCcaLength(uint8_t xCcaLength)
453 | {
454 | uint8_t tmp;
455 | s_assert_param(IS_CSMA_LENGTH(xCcaLength));
456 |
457 | S2LPSpiReadRegisters(CSMA_CONF0_ADDR, 1, &tmp);
458 |
459 | tmp &= ~CCA_LEN_REGMASK;
460 | tmp |= (xCcaLength<<4);
461 |
462 | g_xStatus = S2LPSpiWriteRegisters(CSMA_CONF0_ADDR, 1, &tmp);
463 |
464 | }
465 |
466 |
467 | /**
468 | * @brief Return the CCA length.
469 | * @param None.
470 | * @retval uint8_t CCA length.
471 | */
472 | uint8_t S2LP::S2LPCsmaGetCcaLength(void)
473 | {
474 | uint8_t tmp;
475 |
476 | g_xStatus = S2LPSpiReadRegisters(CSMA_CONF0_ADDR, 1, &tmp);
477 |
478 | return (tmp >> 4);
479 | }
480 |
481 |
482 | /**
483 | * @brief Set the max number of back-off. If reached S2LP stops the transmission.
484 | * @param cMaxNb the max number of back-off.
485 | * This parameter is an uint8_t.
486 | * @retval None.
487 | */
488 | void S2LP::S2LPCsmaSetMaxNumberBackoff(uint8_t cMaxNb)
489 | {
490 | uint8_t tmp;
491 | s_assert_param(IS_CMAX_NB(cMaxNb));
492 |
493 | S2LPSpiReadRegisters(CSMA_CONF0_ADDR, 1, &tmp);
494 |
495 | tmp &= ~NBACKOFF_MAX_REGMASK;
496 | tmp |= cMaxNb;
497 |
498 | g_xStatus = S2LPSpiWriteRegisters(CSMA_CONF0_ADDR, 1, &tmp);
499 | }
500 |
501 | /**
502 | * @brief Return the max number of back-off.
503 | * @param None.
504 | * @retval uint8_t Max number of back-off.
505 | */
506 | uint8_t S2LP::S2LPCsmaGetMaxNumberBackoff(void)
507 | {
508 | uint8_t tmp;
509 |
510 | g_xStatus = S2LPSpiReadRegisters(CSMA_CONF0_ADDR, 1, &tmp);
511 |
512 | return (tmp & NBACKOFF_MAX_REGMASK);
513 |
514 | }
515 |
516 |
517 | /**
518 | *@}
519 | */
520 |
521 | /**
522 | *@}
523 | */
524 |
525 |
526 | /**
527 | *@}
528 | */
529 |
530 |
531 |
532 | /******************* (C) COPYRIGHT 2019 STMicroelectronics *****END OF FILE****/
533 |
--------------------------------------------------------------------------------
/src/S2LP_Csma.h:
--------------------------------------------------------------------------------
1 | /**
2 | * @file S2LP_Csma.h
3 | * @author ST Microelectronics
4 | * @version 1.3.0
5 | * @date June, 2019
6 | * @brief Configuration and management of S2-LP CSMA.
7 | * @details
8 | *
9 | * The S2LP CSMA feature, when configured and enabled, is transparent
10 | * for the user. It means the user has only to call the @ref S2LPCsmaInit()
11 | * function on a filled structure and then enable the CSMA policy using the @ref S2LPCsma()
12 | * function.
13 | *
14 | * Example:
15 | * @code
16 | *
17 | * CsmaInit csmaInit={
18 | * S_DISABLE, // persistent mode
19 | * TBIT_TIME_64, // Tbit time
20 | * TCCA_TIME_3, // Tcca time
21 | * 5, // max number of backoffs
22 | * 0xFA21, // BU counter seed
23 | * 32 // CU prescaler
24 | * };
25 | *
26 | * ...
27 | *
28 | * S2LPCsmaInit(&csmaInit);
29 | * S2LPCsma(S_ENABLE);
30 | *
31 | *
32 | * @endcode
33 | *
34 | * @note The CS status depends of the RSSI threshold set. Please see the S2LP_Qi
35 | * module for details.
36 | *
37 | * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
38 | * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
39 | * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
40 | * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
41 | * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
42 | * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
43 | *
44 | * THIS SOURCE CODE IS PROTECTED BY A LICENSE.
45 | * FOR MORE INFORMATION PLEASE CAREFULLY READ THE LICENSE AGREEMENT FILE LOCATED
46 | * IN THE ROOT DIRECTORY OF THIS FIRMWARE PACKAGE.
47 | *
48 | * © COPYRIGHT 2019 STMicroelectronics
49 | */
50 |
51 |
52 | /* Define to prevent recursive inclusion -------------------------------------*/
53 | #ifndef __S2LP_CSMA_H
54 | #define __S2LP_CSMA_H
55 |
56 |
57 | /* Includes ------------------------------------------------------------------*/
58 | #include "S2LP_Types.h"
59 | #include "S2LP_Regs.h"
60 |
61 | #ifdef __cplusplus
62 | extern "C" {
63 | #endif
64 |
65 |
66 | /**
67 | * @addtogroup S2LP_Libraries
68 | * @{
69 | */
70 |
71 |
72 | /**
73 | * @defgroup S2LP_Csma CSMA
74 | * @brief Configuration and management of S2LP CSMA.
75 | * @details See the file @ref S2LP_Csma.h for more details.
76 | * @{
77 | */
78 |
79 | /**
80 | * @defgroup Csma_Exported_Types CSMA Exported Types
81 | * @{
82 | */
83 |
84 |
85 | /**
86 | * @brief Multiplier for Tcca time enumeration (Tcca = Multiplier*Tbit).
87 | */
88 |
89 | typedef enum {
90 | CSMA_PERIOD_64TBIT, /*!< CSMA/CA: Sets CCA period to 64*TBIT */
91 | CSMA_PERIOD_128TBIT, /*!< CSMA/CA: Sets CCA period to 128*TBIT */
92 | CSMA_PERIOD_256TBIT, /*!< CSMA/CA: Sets CCA period to 256*TBIT */
93 | CSMA_PERIOD_512TBIT /*!< CSMA/CA: Sets CCA period to 512*TBIT */
94 | }SCsmaPeriod;
95 |
96 |
97 | /**
98 | * @brief S2LP CSMA Init structure definition
99 | */
100 | typedef struct {
101 | SFunctionalState xCsmaPersistentMode; /*!< Enable the CSMA persistent mode */
102 | SCsmaPeriod xMultiplierTbit; /*!< Set the Tbit multiplier to obtain the Tcca. @ref CcaPeriod */
103 | uint8_t xCcaLength; /*!< Set the Tcca multiplier to determinate the Tlisten. From 0 to 15. */
104 | uint8_t cMaxNb; /*!< Specifies the max number of backoff cycles. From 0 to 7. */
105 | uint16_t nBuCounterSeed; /*!< Specifies the BU counter seed. */
106 | uint8_t cBuPrescaler; /*!< Specifies the BU prescaler. From 0 to 63. */
107 | } SCsmaInit;
108 |
109 |
110 | /**
111 | *@}
112 | */
113 |
114 |
115 | /**
116 | * @defgroup Csma_Exported_Constants CSMA Exported Constants
117 | * @{
118 | */
119 |
120 | /**
121 | * @defgroup Csma_Parameters CSMA Parameters
122 | * @{
123 | */
124 |
125 |
126 | /**
127 | *@}
128 | */
129 |
130 | /**
131 | *@}
132 | */
133 |
134 |
135 | /**
136 | * @defgroup Csma_Exported_Macros CSMA Exported Macros
137 | * @{
138 | */
139 |
140 |
141 | /**
142 | *@}
143 | */
144 |
145 |
146 | /**
147 | *@}
148 | */
149 |
150 |
151 | /**
152 | *@}
153 | */
154 |
155 | #ifdef __cplusplus
156 | }
157 | #endif
158 |
159 | #endif
160 |
161 | /******************* (C) COPYRIGHT 2019 STMicroelectronics *****END OF FILE****/
162 |
--------------------------------------------------------------------------------
/src/S2LP_Fifo.cpp:
--------------------------------------------------------------------------------
1 | /**
2 | * @file S2LP_Fifo.c
3 | * @author ST Microelectronics
4 | * @version 1.3.0
5 | * @date June, 2019
6 | * @brief Configuration and management of S2-LP Fifo.
7 | * @details
8 | *
9 | * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
10 | * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
11 | * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
12 | * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
13 | * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
14 | * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
15 | *
16 | * THIS SOURCE CODE IS PROTECTED BY A LICENSE.
17 | * FOR MORE INFORMATION PLEASE CAREFULLY READ THE LICENSE AGREEMENT FILE LOCATED
18 | * IN THE ROOT DIRECTORY OF THIS FIRMWARE PACKAGE.
19 | *
20 | * © COPYRIGHT 2019 STMicroelectronics
21 | */
22 |
23 |
24 | /* Includes ------------------------------------------------------------------*/
25 | #include "S2LP.h"
26 |
27 |
28 | /**
29 | * @addtogroup S2LP_Libraries
30 | * @{
31 | */
32 |
33 |
34 | /**
35 | * @addtogroup S2LP_Fifo
36 | * @{
37 | */
38 |
39 |
40 | /**
41 | * @defgroup Fifo_Private_TypesDefinitions FIFO Private Types Definitions
42 | * @{
43 | */
44 |
45 | /**
46 | *@}
47 | */
48 |
49 |
50 | /**
51 | * @defgroup Fifo_Private_Defines FIFO Private Defines
52 | * @{
53 | */
54 |
55 | /**
56 | *@}
57 | */
58 |
59 |
60 | /**
61 | * @defgroup Fifo_Private_Macros FIFO Private Macros
62 | * @{
63 | */
64 | #define IS_FIFO_THR(VAL) (VAL<=128)
65 |
66 | /**
67 | *@}
68 | */
69 |
70 |
71 | /**
72 | * @defgroup Fifo_Private_Variables FIFO Private Variables
73 | * @{
74 | */
75 |
76 | /**
77 | *@}
78 | */
79 |
80 |
81 | /**
82 | * @defgroup Fifo_Private_FunctionPrototypes FIFO Private Function Prototypes
83 | * @{
84 | */
85 |
86 | /**
87 | *@}
88 | */
89 |
90 |
91 | /**
92 | * @defgroup Fifo_Private_Functions FIFO Private Functions
93 | * @{
94 | */
95 |
96 | /**
97 | * @brief Return the number of elements in the Rx FIFO.
98 | * @param None.
99 | * @retval uint8_t Number of elements in the Rx FIFO.
100 | */
101 | uint8_t S2LP::S2LPFifoReadNumberBytesRxFifo(void)
102 | {
103 | uint8_t tmp;
104 | g_xStatus = S2LPSpiReadRegisters(RX_FIFO_STATUS_ADDR, 1, &tmp);
105 | return tmp;
106 |
107 | }
108 |
109 |
110 | /**
111 | * @brief Return the number of elements in the Tx FIFO.
112 | * @param None.
113 | * @retval uint8_t Number of elements in the Tx FIFO.
114 | */
115 | uint8_t S2LP::S2LPFifoReadNumberBytesTxFifo(void)
116 | {
117 | uint8_t tmp;
118 | g_xStatus = S2LPSpiReadRegisters(TX_FIFO_STATUS_ADDR, 1, &tmp);
119 | return tmp;
120 |
121 | }
122 |
123 |
124 | /**
125 | * @brief Set the almost full threshold for the Rx FIFO. When the number of elements in RX FIFO reaches this value an interrupt can be generated to the MCU.
126 | * @note The almost full threshold is encountered from the top of the FIFO. For example, if it is set to 7 the almost
127 | * full FIFO irq will be raised when the number of elements is equals to 128-7 = 121.
128 | * @param cThrRxFifo almost full threshold.
129 | * This parameter is an uint8_t.
130 | * @retval None.
131 | */
132 | void S2LP::S2LPFifoSetAlmostFullThresholdRx(uint8_t cThrRxFifo)
133 | {
134 | uint8_t tmp;
135 |
136 | s_assert_param(IS_FIFO_THR(cThrRxFifo));
137 |
138 | S2LPSpiReadRegisters(FIFO_CONFIG3_ADDR, 1, &tmp);
139 |
140 | tmp &= ~RX_AFTHR_REGMASK;
141 | tmp |= cThrRxFifo;
142 |
143 | g_xStatus = S2LPSpiWriteRegisters(FIFO_CONFIG3_ADDR, 1, &tmp);
144 |
145 | }
146 |
147 |
148 | /**
149 | * @brief Return the almost full threshold for RX FIFO.
150 | * @note The almost full threshold is encountered from the top of the FIFO. For example, if it is 7 the almost
151 | * full FIFO irq will be raised when the number of elements is equals to 128-7 = 121.
152 | * @param None.
153 | * @retval uint8_t Almost full threshold for Rx FIFO.
154 | */
155 | uint8_t S2LP::S2LPFifoGetAlmostFullThresholdRx(void)
156 | {
157 | uint8_t tmp;
158 |
159 | g_xStatus = S2LPSpiReadRegisters(FIFO_CONFIG3_ADDR, 1, &tmp);
160 |
161 | return (tmp & RX_AFTHR_REGMASK);
162 |
163 | }
164 |
165 |
166 | /**
167 | * @brief Set the almost empty threshold for the Rx FIFO. When the number of elements in RX FIFO reaches this value an interrupt can be generated to the MCU.
168 | * @param cThrRxFifo almost empty threshold.
169 | * This parameter is an uint8_t.
170 | * @retval None.
171 | */
172 | void S2LP::S2LPFifoSetAlmostEmptyThresholdRx(uint8_t cThrRxFifo)
173 | {
174 | uint8_t tmp;
175 |
176 | s_assert_param(IS_FIFO_THR(cThrRxFifo));
177 |
178 | S2LPSpiReadRegisters(FIFO_CONFIG2_ADDR, 1, &tmp);
179 |
180 | tmp &= ~RX_AETHR_REGMASK;
181 | tmp |= cThrRxFifo;
182 |
183 | g_xStatus = S2LPSpiWriteRegisters(FIFO_CONFIG2_ADDR, 1, &tmp);
184 |
185 | }
186 |
187 |
188 | /**
189 | * @brief Return the almost empty threshold for Rx FIFO.
190 | * @param None.
191 | * @retval uint8_t Almost empty threshold for Rx FIFO.
192 | */
193 | uint8_t S2LP::S2LPFifoGetAlmostEmptyThresholdRx(void)
194 | {
195 | uint8_t tmp;
196 |
197 | g_xStatus = S2LPSpiReadRegisters(FIFO_CONFIG2_ADDR, 1, &tmp);
198 |
199 | return (tmp & RX_AETHR_REGMASK);
200 |
201 | }
202 |
203 |
204 | /**
205 | * @brief Set the almost full threshold for the Tx FIFO. When the number of elements in TX FIFO reaches this value an interrupt can be generated to the MCU.
206 | * @note The almost full threshold is encountered from the top of the FIFO. For example, if it is set to 7 the almost
207 | * full FIFO irq will be raised when the number of elements is equals to 128-7 = 121.
208 | * @param cThrTxFifo almost full threshold.
209 | * This parameter is an uint8_t.
210 | * @retval None.
211 | */
212 | void S2LP::S2LPFifoSetAlmostFullThresholdTx(uint8_t cThrTxFifo)
213 | {
214 | uint8_t tmp;
215 |
216 | s_assert_param(IS_FIFO_THR(cThrTxFifo));
217 |
218 | S2LPSpiReadRegisters(FIFO_CONFIG1_ADDR, 1, &tmp);
219 |
220 | tmp &= ~TX_AFTHR_REGMASK;
221 | tmp |= cThrTxFifo;
222 |
223 | g_xStatus = S2LPSpiWriteRegisters(FIFO_CONFIG1_ADDR, 1, &tmp);
224 |
225 | }
226 |
227 |
228 | /**
229 | * @brief Return the almost full threshold for Tx FIFO.
230 | * @note The almost full threshold is encountered from the top of the FIFO. For example, if it is set to 7 the almost
231 | * full FIFO irq will be raised when the number of elements is equals to 128-7 = 121.
232 | * @param None.
233 | * @retval uint8_t Almost full threshold for Tx FIFO.
234 | */
235 | uint8_t S2LP::S2LPFifoGetAlmostFullThresholdTx(void)
236 | {
237 | uint8_t tmp;
238 |
239 | g_xStatus = S2LPSpiReadRegisters(FIFO_CONFIG1_ADDR, 1, &tmp);
240 |
241 | return (tmp & TX_AFTHR_REGMASK);
242 |
243 | }
244 |
245 |
246 | /**
247 | * @brief Set the almost empty threshold for the Tx FIFO. When the number of elements in Tx FIFO reaches this value an interrupt can can be generated to the MCU.
248 | * @param cThrTxFifo: almost empty threshold.
249 | * This parameter is an uint8_t.
250 | * @retval None.
251 | */
252 | void S2LP::S2LPFifoSetAlmostEmptyThresholdTx(uint8_t cThrTxFifo)
253 | {
254 | uint8_t tmp;
255 |
256 | s_assert_param(IS_FIFO_THR(cThrTxFifo));
257 |
258 | S2LPSpiReadRegisters(FIFO_CONFIG0_ADDR, 1, &tmp);
259 |
260 | /* Build the register value */
261 | tmp &= ~TX_AETHR_REGMASK;
262 | tmp |= cThrTxFifo;
263 |
264 | /* Writes the Almost Empty threshold for Tx in the corresponding register */
265 | g_xStatus = S2LPSpiWriteRegisters(FIFO_CONFIG0_ADDR, 1, &tmp);
266 |
267 | }
268 |
269 |
270 | /**
271 | * @brief Return the almost empty threshold for Tx FIFO.
272 | * @param None.
273 | * @retval uint8_t Almost empty threshold for Tx FIFO.
274 | */
275 | uint8_t S2LP::S2LPFifoGetAlmostEmptyThresholdTx(void)
276 | {
277 | uint8_t tmp;
278 |
279 | g_xStatus = S2LPSpiReadRegisters(FIFO_CONFIG0_ADDR, 1, &tmp);
280 |
281 | return (tmp & TX_AETHR_REGMASK);
282 |
283 | }
284 |
285 |
286 | /**
287 | * @brief Enable the Mux for the Rx FIFO IRQ. To be enabled when RX FIFO THRESHOLD is used.
288 | * @param xNewState.
289 | * @retval None.
290 | */
291 | void S2LP::S2LPFifoMuxRxFifoIrqEnable(SFunctionalState xNewState)
292 | {
293 | /* default TX selection*/
294 | uint8_t tmp;
295 | s_assert_param(IS_SFUNCTIONAL_STATE(xNewState));
296 |
297 | S2LPSpiReadRegisters(PROTOCOL2_ADDR, 1, &tmp);
298 |
299 | if(xNewState == S_ENABLE) {
300 | tmp |= FIFO_GPIO_OUT_MUX_SEL_REGMASK;
301 | } else {
302 | tmp &= ~FIFO_GPIO_OUT_MUX_SEL_REGMASK;
303 | }
304 | g_xStatus = S2LPSpiWriteRegisters(PROTOCOL2_ADDR, 1, &tmp);
305 | }
306 |
307 |
308 | /**
309 | *@}
310 | */
311 |
312 | /**
313 | *@}
314 | */
315 |
316 |
317 | /**
318 | *@}
319 | */
320 |
321 |
322 |
323 | /******************* (C) COPYRIGHT 2019 STMicroelectronics *****END OF FILE****/
324 |
--------------------------------------------------------------------------------
/src/S2LP_Fifo.h:
--------------------------------------------------------------------------------
1 | /**
2 | * @file S2LP_Fifo.h
3 | * @author ST Microelectronics
4 | * @version 1.3.0
5 | * @date June, 2019
6 | * @brief Configuration and management of S2-LP Fifo.
7 | * @details
8 | *
9 | * This module allows the user to manage the linear FIFO. The functions exported
10 | * here can be used to set the thresholds for the FIFO almost full / empty alarm
11 | * interrupts or to get the total number of elements inside the FIFO.
12 | *
13 | * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
14 | * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
15 | * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
16 | * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
17 | * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
18 | * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
19 | *
20 | * THIS SOURCE CODE IS PROTECTED BY A LICENSE.
21 | * FOR MORE INFORMATION PLEASE CAREFULLY READ THE LICENSE AGREEMENT FILE LOCATED
22 | * IN THE ROOT DIRECTORY OF THIS FIRMWARE PACKAGE.
23 | *
24 | * © COPYRIGHT 2019 STMicroelectronics
25 | */
26 |
27 |
28 | /* Define to prevent recursive inclusion -------------------------------------*/
29 | #ifndef __S2LP_FIFO_H
30 | #define __S2LP_FIFO_H
31 |
32 |
33 | /* Includes ------------------------------------------------------------------*/
34 | #include "S2LP_Regs.h"
35 | #include "S2LP_Types.h"
36 |
37 |
38 | #ifdef __cplusplus
39 | extern "C" {
40 | #endif
41 |
42 |
43 | /**
44 | * @addtogroup S2LP_Libraries
45 | * @{
46 | */
47 |
48 |
49 | /**
50 | * @defgroup S2LP_Fifo FIFO
51 | * @brief Configuration and management of S2LP FIFO.
52 | * @details See the file @ref S2LP_Fifo.h for more details.
53 | * @{
54 | */
55 |
56 | /**
57 | * @defgroup Fifo_Exported_Types FIFO Exported Types
58 | * @{
59 | */
60 |
61 |
62 | /**
63 | * @}
64 | */
65 |
66 |
67 | /**
68 | * @defgroup Fifo_Exported_Constants FIFO Exported Constants
69 | * @{
70 | */
71 |
72 | /**
73 | * @}
74 | */
75 |
76 |
77 | /**
78 | * @defgroup Fifo_Exported_Macros FIFO Exported Macros
79 | * @{
80 | */
81 |
82 |
83 | /**
84 | * @}
85 | */
86 |
87 |
88 | /**
89 | * @}
90 | */
91 |
92 |
93 | /**
94 | * @}
95 | */
96 |
97 | #ifdef __cplusplus
98 | }
99 | #endif
100 |
101 | #endif
102 |
103 | /******************* (C) COPYRIGHT 2019 STMicroelectronics *****END OF FILE****/
104 |
--------------------------------------------------------------------------------
/src/S2LP_General.cpp:
--------------------------------------------------------------------------------
1 | /**
2 | * @file S2LP_General.c
3 | * @author ST Microelectronics
4 | * @version 1.3.0
5 | * @date June, 2019
6 | * @brief Configuration and management of S2-LP General functionalities.
7 | * @details
8 | *
9 | * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
10 | * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
11 | * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
12 | * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
13 | * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
14 | * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
15 | *
16 | * THIS SOURCE CODE IS PROTECTED BY A LICENSE.
17 | * FOR MORE INFORMATION PLEASE CAREFULLY READ THE LICENSE AGREEMENT FILE LOCATED
18 | * IN THE ROOT DIRECTORY OF THIS FIRMWARE PACKAGE.
19 | *
20 | * © COPYRIGHT 2019 STMicroelectronics
21 | */
22 |
23 | /* Includes ------------------------------------------------------------------*/
24 | #include "S2LP.h"
25 |
26 |
27 | /**
28 | * @addtogroup S2LP_Libraries
29 | * @{
30 | */
31 |
32 |
33 | /**
34 | * @addtogroup S2LP_General
35 | * @{
36 | */
37 |
38 |
39 | /**
40 | * @defgroup General_Private_TypesDefinitions General Private Types Definitions
41 | * @{
42 | */
43 |
44 | /**
45 | *@}
46 | */
47 |
48 |
49 | /**
50 | * @defgroup General_Private_Defines General Private Defines
51 | * @{
52 | */
53 |
54 | /**
55 | *@}
56 | */
57 |
58 |
59 | /**
60 | * @defgroup General_Private_Macros General Private Macros
61 | * @{
62 | */
63 |
64 | #define IS_MODE_EXT(MODE) (MODE == MODE_EXT_XO || \
65 | MODE == MODE_EXT_XIN)
66 | /**
67 | *@}
68 | */
69 |
70 |
71 | /**
72 | * @defgroup General_Private_Variables General Private Variables
73 | * @{
74 | */
75 |
76 | /**
77 | *@}
78 | */
79 |
80 |
81 | /**
82 | * @defgroup General_Private_FunctionPrototypes General Private Function Prototypes
83 | * @{
84 | */
85 |
86 | /**
87 | *@}
88 | */
89 |
90 |
91 | /**
92 | * @defgroup General_Private_Functions General Private Functions
93 | * @{
94 | */
95 |
96 |
97 | /**
98 | * @brief Set External Reference.
99 | * @param xExtMode new state for the external reference.
100 | * This parameter can be: MODE_EXT_XO or MODE_EXT_XIN.
101 | * @retval None.
102 | */
103 | void S2LP::S2LPGeneralSetExtRef(ModeExtRef xExtMode)
104 | {
105 | uint8_t tmp;
106 | s_assert_param(IS_MODE_EXT(xExtMode));
107 |
108 | S2LPSpiReadRegisters(XO_RCO_CONF0_ADDR, 1, &tmp);
109 | if(xExtMode == MODE_EXT_XO) {
110 | tmp &= ~EXT_REF_REGMASK;
111 | }
112 | else {
113 | tmp |= EXT_REF_REGMASK;
114 | }
115 | g_xStatus = S2LPSpiWriteRegisters(XO_RCO_CONF0_ADDR, 1, &tmp);
116 |
117 | }
118 |
119 |
120 | /**
121 | * @brief Return External Reference.
122 | * @param None.
123 | * @retval ModeExtRef Settled external reference.
124 | * This parameter can be: MODE_EXT_XO or MODE_EXT_XIN.
125 | */
126 | ModeExtRef S2LP::S2LPGeneralGetExtRef(void)
127 | {
128 | uint8_t tmp;
129 | g_xStatus = S2LPSpiReadRegisters(XO_RCO_CONF0_ADDR, 1, &tmp);
130 | return (ModeExtRef)(tmp & EXT_REF_REGMASK);
131 | }
132 |
133 |
134 | /**
135 | * @brief Return device part number.
136 | * @param None.
137 | * @retval Device part number.
138 | */
139 | uint8_t S2LP::S2LPGeneralGetDevicePN(void)
140 | {
141 | uint8_t tmp;
142 | g_xStatus = S2LPSpiReadRegisters(DEVICE_INFO1_ADDR, 1, &tmp);
143 | return tmp;
144 | }
145 |
146 | /**
147 | * @brief Return S2LP version.
148 | * @param None.
149 | * @retval S2LP version.
150 | */
151 | uint8_t S2LP::S2LPGeneralGetVersion(void)
152 | {
153 | uint8_t tmp;
154 | S2LPSpiReadRegisters(DEVICE_INFO0_ADDR, 1, &tmp);
155 | return tmp;
156 | }
157 |
158 |
159 | /**
160 | * @brief Disable or enable the internal SMPS.
161 | * @param xNewState if this value is S_DISABLE the external SMPS is enabled and a vlotage must be provided from outside.
162 | * In this case the internal SMPS will be disabled.
163 | * @retval None.
164 | */
165 | void S2LP::S2LPRadioSetExternalSmpsMode(SFunctionalState xNewState)
166 | {
167 | uint8_t tmp;
168 | s_assert_param(IS_SFUNCTIONAL_STATE(xNewState));
169 |
170 | S2LPSpiReadRegisters(PM_CONF4_ADDR, 1, &tmp);
171 |
172 | if(xNewState == S_ENABLE) {
173 | tmp |= EXT_SMPS_REGMASK;
174 | } else {
175 | tmp &= ~EXT_SMPS_REGMASK;
176 | }
177 | g_xStatus = S2LPSpiWriteRegisters(PM_CONF4_ADDR, 1, &tmp);
178 | }
179 |
180 | /**
181 | *@}
182 | */
183 |
184 |
185 | /**
186 | *@}
187 | */
188 |
189 |
190 | /**
191 | *@}
192 | */
193 |
194 |
195 | /******************* (C) COPYRIGHT 2019 STMicroelectronics *****END OF FILE****/
196 |
--------------------------------------------------------------------------------
/src/S2LP_General.h:
--------------------------------------------------------------------------------
1 | /**
2 | * @file S2LP_General.h
3 | * @author ST Microelectronics
4 | * @version 1.3.0
5 | * @date June, 2019
6 | * @brief Configuration and management of S2-LP General functionalities.
7 | * @details
8 | *
9 | * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
10 | * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
11 | * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
12 | * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
13 | * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
14 | * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
15 | *
16 | * THIS SOURCE CODE IS PROTECTED BY A LICENSE.
17 | * FOR MORE INFORMATION PLEASE CAREFULLY READ THE LICENSE AGREEMENT FILE LOCATED
18 | * IN THE ROOT DIRECTORY OF THIS FIRMWARE PACKAGE.
19 | *
20 | * © COPYRIGHT 2019 STMicroelectronics
21 | */
22 |
23 |
24 | /* Define to prevent recursive inclusion -------------------------------------*/
25 | #ifndef __S2LP_GENERAL_H
26 | #define __S2LP_GENERAL_H
27 |
28 |
29 | /* Includes ------------------------------------------------------------------*/
30 |
31 | #include "S2LP_Regs.h"
32 | #include "S2LP_Types.h"
33 |
34 |
35 |
36 | #ifdef __cplusplus
37 | extern "C" {
38 | #endif
39 |
40 | /**
41 | * @addtogroup S2LP_Libraries
42 | * @{
43 | */
44 |
45 |
46 | /**
47 | * @defgroup S2LP_General General
48 | * @brief Configuration and management of S2LP General functionalities.
49 | * @details See the file @ref S2LP_General.h for more details.
50 | * @{
51 | */
52 |
53 | /**
54 | * @defgroup General_Exported_Types General Exported Types
55 | * @{
56 | */
57 |
58 |
59 | /**
60 | * @brief S2LP version type enumeration
61 | */
62 |
63 | typedef enum {
64 | MODE_EXT_XO = 0,
65 | MODE_EXT_XIN = 0x80,
66 | } ModeExtRef;
67 |
68 |
69 | /**
70 | * @}
71 | */
72 |
73 |
74 | /**
75 | * @defgroup General_Exported_Constants General Exported Constants
76 | * @{
77 | */
78 |
79 |
80 | /**
81 | * @}
82 | */
83 |
84 |
85 | /**
86 | * @defgroup General_Exported_Macros General Exported Macros
87 | * @{
88 | */
89 | #define S2LPGeneralLibraryVersion() "S2LP_Libraries_v.1.3.0"
90 |
91 |
92 | /**
93 | * @}
94 | */
95 |
96 |
97 | /**
98 | * @}
99 | */
100 |
101 |
102 | /**
103 | * @}
104 | */
105 |
106 |
107 | #ifdef __cplusplus
108 | }
109 | #endif
110 |
111 | #endif
112 |
113 | /******************* (C) COPYRIGHT 2019 STMicroelectronics *****END OF FILE****/
114 |
--------------------------------------------------------------------------------
/src/S2LP_Gpio.cpp:
--------------------------------------------------------------------------------
1 | /**
2 | * @file S2LP_Gpio.c
3 | * @author ST Microelectronics
4 | * @version 1.3.0
5 | * @date June, 2019
6 | * @brief This file provides all the low level API to manage S2-LP GPIO.
7 | * @details
8 | *
9 | * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
10 | * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
11 | * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
12 | * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
13 | * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
14 | * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
15 | *
16 | * THIS SOURCE CODE IS PROTECTED BY A LICENSE.
17 | * FOR MORE INFORMATION PLEASE CAREFULLY READ THE LICENSE AGREEMENT FILE LOCATED
18 | * IN THE ROOT DIRECTORY OF THIS FIRMWARE PACKAGE.
19 | *
20 | * © COPYRIGHT 2019 STMicroelectronics
21 | *
22 | */
23 |
24 | /* Includes ------------------------------------------------------------------*/
25 | #include "S2LP.h"
26 |
27 |
28 | /** @addtogroup S2LP_Libraries
29 | * @{
30 | */
31 |
32 |
33 | /** @addtogroup S2LP_Gpio
34 | * @{
35 | */
36 |
37 |
38 |
39 |
40 | /** @defgroup Gpio_Private_Macros GPIO Private Macros
41 | * @{
42 | */
43 |
44 |
45 | #define IS_S2LP_GPIO(PIN) ((PIN == S2LP_GPIO_0) || \
46 | (PIN == S2LP_GPIO_1) || \
47 | (PIN == S2LP_GPIO_2) || \
48 | (PIN == S2LP_GPIO_3))
49 |
50 |
51 | #define IS_S2LP_GPIO_MODE(MODE) ((MODE == S2LP_GPIO_MODE_DIGITAL_INPUT) || \
52 | (MODE == S2LP_GPIO_MODE_DIGITAL_OUTPUT_LP) || \
53 | (MODE == S2LP_GPIO_MODE_DIGITAL_OUTPUT_HP))
54 |
55 | #define IS_S2LP_GPIO_IO(IO_SEL) ((IO_SEL == S2LP_GPIO_DIG_OUT_IRQ) || \
56 | (IO_SEL == S2LP_GPIO_DIG_OUT_POR_INV) || \
57 | (IO_SEL == S2LP_GPIO_DIG_OUT_WUT_EXP) || \
58 | (IO_SEL == S2LP_GPIO_DIG_OUT_LBD) || \
59 | (IO_SEL == S2LP_GPIO_DIG_OUT_TX_DATA) || \
60 | (IO_SEL == S2LP_GPIO_DIG_OUT_TX_STATE) || \
61 | (IO_SEL == S2LP_GPIO_DIG_OUT_TXRX_FIFO_ALMOST_EMPTY) || \
62 | (IO_SEL == S2LP_GPIO_DIG_OUT_TXRX_FIFO_ALMOST_FULL) || \
63 | (IO_SEL == S2LP_GPIO_DIG_OUT_RX_DATA) || \
64 | (IO_SEL == S2LP_GPIO_DIG_OUT_RX_CLOCK) || \
65 | (IO_SEL == S2LP_GPIO_DIG_OUT_RX_STATE) || \
66 | (IO_SEL == S2LP_GPIO_DIG_OUT_NOT_STANDBY_SLEEP) || \
67 | (IO_SEL == S2LP_GPIO_DIG_OUT_STANDBY) || \
68 | (IO_SEL == S2LP_GPIO_DIG_OUT_ANTENNA_SWITCH) || \
69 | (IO_SEL == S2LP_GPIO_DIG_OUT_VALID_PREAMBLE) || \
70 | (IO_SEL == S2LP_GPIO_DIG_OUT_SYNC_DETECTED) || \
71 | (IO_SEL == S2LP_GPIO_DIG_OUT_RSSI_THRESHOLD) || \
72 | (IO_SEL == S2LP_GPIO_DIG_OUT_MCU_CLOCK) || \
73 | (IO_SEL == S2LP_GPIO_DIG_OUT_TX_RX_MODE) || \
74 | (IO_SEL == S2LP_GPIO_DIG_OUT_VDD) || \
75 | (IO_SEL == S2LP_GPIO_DIG_OUT_GND) || \
76 | (IO_SEL == S2LP_GPIO_DIG_OUT_SMPS_EXT) ||\
77 | (IO_SEL == S2LP_GPIO_DIG_OUT_SLEEP) ||\
78 | (IO_SEL == S2LP_GPIO_DIG_OUT_READY) ||\
79 | (IO_SEL == S2LP_GPIO_DIG_OUT_LOCK) ||\
80 | (IO_SEL == S2LP_GPIO_DIG_OUT_WAIT_FOR_LOCK_SIG) ||\
81 | (IO_SEL == S2LP_GPIO_DIG_OUT_TX_DATA_OOK_SIGNAL) ||\
82 | (IO_SEL == S2LP_GPIO_DIG_OUT_WAIT_FOR_READY2_SIG) ||\
83 | (IO_SEL == S2LP_GPIO_DIG_OUT_WAIT_FOR_TIMER_FOR_PM_SET) ||\
84 | (IO_SEL == S2LP_GPIO_DIG_OUT_WAIT_VCO_CALIBRATION) ||\
85 | (IO_SEL == S2LP_GPIO_DIG_OUT_ENABLE_SYNTH_FULL_CIRCUIT) ||\
86 | (IO_SEL == S2LP_GPIO_DIG_IN_TX_COMMAND) ||\
87 | (IO_SEL == S2LP_GPIO_DIG_IN_RX_COMMAND) ||\
88 | (IO_SEL == S2LP_GPIO_DIG_IN_TX_DATA_INPUT_FOR_DIRECTRF) ||\
89 | (IO_SEL == S2LP_GPIO_DIG_IN_DATA_WAKEUP) ||\
90 | (IO_SEL == S2LP_GPIO_DIG_IN_EXT_CLOCK_AT_34_7KHZ))
91 |
92 |
93 | #define IS_S2LP_GPIO_LEVEL(LEVEL) ((LEVEL == S2LP_LOW) || \
94 | (LEVEL == S2LP_HIGH))
95 |
96 | #define IS_S2LP_CLOCK_OUTPUT_XO(RATIO) ((RATIO == XO_RATIO_1) || \
97 | (RATIO == XO_RATIO_1_2) || \
98 | (RATIO == XO_RATIO_1_4) || \
99 | (RATIO == XO_RATIO_1_8) || \
100 | (RATIO == XO_RATIO_1_16) || \
101 | (RATIO == XO_RATIO_1_32) || \
102 | (RATIO == XO_RATIO_1_64) || \
103 | (RATIO == XO_RATIO_1_128) || \
104 | (RATIO == XO_RATIO_1_256))
105 |
106 | #define IS_S2LP_CLOCK_OUTPUT_RCO(RATIO) ((RATIO == RCO_RATIO_1) || \
107 | (RATIO == RCO_RATIO_1_128))
108 |
109 |
110 | #define IS_S2LP_CLOCK_OUTPUT_EXTRA_CYCLES(CYCLES) ((CYCLES == EXTRA_CLOCK_CYCLES_0) || \
111 | (CYCLES == EXTRA_CLOCK_CYCLES_128) || \
112 | (CYCLES == EXTRA_CLOCK_CYCLES_256) || \
113 | (CYCLES == EXTRA_CLOCK_CYCLES_512))
114 |
115 |
116 | #define IS_S2LP_IRQ_LIST(VALUE) ((VALUE == RX_DATA_READY) || \
117 | (VALUE == RX_DATA_DISC) || \
118 | (VALUE == TX_DATA_SENT) || \
119 | (VALUE == MAX_RE_TX_REACH) || \
120 | (VALUE == CRC_ERROR) || \
121 | (VALUE == TX_FIFO_ERROR) || \
122 | (VALUE == RX_FIFO_ERROR) || \
123 | (VALUE == TX_FIFO_ALMOST_FULL) || \
124 | (VALUE == TX_FIFO_ALMOST_EMPTY) || \
125 | (VALUE == RX_FIFO_ALMOST_FULL) || \
126 | (VALUE == RX_FIFO_ALMOST_EMPTY) || \
127 | (VALUE == MAX_BO_CCA_REACH) || \
128 | (VALUE == VALID_PREAMBLE) || \
129 | (VALUE == VALID_SYNC) || \
130 | (VALUE == RSSI_ABOVE_TH) || \
131 | (VALUE == WKUP_TOUT_LDC) || \
132 | (VALUE == READY) || \
133 | (VALUE == STANDBY_DELAYED) || \
134 | (VALUE == LOW_BATT_LVL) || \
135 | (VALUE == POR) || \
136 | (VALUE == BOR) || \
137 | (VALUE == LOCK) || \
138 | (VALUE == VCO_CALIBRATION_END) || \
139 | (VALUE == PA_CALIBRATION_END) || \
140 | (VALUE == PM_COUNT_EXPIRED) || \
141 | (VALUE == XO_COUNT_EXPIRED) || \
142 | (VALUE == TX_START_TIME) || \
143 | (VALUE == RX_START_TIME) || \
144 | (VALUE == RX_TIMEOUT) || \
145 | (VALUE == RX_SNIFF_TIMEOUT) || \
146 | (VALUE == ALL_IRQ ))
147 |
148 |
149 |
150 | /**
151 | * @}
152 | */
153 |
154 |
155 |
156 | /** @defgroup Gpio_Private_Functions GPIO Private Functions
157 | * @{
158 | */
159 |
160 | /**
161 | * @brief Initialize the S2LP GPIOx according to the specified
162 | * parameters in the pxGpioInitStruct.
163 | * @param pxGpioInitStruct pointer to a SGpioInit structure that
164 | * contains the configuration information for the specified S2LP GPIO.
165 | * @retval None.
166 | */
167 | void S2LP::S2LPGpioInit(SGpioInit* pxGpioInitStruct)
168 | {
169 | uint8_t tmp;
170 |
171 | s_assert_param(IS_S2LP_GPIO(pxGpioInitStruct->xS2LPGpioPin));
172 | s_assert_param(IS_S2LP_GPIO_MODE(pxGpioInitStruct->xS2LPGpioMode));
173 | s_assert_param(IS_S2LP_GPIO_IO(pxGpioInitStruct->xS2LPGpioIO));
174 |
175 | tmp = ((uint8_t)(pxGpioInitStruct->xS2LPGpioMode) | (uint8_t)(pxGpioInitStruct->xS2LPGpioIO));
176 | g_xStatus = S2LPSpiWriteRegisters(pxGpioInitStruct->xS2LPGpioPin, 1, &tmp);
177 |
178 | }
179 |
180 |
181 |
182 | /**
183 | * @brief Force S2LP GPIO_x configured as digital output, to VDD or GND.
184 | * @param xGpioX Specifies the GPIO to be configured.
185 | * This parameter can be one of following parameters:
186 | * @arg S2LP_GPIO_0: S2LP GPIO_0
187 | * @arg S2LP_GPIO_1: S2LP GPIO_1
188 | * @arg S2LP_GPIO_2: S2LP GPIO_2
189 | * @arg S2LP_GPIO_3: S2LP GPIO_3
190 | * @param xLevel Specifies the level.
191 | * This parameter can be: S2LP_HIGH or S2LP_LOW.
192 | * @retval None.
193 | */
194 | void S2LP::S2LPGpioSetLevel(S2LPGpioPin xGpioX, OutputLevel xLevel)
195 | {
196 | uint8_t tmp;
197 |
198 | s_assert_param(IS_S2LP_GPIO(xGpioX));
199 | s_assert_param(IS_S2LP_GPIO_LEVEL(xLevel));
200 |
201 | /* Sets the value of the S2LP GPIO register according to the specified level */
202 | if(xLevel == S2LP_HIGH) {
203 | tmp = (uint8_t)S2LP_GPIO_DIG_OUT_VDD | (uint8_t)S2LP_GPIO_MODE_DIGITAL_OUTPUT_HP;
204 | }
205 | else {
206 | tmp = (uint8_t)S2LP_GPIO_DIG_OUT_GND | (uint8_t)S2LP_GPIO_MODE_DIGITAL_OUTPUT_HP;
207 | }
208 |
209 | g_xStatus = S2LPSpiWriteRegisters(xGpioX, 1, &tmp);
210 |
211 | }
212 |
213 |
214 | /**
215 | * @brief Return output value (VDD or GND) of S2LP GPIO_x, when it is configured as digital output.
216 | * @param xGpioX Specifies the GPIO to be read.
217 | * This parameter can be one of following parameters:
218 | * @arg S2LP_GPIO_0: S2LP GPIO_0
219 | * @arg S2LP_GPIO_1: S2LP GPIO_1
220 | * @arg S2LP_GPIO_2: S2LP GPIO_2
221 | * @arg S2LP_GPIO_3: S2LP GPIO_3
222 | * @retval OutputLevel Logical level of selected GPIO configured as digital output.
223 | * This parameter can be: S2LP_HIGH or S2LP_LOW.
224 | */
225 | OutputLevel S2LP::S2LPGpioGetLevel(S2LPGpioPin xGpioX)
226 | {
227 | uint8_t tmp = 0x00;
228 |
229 | s_assert_param(IS_S2LP_GPIO(xGpioX));
230 |
231 | g_xStatus = S2LPSpiReadRegisters(xGpioX, 1, &tmp);
232 |
233 | /* Mask the GPIO_SELECT field and returns the value according */
234 | tmp &= GPIO_SELECT_REGMASK;
235 | if(tmp == S2LP_GPIO_DIG_OUT_VDD) {
236 | return S2LP_HIGH;
237 | }
238 | else {
239 | return S2LP_LOW;
240 | }
241 |
242 | }
243 |
244 |
245 | /**
246 | * @brief Deinit the S2LPIrqs structure setting all the bitfield to 0.
247 | * Moreover, it sets the IRQ mask registers to 0x00000000, disabling all IRQs.
248 | * @param pxIrqInit pointer to a variable of type @ref S2LPIrqs, in which all the
249 | * bitfields will be settled to zero.
250 | * @retval None.
251 | */
252 | void S2LP::S2LPGpioIrqDeInit(S2LPIrqs* pxIrqInit)
253 | {
254 | uint8_t tmp[4] = {0x00,0x00,0x00,0x00};
255 |
256 | if(pxIrqInit!=NULL) {
257 | memset(pxIrqInit, 0x00, sizeof(S2LPIrqs));
258 | }
259 |
260 | g_xStatus = S2LPSpiWriteRegisters(IRQ_MASK3_ADDR, 4, tmp);
261 | }
262 |
263 |
264 | /**
265 | * @brief Enable the IRQs according to the user defined pxIrqInit structure.
266 | * @param pxIrqInit pointer to a variable of type @ref S2LPIrqs, through which the
267 | * user enable specific IRQs. This parameter is a pointer to a S2LPIrqs.
268 | * For example suppose to enable only the two IRQ Low Battery Level and Tx Data Sent:
269 | * @code
270 | * S2LPIrqs myIrqInit = {0};
271 | * myIrqInit.IRQ_LOW_BATT_LVL = 1;
272 | * myIrqInit.IRQ_TX_DATA_SENT = 1;
273 | * S2LPGpioIrqInit(&myIrqInit);
274 | * @endcode
275 | * @retval None.
276 | */
277 | void S2LP::S2LPGpioIrqInit(S2LPIrqs* pxIrqInit)
278 | {
279 | uint8_t tmp[4];
280 | uint8_t* tmpPoint;
281 |
282 | tmpPoint = (uint8_t*)(pxIrqInit);
283 | for(int i=0; i<4; i++) {
284 | tmp[3-i]= tmpPoint[i];
285 | }
286 |
287 | g_xStatus = S2LPSpiWriteRegisters(IRQ_MASK3_ADDR, 4, tmp);
288 |
289 | }
290 |
291 |
292 | /**
293 | * @brief Enable or disables a specific IRQ.
294 | * @param xIrq IRQ to enable or disable.
295 | * This parameter can be any value of @ref IrqList.
296 | * @param xNewState new state for the IRQ.
297 | * This parameter can be: S_ENABLE or S_DISABLE.
298 | * @retval None.
299 | */
300 | void S2LP::S2LPGpioIrqConfig(IrqList xIrq, SFunctionalState xNewState)
301 | {
302 | uint8_t tmpBuffer[4];
303 | uint32_t tempValue = 0;
304 |
305 | s_assert_param(IS_S2LP_IRQ_LIST(xIrq));
306 | s_assert_param(IS_SFUNCTIONAL_STATE(xNewState));
307 |
308 | S2LPSpiReadRegisters(IRQ_MASK3_ADDR, 4, tmpBuffer);
309 |
310 | /* Build the IRQ mask word */
311 | for(int i=0; i<4; i++) {
312 | tempValue += ((uint32_t)tmpBuffer[i])<<(8*(3-i));
313 | }
314 |
315 | /* Rebuild the new mask according to user request */
316 | if(xNewState == S_DISABLE) {
317 | tempValue &= (~xIrq);
318 | }
319 | else {
320 | tempValue |= (xIrq);
321 | }
322 |
323 | /* Build the array of bytes to write in the IRQ_MASK registers */
324 | for(int j=0; j<4; j++) {
325 | tmpBuffer[j] = (uint8_t)(tempValue>>(8*(3-j)));
326 | }
327 |
328 | g_xStatus = S2LPSpiWriteRegisters(IRQ_MASK3_ADDR, 4, tmpBuffer);
329 |
330 | }
331 |
332 |
333 | /**
334 | * @brief Fill a pointer to a structure of S2LPIrqs type reading the IRQ_MASK registers.
335 | * @param pxIrqMask pointer to a variable of type @ref S2LPIrqs, through which the
336 | * user can read which IRQs are enabled. All the bitfields equals to zero correspond
337 | * to enabled IRQs, while all the bitfields equals to one correspond to disabled IRQs.
338 | * This parameter is a pointer to a S2LPIrqs.
339 | * For example suppose that the Power On Reset and RX Data ready are the only enabled IRQs.
340 | * @code
341 | * S2LPIrqs myIrqMask;
342 | * S2LPIrqGetStatus(&myIrqMask);
343 | * @endcode
344 | * Then
345 | * myIrqMask.IRQ_POR and myIrqMask.IRQ_RX_DATA_READY are equal to 0
346 | * while all the other bitfields are equal to one.
347 | * @retval None.
348 | */
349 | void S2LP::S2LPGpioIrqGetMask(S2LPIrqs* pxIrqMask)
350 | {
351 | uint8_t tmp[4];
352 | uint8_t* pIrqPointer = (uint8_t*)pxIrqMask;
353 |
354 | g_xStatus = S2LPSpiReadRegisters(IRQ_MASK3_ADDR, 4, tmp);
355 |
356 | for(char i=0; i<4; i++) {
357 | *pIrqPointer = tmp[3-i];
358 | pIrqPointer++;
359 | }
360 |
361 | }
362 |
363 |
364 | /**
365 | * @brief Fill a pointer to a structure of S2LPIrqs type reading the IRQ_STATUS registers.
366 | * @param pxIrqStatus pointer to a variable of type @ref S2LPIrqs, through which the
367 | * user can read the status of all the IRQs. All the bitfields equals to one correspond
368 | * to the raised interrupts. This parameter is a pointer to a S2LPIrqs.
369 | * For example suppose that the XO settling timeout is raised as well as the Sync word
370 | * detection.
371 | * @code
372 | * S2LPIrqs myIrqStatus;
373 | * S2LPGpioIrqGetStatus(&myIrqStatus);
374 | * @endcode
375 | * Then
376 | * myIrqStatus.IRQ_XO_COUNT_EXPIRED and myIrqStatus.IRQ_VALID_SYNC are equals to 1
377 | * while all the other bitfields are equals to zero.
378 | * @retval None.
379 | */
380 | void S2LP::S2LPGpioIrqGetStatus(S2LPIrqs* pxIrqStatus)
381 | {
382 | uint8_t tmp[4];
383 | uint8_t* pIrqPointer = (uint8_t*)pxIrqStatus;
384 |
385 | g_xStatus = S2LPSpiReadRegisters(IRQ_STATUS3_ADDR, 4, tmp);
386 |
387 |
388 |
389 | /* Build the IRQ Status word */
390 | for(uint8_t i=0; i<4; i++) {
391 | *pIrqPointer = tmp[3-i];
392 | pIrqPointer++;
393 | }
394 | }
395 |
396 |
397 | /**
398 | * @brief Clear the IRQ status registers.
399 | * @param None.
400 | * @retval None.
401 | */
402 | void S2LP::S2LPGpioIrqClearStatus(void)
403 | {
404 | uint8_t tmp[4];
405 | g_xStatus = S2LPSpiReadRegisters(IRQ_STATUS3_ADDR, 4, tmp);
406 |
407 | }
408 |
409 |
410 | /**
411 | * @brief Verifie if a specific IRQ has been generated.
412 | * The call resets all the IRQ status, so it can't be used in case of multiple raising interrupts.
413 | * @param xFlag IRQ flag to be checked.
414 | * This parameter can be any value of @ref IrqList.
415 | * @retval SBool S_TRUE or S_FALSE.
416 | */
417 | SBool S2LP::S2LPGpioIrqCheckFlag(IrqList xFlag)
418 | {
419 | uint8_t tmp[4];
420 | uint32_t tempValue = 0;
421 | SBool flag;
422 |
423 | s_assert_param(IS_S2LP_IRQ_LIST(xFlag));
424 |
425 | g_xStatus = S2LPSpiReadRegisters(IRQ_STATUS3_ADDR, 4, tmp);
426 | for(uint8_t i=0; i<4; i++) {
427 | tempValue += ((uint32_t)tmp[i])<<(8*(3-i));
428 | }
429 |
430 | if(tempValue & xFlag) {
431 | flag = S_TRUE;
432 | }
433 | else {
434 | flag = S_FALSE;
435 | }
436 |
437 | return flag;
438 |
439 | }
440 |
441 | /**
442 | * @}
443 | */
444 |
445 |
446 | /**
447 | * @}
448 | */
449 |
450 |
451 | /**
452 | * @}
453 | */
454 |
455 |
456 |
457 | /******************* (C) COPYRIGHT 2019 STMicroelectronics *****END OF FILE****/
458 |
--------------------------------------------------------------------------------
/src/S2LP_Gpio.h:
--------------------------------------------------------------------------------
1 | /**
2 | * @file S2LP_Gpio.h
3 | * @author ST Microelectronics
4 | * @version 1.3.0
5 | * @date June, 2019
6 | * @brief Configuration and management of S2-LP GPIO.
7 | * @details
8 | *
9 | * This module can be used to configure the S2-LP GPIO pins to perform
10 | * specific functions.
11 | * The structure @ref gpioIRQ can be used to specify these features for
12 | * one of the four S2-LP Gpio pin.
13 | * The following example shows how to configure a pin (GPIO 3) to be used as an IRQ source
14 | * for a microcontroller using the @ref S2LPGpioInit() function.
15 | *
16 | * Example:
17 | * @code
18 | *
19 | * SGpioInit gpioIRQ={
20 | * S2LP_GPIO_3,
21 | * S2LP_GPIO_MODE_DIGITAL_OUTPUT_LP,
22 | * S2LP_GPIO_DIG_OUT_IRQ
23 | * };
24 | *
25 | * ...
26 | *
27 | * S2LPGpioInit(&gpioIRQ);
28 | *
29 | * @endcode
30 | *
31 | * @note Please read the functions documentation for the other GPIO features.
32 | *
33 | * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
34 | * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
35 | * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
36 | * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
37 | * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
38 | * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
39 | *
40 | * THIS SOURCE CODE IS PROTECTED BY A LICENSE.
41 | * FOR MORE INFORMATION PLEASE CAREFULLY READ THE LICENSE AGREEMENT FILE LOCATED
42 | * IN THE ROOT DIRECTORY OF THIS FIRMWARE PACKAGE.
43 | *
44 | * © COPYRIGHT 2019 STMicroelectronics
45 | */
46 |
47 |
48 | /* Define to prevent recursive inclusion -------------------------------------*/
49 | #ifndef __S2LP_GPIO_H
50 | #define __S2LP_GPIO_H
51 |
52 |
53 | /* Includes ------------------------------------------------------------------*/
54 | #include "S2LP_Regs.h"
55 | #include "S2LP_Types.h"
56 |
57 |
58 | #ifdef __cplusplus
59 | extern "C" {
60 | #endif
61 |
62 |
63 | /** @addtogroup S2LP_Libraries
64 | * @{
65 | */
66 |
67 |
68 | /** @defgroup S2LP_Gpio GPIO
69 | * @brief Configuration and management of S2LP GPIO.
70 | * @details See the file @ref S2LP_Gpio.h for more details.
71 | * @{
72 | */
73 |
74 |
75 |
76 | /** @defgroup Gpio_Exported_Types GPIO Exported Types
77 | * @{
78 | */
79 |
80 | /**
81 | * @brief S2LP GPIO pin enumeration.
82 | */
83 | typedef enum {
84 | S2LP_GPIO_0 = GPIO0_CONF_ADDR, /*!< GPIO_0 selected */
85 | S2LP_GPIO_1 = GPIO1_CONF_ADDR, /*!< GPIO_1 selected */
86 | S2LP_GPIO_2 = GPIO2_CONF_ADDR, /*!< GPIO_2 selected */
87 | S2LP_GPIO_3 = GPIO3_CONF_ADDR /*!< GPIO_3 selected */
88 | } S2LPGpioPin;
89 |
90 |
91 | /**
92 | * @brief S2LP GPIO mode enumeration.
93 | */
94 | typedef enum {
95 | S2LP_GPIO_MODE_DIGITAL_INPUT = 0x01, /*!< Digital Input on GPIO */
96 | S2LP_GPIO_MODE_DIGITAL_OUTPUT_LP , /*!< Digital Output on GPIO (low current) */
97 | S2LP_GPIO_MODE_DIGITAL_OUTPUT_HP /*!< Digital Output on GPIO (high current) */
98 | } S2LPGpioMode;
99 |
100 |
101 |
102 | /**
103 | * @brief S2LP I/O selection enumeration.
104 | */
105 | typedef enum {
106 | S2LP_GPIO_DIG_OUT_IRQ = 0x00, /*!< nIRQ (Interrupt Request, active low) , default configuration after POR */
107 | S2LP_GPIO_DIG_OUT_POR_INV = 0x08, /*!< POR inverted (active low) */
108 | S2LP_GPIO_DIG_OUT_WUT_EXP = 0x10, /*!< Wake-Up Timer expiration: "1" when WUT has expired */
109 | S2LP_GPIO_DIG_OUT_LBD = 0x18, /*!< Low battery detection: "1" when battery is below threshold setting */
110 | S2LP_GPIO_DIG_OUT_TX_DATA = 0x20, /*!< TX data internal clock output (TX data are sampled on the rising edge of it) */
111 | S2LP_GPIO_DIG_OUT_TX_STATE = 0x28, /*!< TX state indication: "1" when S2LP1 is passing in the TX state */
112 | S2LP_GPIO_DIG_OUT_TXRX_FIFO_ALMOST_EMPTY = 0x30, /*!< TX/RX FIFO Almost Empty Flag */
113 | S2LP_GPIO_DIG_OUT_TXRX_FIFO_ALMOST_FULL = 0x38, /*!< TX/RX FIFO Almost Full Flag */
114 | S2LP_GPIO_DIG_OUT_RX_DATA = 0x40, /*!< RX data output */
115 | S2LP_GPIO_DIG_OUT_RX_CLOCK = 0x48, /*!< RX clock output (recovered from received data) */
116 | S2LP_GPIO_DIG_OUT_RX_STATE = 0x50, /*!< RX state indication: "1" when demodulator is ON */
117 | S2LP_GPIO_DIG_OUT_NOT_STANDBY_SLEEP = 0x58, /*!< VDD when the device is not in SLEEP or STANDBY */
118 | S2LP_GPIO_DIG_OUT_STANDBY = 0x60, /*!< VDD when device is in STANDBY */
119 | S2LP_GPIO_DIG_OUT_ANTENNA_SWITCH = 0x68, /*!< Antenna switch used for antenna diversity */
120 | S2LP_GPIO_DIG_OUT_VALID_PREAMBLE = 0x70, /*!< Valid Preamble Detected Flag */
121 | S2LP_GPIO_DIG_OUT_SYNC_DETECTED = 0x78, /*!< Sync WordSync Word Detected Flag */
122 | S2LP_GPIO_DIG_OUT_RSSI_THRESHOLD = 0x80, /*!< RSSI above threshold */
123 | S2LP_GPIO_DIG_OUT_MCU_CLOCK = 0x88, /*!< MCU Clock */
124 | S2LP_GPIO_DIG_OUT_TX_RX_MODE = 0x90, /*!< TX or RX mode indicator (to enable an external range extender) */
125 | S2LP_GPIO_DIG_OUT_VDD = 0x98, /*!< VDD (to emulate an additional GPIO of the MCU, programmable by SPI) */
126 | S2LP_GPIO_DIG_OUT_GND = 0xA0, /*!< GND (to emulate an additional GPIO of the MCU, programmable by SPI) */
127 | S2LP_GPIO_DIG_OUT_SMPS_EXT = 0xA8, /*!< External SMPS enable signal (active high) */
128 | S2LP_GPIO_DIG_OUT_SLEEP = 0xB0, /*!< Device in SLEEP (active high) */
129 | S2LP_GPIO_DIG_OUT_READY = 0xB8, /*!< Device in READY (active high) */
130 | S2LP_GPIO_DIG_OUT_LOCK = 0xC0, /*!< Device in LOCK (active high) */
131 | S2LP_GPIO_DIG_OUT_WAIT_FOR_LOCK_SIG = 0xC8, /*!< Device waiting for LOCK (active high) */
132 | S2LP_GPIO_DIG_OUT_TX_DATA_OOK_SIGNAL = 0xD0,
133 | S2LP_GPIO_DIG_OUT_WAIT_FOR_READY2_SIG = 0xD8,
134 | S2LP_GPIO_DIG_OUT_WAIT_FOR_TIMER_FOR_PM_SET = 0xE0,
135 | S2LP_GPIO_DIG_OUT_WAIT_VCO_CALIBRATION = 0xE8,
136 | S2LP_GPIO_DIG_OUT_ENABLE_SYNTH_FULL_CIRCUIT = 0xF0,
137 |
138 | S2LP_GPIO_DIG_IN_TX_COMMAND = 0x00,
139 | S2LP_GPIO_DIG_IN_RX_COMMAND = 0x08,
140 | S2LP_GPIO_DIG_IN_TX_DATA_INPUT_FOR_DIRECTRF = 0x10,
141 | S2LP_GPIO_DIG_IN_DATA_WAKEUP = 0x18,
142 | S2LP_GPIO_DIG_IN_EXT_CLOCK_AT_34_7KHZ = 0x20
143 | } S2LPGpioIO;
144 |
145 |
146 | /**
147 | * @brief S2LP OutputLevel enumeration.
148 | */
149 | typedef enum {
150 | S2LP_LOW = 0,
151 | S2LP_HIGH = !S2LP_LOW
152 | } OutputLevel;
153 |
154 |
155 | /**
156 | * @brief S2LP GPIO Init structure definition.
157 | */
158 | typedef struct {
159 | S2LPGpioPin xS2LPGpioPin; /*!< Select the GPIO pins to be configured. @ref S2LPGpioPin */
160 | S2LPGpioMode xS2LPGpioMode; /*!< Set the pin operating mode. @ref S2LPGpioMode */
161 | S2LPGpioIO xS2LPGpioIO; /*!< Set the I/O selection for the pin. @ref S2LPGpioIO */
162 | } SGpioInit;
163 |
164 |
165 | /**
166 | * @brief S2LP clock output XO prescaler enumeration.
167 | */
168 | typedef enum {
169 | XO_RATIO_1 = 0x00, /*!< XO Clock signal available on the GPIO divided by 1 */
170 | XO_RATIO_1_2 = 0x02, /*!< XO Clock signal available on the GPIO divided by 1/2 */
171 | XO_RATIO_1_4 = 0x04, /*!< XO Clock signal available on the GPIO divided by 1/4 */
172 | XO_RATIO_1_8 = 0x06, /*!< XO Clock signal available on the GPIO divided by 1/8 */
173 | XO_RATIO_1_16 = 0x08, /*!< XO Clock signal available on the GPIO divided by 1/16 */
174 | XO_RATIO_1_32 = 0x0A, /*!< XO Clock signal available on the GPIO divided by 1/32 */
175 | XO_RATIO_1_64 = 0x0C, /*!< XO Clock signal available on the GPIO divided by 1/64 */
176 | XO_RATIO_1_128 = 0x0E, /*!< XO Clock signal available on the GPIO divided by 1/128 */
177 | XO_RATIO_1_256 = 0x10 /*!< XO Clock signal available on the GPIO divided by 1/256 */
178 | } ClockOutputXOPrescaler;
179 |
180 |
181 | /**
182 | * @brief S2LP Clock Output RCO prescaler enumeration.
183 | */
184 |
185 | typedef enum {
186 | RCO_RATIO_1 = 0x00, /*!< RCO Clock signal available on the GPIO divided by 1 */
187 | RCO_RATIO_1_128 /*!< RCO Clock signal available on the GPIO divided by 1/128 */
188 | } ClockOutputRCOPrescaler;
189 |
190 |
191 | /**
192 | * @brief S2LP ExtraClockCycles enumeration.
193 | */
194 | typedef enum {
195 | EXTRA_CLOCK_CYCLES_0 = 0x00, /*!< 0 extra clock cycles provided to the MCU before switching to STANDBY state */
196 | EXTRA_CLOCK_CYCLES_128 = 0x20, /*!< 128 extra clock cycles provided to the MCU before switching to STANDBY state */
197 | EXTRA_CLOCK_CYCLES_256 = 0x40, /*!< 256 extra clock cycles provided to the MCU before switching to STANDBY state */
198 | EXTRA_CLOCK_CYCLES_512 = 0x60 /*!< 512 extra clock cycles provided to the MCU before switching to STANDBY state */
199 | } ExtraClockCycles;
200 |
201 |
202 | /**
203 | * @brief S2LP Clock Output initialization structure definition.
204 | */
205 | typedef struct {
206 | ClockOutputXOPrescaler xClockOutputXOPrescaler; /*!< Set the XO Ratio. @ref ClockOutputXOPrescaler */
207 | ClockOutputRCOPrescaler xClockOutputRCOPrescaler; /*!< Set the RCO Ratio. @ref ClockOutputRCOPrescaler */
208 | ExtraClockCycles xExtraClockCycles; /*!< Set the Extra Clock Cycles provided before entering in Standby state. @ref ExtraClockCycles */
209 | } ClockOutputInit;
210 |
211 |
212 | /**
213 | * @brief IRQ bitfield structure for S2LP. This structure is used to read or write the single IRQ bit.
214 | * During the initialization the user has to fill this structure setting to one the single field related
215 | * to the IRQ he wants to enable, and to zero the single field related to all the IRQs he wants to disable.
216 | * The same structure can be used to retrieve all the IRQ events from the IRQ registers IRQ_STATUS[3:0],
217 | * and read if one or more specific IRQ raised.
218 | * @note The fields order in the structure depends on used endianness (little or big
219 | * endian). The actual definition is valid ONLY for LITTLE ENDIAN mode. Be sure to
220 | * change opportunely the fields order when use a different endianness.
221 | */
222 | typedef struct {
223 | SFlagStatus IRQ_RX_DATA_READY:1; /*!< IRQ: RX data ready */
224 | SFlagStatus IRQ_RX_DATA_DISC:1; /*!< IRQ: RX data discarded (upon filtering) */
225 | SFlagStatus IRQ_TX_DATA_SENT:1; /*!< IRQ: TX data sent */
226 | SFlagStatus IRQ_MAX_RE_TX_REACH:1; /*!< IRQ: Max re-TX reached */
227 | SFlagStatus IRQ_CRC_ERROR:1; /*!< IRQ: CRC error */
228 | SFlagStatus IRQ_TX_FIFO_ERROR:1; /*!< IRQ: TX FIFO underflow/overflow error */
229 | SFlagStatus IRQ_RX_FIFO_ERROR:1; /*!< IRQ: RX FIFO underflow/overflow error */
230 | SFlagStatus IRQ_TX_FIFO_ALMOST_FULL:1; /*!< IRQ: TX FIFO almost full */
231 |
232 | SFlagStatus IRQ_TX_FIFO_ALMOST_EMPTY:1; /*!< IRQ: TX FIFO almost empty */
233 | SFlagStatus IRQ_RX_FIFO_ALMOST_FULL:1; /*!< IRQ: RX FIFO almost full */
234 | SFlagStatus IRQ_RX_FIFO_ALMOST_EMPTY:1; /*!< IRQ: RX FIFO almost empty */
235 | SFlagStatus IRQ_MAX_BO_CCA_REACH:1; /*!< IRQ: Max number of back-off during CCA */
236 | SFlagStatus IRQ_VALID_PREAMBLE:1; /*!< IRQ: Valid preamble detected */
237 | SFlagStatus IRQ_VALID_SYNC:1; /*!< IRQ: Sync word detected */
238 | SFlagStatus IRQ_RSSI_ABOVE_TH:1; /*!< IRQ: RSSI above threshold */
239 | SFlagStatus IRQ_WKUP_TOUT_LDC:1; /*!< IRQ: Wake-up timeout in LDC mode */
240 |
241 | SFlagStatus IRQ_READY:1; /*!< IRQ: READY state */
242 | SFlagStatus IRQ_STANDBY_DELAYED:1; /*!< IRQ: STANDBY state after MCU_CK_CONF_CLOCK_TAIL_X clock cycles */
243 | SFlagStatus IRQ_LOW_BATT_LVL:1; /*!< IRQ: Battery level below threshold*/
244 | SFlagStatus IRQ_POR:1; /*!< IRQ: Power On Reset */
245 | SFlagStatus IRQ_BOR:1; /*!< IRQ: Brown out event (both accurate and inaccurate)*/
246 | SFlagStatus IRQ_LOCK:1; /*!< IRQ: LOCK state */
247 | SFlagStatus IRQ_VCO_CALIBRATION_END:1; /*!< IRQ: End of VCO calibration procedure */
248 | SFlagStatus IRQ_PA_CALIBRATION_END:1; /*!< IRQ: End of PA calibration procedure */
249 |
250 | SFlagStatus IRQ_PM_COUNT_EXPIRED:1; /*!< IRQ: only for debug; Power Management startup timer expiration (see reg PM_START_COUNTER, 0xB5) */
251 | SFlagStatus IRQ_XO_COUNT_EXPIRED:1; /*!< IRQ: only for debug; Crystal oscillator settling time counter expired */
252 | SFlagStatus IRQ_TX_START_TIME:1; /*!< IRQ: only for debug; TX circuitry startup time; see TX_START_COUNTER */
253 | SFlagStatus IRQ_RX_START_TIME:1; /*!< IRQ: only for debug; RX circuitry startup time; see TX_START_COUNTER */
254 | SFlagStatus IRQ_RX_TIMEOUT:1; /*!< IRQ: RX operation timeout */
255 | SFlagStatus IRQ_RX_SNIFF_TIMEOUT:1; /*!< IRQ: RX sniff opeartion timeout */
256 | SFlagStatus :2; /*!< Reserved bit */
257 | } S2LPIrqs;
258 |
259 |
260 | /**
261 | * @brief IRQ list enumeration for S2LP. This enumeration type can be used to address a
262 | * specific IRQ.
263 | */
264 | typedef enum {
265 | RX_DATA_READY = 0x00000001, /*!< IRQ: RX data ready */
266 | RX_DATA_DISC = 0x00000002, /*!< IRQ: RX data discarded (upon filtering) */
267 | TX_DATA_SENT = 0x00000004, /*!< IRQ: TX data sent */
268 | MAX_RE_TX_REACH = 0x00000008, /*!< IRQ: Max re-TX reached */
269 | CRC_ERROR = 0x00000010, /*!< IRQ: CRC error */
270 | TX_FIFO_ERROR = 0x00000020, /*!< IRQ: TX FIFO underflow/overflow error */
271 | RX_FIFO_ERROR = 0x00000040, /*!< IRQ: RX FIFO underflow/overflow error */
272 | TX_FIFO_ALMOST_FULL = 0x00000080, /*!< IRQ: TX FIFO almost full */
273 | TX_FIFO_ALMOST_EMPTY = 0x00000100, /*!< IRQ: TX FIFO almost empty */
274 | RX_FIFO_ALMOST_FULL = 0x00000200, /*!< IRQ: RX FIFO almost full */
275 | RX_FIFO_ALMOST_EMPTY = 0x00000400, /*!< IRQ: RX FIFO almost empty */
276 | MAX_BO_CCA_REACH = 0x00000800, /*!< IRQ: Max number of back-off during CCA */
277 | VALID_PREAMBLE = 0x00001000, /*!< IRQ: Valid preamble detected */
278 | VALID_SYNC = 0x00002000, /*!< IRQ: Sync word detected */
279 | RSSI_ABOVE_TH = 0x00004000, /*!< IRQ: RSSI above threshold */
280 | WKUP_TOUT_LDC = 0x00008000, /*!< IRQ: Wake-up timeout in LDC mode */
281 | READY = 0x00010000, /*!< IRQ: READY state */
282 | STANDBY_DELAYED = 0x00020000, /*!< IRQ: STANDBY state after MCU_CK_CONF_CLOCK_TAIL_X clock cycles */
283 | LOW_BATT_LVL = 0x00040000, /*!< IRQ: Battery level below threshold*/
284 | POR = 0x00080000, /*!< IRQ: Power On Reset */
285 | BOR = 0x00100000, /*!< IRQ: Brown out event (both accurate and inaccurate)*/
286 | LOCK = 0x00200000, /*!< IRQ: LOCK state */
287 | VCO_CALIBRATION_END = 0x00400000, /*!< IRQ: only for debug; Power Management startup timer expiration (see reg PM_START_COUNTER, 0xB5) */
288 | PA_CALIBRATION_END = 0x00800000, /*!< IRQ: only for debug; Crystal oscillator settling time counter expired */
289 | PM_COUNT_EXPIRED = 0x01000000, /*!< IRQ: only for debug; Power Management startup timer expiration (see reg PM_START_COUNTER, 0xB5) */
290 | XO_COUNT_EXPIRED = 0x02000000, /*!< IRQ: only for debug; Crystal oscillator settling time counter expired */
291 | TX_START_TIME = 0x04000000, /*!< IRQ: only for debug; TX circuitry startup time; see TX_START_COUNTER */
292 | RX_START_TIME = 0x08000000, /*!< IRQ: only for debug; RX circuitry startup time; see TX_START_COUNTER */
293 | RX_TIMEOUT = 0x10000000, /*!< IRQ: RX operation timeout */
294 | RX_SNIFF_TIMEOUT = 0x20000000, /*!< IRQ: RX sniff operation timeout */
295 | ALL_IRQ = 0x7FFFFFFF /*!< All the above mentioned IRQs */
296 | } IrqList;
297 |
298 |
299 | /**
300 | * @}
301 | */
302 |
303 |
304 | /**
305 | * @}
306 | */
307 |
308 |
309 | /**
310 | * @}
311 | */
312 |
313 |
314 |
315 | #ifdef __cplusplus
316 | }
317 | #endif
318 |
319 | #endif
320 |
321 | /******************* (C) COPYRIGHT 2019 STMicroelectronics *****END OF FILE****/
322 |
--------------------------------------------------------------------------------
/src/S2LP_PacketHandler.h:
--------------------------------------------------------------------------------
1 | /**
2 | * @file S2LP_PacketHandler.h
3 | * @author ST Microelectronics
4 | * @version 1.3.0
5 | * @date June, 2019
6 | * @brief Configuration and management of the common features of S2-LP packets.
7 | * @details
8 | *
9 | * This module provides all the common functions and definitions used by the
10 | * packets modules.
11 | * Here are also defined all the generic enumeration types that are redefined
12 | * in the specific packets modules, but every enumeration value is referred
13 | * to this module. So the user who wants to configure the preamble of a Basic,
14 | * or a STack packet has to use the enumeration values defined here.
15 | *
16 | * Example:
17 | * @code
18 | *
19 | * ...
20 | *
21 | * S2LPPktBasicSetPreambleLength(PKT_PREAMBLE_LENGTH_18BYTES);
22 | *
23 | * ...
24 | *
25 | * @endcode
26 | *
27 | * @note Is recommended for the user to not use these API directly
28 | * importing this module in his application.
29 | *
30 | * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
31 | * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
32 | * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
33 | * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
34 | * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
35 | * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
36 | *
37 | * THIS SOURCE CODE IS PROTECTED BY A LICENSE.
38 | * FOR MORE INFORMATION PLEASE CAREFULLY READ THE LICENSE AGREEMENT FILE LOCATED
39 | * IN THE ROOT DIRECTORY OF THIS FIRMWARE PACKAGE.
40 | *
41 | * © COPYRIGHT 2019 STMicroelectronics
42 | */
43 |
44 | /* Define to prevent recursive inclusion -------------------------------------*/
45 | #ifndef __S2LP_PKT_COMMON_H
46 | #define __S2LP_PKT_COMMON_H
47 |
48 | /* Includes ------------------------------------------------------------------*/
49 |
50 | #include "S2LP_Regs.h"
51 | #include "S2LP_Types.h"
52 |
53 | #ifdef __cplusplus
54 | extern "C" {
55 | #endif
56 |
57 |
58 | /**
59 | * @addtogroup S2LP_Libraries
60 | * @{
61 | */
62 |
63 |
64 | /**
65 | * @defgroup S2LP_PktCommon Pkt Common
66 | * @brief Configuration and management of the common features of S2LP packets.
67 | * @details See the file @ref S2LP_PktCommon.h for more details.
68 | * @{
69 | */
70 |
71 | /**
72 | * @defgroup PktCommon_Exported_Types Pkt Common Exported Types
73 | * @{
74 | */
75 |
76 |
77 | /**
78 | * @brief CRC length in bytes enumeration.
79 | */
80 | typedef enum {
81 | PKT_NO_CRC = 0x00, /*!< No CRC */
82 | PKT_CRC_MODE_8BITS = 0x20, /*!< CRC length 8 bits - poly: 0x07 */
83 | PKT_CRC_MODE_16BITS_1 = 0x40, /*!< CRC length 16 bits - poly: 0x8005 */
84 | PKT_CRC_MODE_16BITS_2 = 0x60, /*!< CRC length 16 bits - poly: 0x1021 */
85 | PKT_CRC_MODE_24BITS = 0x80, /*!< CRC length 24 bits - poly: 0x864CFB */
86 | PKT_CRC_MODE_32BITS = 0xA0, /*!< CRC length 32 bits - poly: 0x04C011BB7 */
87 | } PktCrcMode;
88 |
89 |
90 | /**
91 | * @brief Direct transmission mode enumeration for SPIRIT.
92 | */
93 | typedef enum
94 | {
95 | NORMAL_TX_MODE = 0x00, /*!< Normal mode, no direct transmission is used */
96 | DIRECT_TX_FIFO_MODE = 0x04, /*!< Source is FIFO: payload bits are continuously read from the TX FIFO */
97 | DIRECT_TX_GPIO_MODE = 0x08, /*!< Source is GPIO: payload bits are continuously read from one of the GPIO ports and transmitted without any processing */
98 | PN9_TX_MODE = 0x0C /*!< A pseudorandom binary sequence is generated internally */
99 | } DirectTx;
100 |
101 |
102 | /**
103 | * @brief Direct receive mode enumeration for SPIRIT.
104 | */
105 | typedef enum
106 | {
107 | NORMAL_RX_MODE = 0x00, /*!< Normal mode, no direct reception is used */
108 | DIRECT_RX_FIFO_MODE = 0x10, /*!< Destination is FIFO: payload bits are continuously written to the RX FIFO and not subjected to any processing*/
109 | DIRECT_RX_GPIO_MODE = 0x20 /*!< Destination is GPIO: payload bits are continuously written to one of the GPIO ports and not subjected to any processing*/
110 | } DirectRx;
111 |
112 |
113 | /**
114 | *@}
115 | */
116 |
117 |
118 | /**
119 | * @defgroup PktCommon_Exported_Constants Pkt Common Exported Constants
120 | * @{
121 | */
122 |
123 |
124 | /**
125 | *@}
126 | */
127 |
128 |
129 | /**
130 | * @defgroup PktCommon_Exported_Macros Pkt Common Exported Macros
131 | * @{
132 | */
133 |
134 | #define S2LPSetPreambleLengthByte(xPreambleLength) S2LPSetPreambleLength(4*xPreambleLength)
135 | #define S2LPSetSyncLengthByte(cSyncLength) S2LPSetSyncLength(8*cSyncLength)
136 |
137 | #define IS_PREAMBLE_LEN(VAL) (VAL<=1024)
138 | #define IS_SYNC_LEN(VAL) (VAL<=64)
139 |
140 | #define IS_PKT_LEN_FIELD_WID(LENGTH) ((LENGTH == PKT_LENGTH_FIELD_1BYTE) || \
141 | (LENGTH == PKT_LENGTH_FIELD_2BYTE))
142 |
143 |
144 | #define IS_PKT_CRC_MODE(MODE) ((MODE == PKT_NO_CRC) || \
145 | (MODE == PKT_CRC_MODE_8BITS) || \
146 | (MODE == PKT_CRC_MODE_16BITS_1) || \
147 | (MODE == PKT_CRC_MODE_16BITS_2) || \
148 | (MODE == PKT_CRC_MODE_24BITS))
149 | /**
150 | *@}
151 | */
152 |
153 |
154 | /**
155 | *@}
156 | */
157 |
158 |
159 | /**
160 | *@}
161 | */
162 |
163 | #ifdef __cplusplus
164 | }
165 | #endif
166 |
167 | #endif
168 |
169 | /******************* (C) COPYRIGHT 2019 STMicroelectronics *****END OF FILE****/
170 |
--------------------------------------------------------------------------------
/src/S2LP_PktBasic.cpp:
--------------------------------------------------------------------------------
1 | /**
2 | * @file S2LP_PktBasic.c
3 | * @author ST Microelectronics
4 | * @version 1.3.0
5 | * @date June, 2019
6 | * @brief Configuration and management of S2-LP Basic packets.
7 | * @details
8 | *
9 | * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
10 | * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
11 | * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
12 | * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
13 | * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
14 | * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
15 | *
16 | * THIS SOURCE CODE IS PROTECTED BY A LICENSE.
17 | * FOR MORE INFORMATION PLEASE CAREFULLY READ THE LICENSE AGREEMENT FILE LOCATED
18 | * IN THE ROOT DIRECTORY OF THIS FIRMWARE PACKAGE.
19 | *
20 | * © COPYRIGHT 2019 STMicroelectronics
21 | */
22 |
23 |
24 | /* Includes ------------------------------------------------------------------*/
25 | #include "S2LP.h"
26 |
27 |
28 | /**
29 | * @addtogroup S2LP_Libraries
30 | * @{
31 | */
32 |
33 |
34 | /**
35 | * @addtogroup S2LP_PktBasic
36 | * @{
37 | */
38 |
39 |
40 |
41 | /**
42 | * @defgroup PktBasic_Private_Defines Pkt Basic Private Defines
43 | * @{
44 | */
45 |
46 | #define PKT_FORMAT_BASIC_CODE 0x00
47 |
48 | /**
49 | *@}
50 | */
51 |
52 |
53 | /**
54 | * @defgroup PktBasic_Private_Macros Pkt Basic Private Macros
55 | * @{
56 | */
57 |
58 | #define IS_BASIC_PREAMBLE_LENGTH IS_PREAMBLE_LEN
59 | #define IS_BASIC_SYNC_LENGTH IS_SYNC_LEN
60 | #define IS_BASIC_PKT_LEN_FIELD_WID IS_PKT_LEN_FIELD_WID
61 | #define IS_BASIC_CRC_MODE IS_PKT_CRC_MODE
62 |
63 | /**
64 | *@}
65 | */
66 |
67 |
68 |
69 | /**
70 | * @defgroup PktBasic_Private_Functions Pkt Basic Private Functions
71 | * @{
72 | */
73 |
74 | /**
75 | * @brief Initialize the S2LP Basic packet according to the specified parameters in the PktBasicInit struct.
76 | * Notice that this function sets the autofiltering option on CRC if it is set to any value different from BASIC_NO_CRC.
77 | * @param pxPktBasicInit Basic packet init structure.
78 | * This parameter is a pointer to @ref PktBasicInit.
79 | * @retval None.
80 | */
81 | void S2LP::S2LPPktBasicInit(PktBasicInit* pxPktBasicInit)
82 | {
83 | uint8_t tmpBuffer[6];
84 |
85 | /* Check the parameters */
86 | s_assert_param(IS_BASIC_PREAMBLE_LENGTH(pxPktBasicInit->xPreambleLength));
87 | s_assert_param(IS_BASIC_SYNC_LENGTH(pxPktBasicInit->xSyncLength));
88 | s_assert_param(IS_BASIC_CRC_MODE(pxPktBasicInit->xCrcMode));
89 | s_assert_param(IS_SFUNCTIONAL_STATE(pxPktBasicInit->cExtendedPktLenField));
90 | s_assert_param(IS_SFUNCTIONAL_STATE(pxPktBasicInit->xFixVarLength));
91 | s_assert_param(IS_SFUNCTIONAL_STATE(pxPktBasicInit->xAddressField));
92 | s_assert_param(IS_SFUNCTIONAL_STATE(pxPktBasicInit->xFec));
93 | s_assert_param(IS_SFUNCTIONAL_STATE(pxPktBasicInit->xDataWhitening));
94 |
95 | S2LPPktWMbusSetSubmode(WMBUS_SUBMODE_NOT_CONFIGURED);
96 |
97 | /* Always set the automatic packet filtering */
98 | S2LPSpiReadRegisters(PROTOCOL1_ADDR, 1, &tmpBuffer[0]);
99 | tmpBuffer[0] |= AUTO_PCKT_FLT_REGMASK;
100 | S2LPSpiWriteRegisters(PROTOCOL1_ADDR, 1, &tmpBuffer[0]);
101 |
102 | tmpBuffer[0] = ((pxPktBasicInit->xSyncLength)<<2) | (uint8_t)((pxPktBasicInit->xPreambleLength)>>8);
103 | tmpBuffer[1] = (uint8_t)(pxPktBasicInit->xPreambleLength);
104 | tmpBuffer[2] = (((uint8_t)pxPktBasicInit->xAddressField)<<3);
105 |
106 | if((pxPktBasicInit->cExtendedPktLenField)==S_ENABLE)
107 | {
108 | tmpBuffer[2]|=0x80;
109 | }
110 |
111 | S2LPSpiReadRegisters(PCKTCTRL3_ADDR, 1, &tmpBuffer[3]);
112 | tmpBuffer[3] &= ~(PCKT_FRMT_REGMASK | RX_MODE_REGMASK);
113 | tmpBuffer[3] |= PKT_FORMAT_BASIC_CODE;
114 |
115 | S2LPSpiReadRegisters(PCKTCTRL2_ADDR, 2, &tmpBuffer[4]);
116 |
117 | if(pxPktBasicInit->xFixVarLength == S_ENABLE) {
118 | tmpBuffer[4] |= FIX_VAR_LEN_REGMASK;
119 | }
120 | else {
121 | tmpBuffer[4] &= ~FIX_VAR_LEN_REGMASK;
122 | }
123 | tmpBuffer[4] &= ~(MANCHESTER_EN_REGMASK | MBUS_3OF6_EN_REGMASK);
124 |
125 | tmpBuffer[5] &= ~(CRC_MODE_REGMASK | TXSOURCE_REGMASK);
126 | tmpBuffer[5] |= (uint8_t)pxPktBasicInit->xCrcMode;
127 |
128 | if(pxPktBasicInit->xDataWhitening == S_ENABLE) {
129 | tmpBuffer[5] |= WHIT_EN_REGMASK;
130 | }
131 | else {
132 | tmpBuffer[5] &= ~WHIT_EN_REGMASK;
133 | }
134 |
135 | if(pxPktBasicInit->xFec == S_ENABLE)
136 | {
137 | tmpBuffer[5] |= FEC_EN_REGMASK;
138 | }
139 | else {
140 | tmpBuffer[5] &= ~FEC_EN_REGMASK;
141 | }
142 |
143 | S2LPSpiWriteRegisters(PCKTCTRL6_ADDR, 6, tmpBuffer);
144 |
145 | /* SYNC word */
146 | for(uint8_t i=0 ; i<4 ; i++) {
147 | tmpBuffer[i] = (uint8_t)(pxPktBasicInit->lSyncWords>>(8*i));
148 | }
149 | g_xStatus = S2LPSpiWriteRegisters(SYNC3_ADDR, 4, tmpBuffer);
150 |
151 | /* Sets CRC check bit */
152 | if(pxPktBasicInit->xCrcMode == PKT_NO_CRC) {
153 | S2LPPktBasicFilterOnCrc(S_DISABLE);
154 | }
155 | else {
156 | S2LPPktBasicFilterOnCrc(S_ENABLE);
157 | }
158 |
159 | /* Constellation map setting */
160 | S2LPSpiReadRegisters(MOD1_ADDR, 1, tmpBuffer);
161 | tmpBuffer[0] &= ~G4FSK_CONST_MAP_REGMASK;
162 | S2LPSpiWriteRegisters(MOD1_ADDR, 1, tmpBuffer);
163 | }
164 |
165 |
166 | /**
167 | * @brief Return the S2LP Basic packet structure according to the specified parameters in the registers.
168 | * @param pxPktBasicInit Basic packet init structure.
169 | * This parameter is a pointer to @ref PktBasicInit.
170 | * @retval None.
171 | */
172 | void S2LP::S2LPPktBasicGetInfo(PktBasicInit* pxPktBasicInit)
173 | {
174 | uint8_t tmpBuffer[6];
175 |
176 | S2LPSpiReadRegisters(PCKTCTRL6_ADDR, 6, tmpBuffer);
177 |
178 | /* Sync length */
179 | pxPktBasicInit->xSyncLength = ((tmpBuffer[0] & SYNC_LEN_REGMASK)>>2);
180 |
181 | /* Preamble length */
182 | pxPktBasicInit->xPreambleLength = (((uint16_t)(tmpBuffer[0] & PREAMBLE_LEN_9_8_REGMASK))<<8) | ((uint16_t)tmpBuffer[1]);
183 |
184 | /* Length width */
185 | pxPktBasicInit->cExtendedPktLenField = (SFunctionalState)((tmpBuffer[2] & LEN_WID_REGMASK)>>7);
186 |
187 | /* Address field */
188 | pxPktBasicInit->xAddressField = (SFunctionalState)((tmpBuffer[2] & ADDRESS_LEN_REGMASK)>>3);
189 |
190 | /* FIX or VAR bit */
191 | pxPktBasicInit->xFixVarLength = (SFunctionalState)(tmpBuffer[4] & FIX_VAR_LEN_REGMASK);
192 |
193 | /* CRC mode */
194 | pxPktBasicInit->xCrcMode = (BasicCrcMode)(tmpBuffer[5] & CRC_MODE_REGMASK);
195 |
196 | /* Whitening */
197 | pxPktBasicInit->xDataWhitening = (SFunctionalState)((tmpBuffer[5] & WHIT_EN_REGMASK)>> 4);
198 |
199 | /* FEC */
200 | pxPktBasicInit->xFec = (SFunctionalState)(tmpBuffer[5] & FEC_EN_REGMASK);
201 |
202 | g_xStatus = S2LPSpiReadRegisters(SYNC3_ADDR, 4, tmpBuffer);
203 |
204 | /* SYNC word */
205 | pxPktBasicInit->lSyncWords = 0;
206 | for(uint8_t i=0 ; i<4 ; i++) {
207 | pxPktBasicInit->lSyncWords |= ((uint32_t)tmpBuffer[i])<<(8*i);
208 | }
209 | }
210 |
211 |
212 | /**
213 | * @brief Initialize the S2LP Basic packet addresses according to the specified
214 | * parameters in the PktBasicAddressesInit struct.
215 | * @param pxPktBasicAddresses Basic packet addresses init structure.
216 | * This parameter is a pointer to @ref PktBasicAddresses.
217 | * @retval None.
218 | */
219 | void S2LP::S2LPPktBasicAddressesInit(PktBasicAddressesInit* pxPktBasicAddresses)
220 | {
221 | uint8_t tmpBuffer[3];
222 | s_assert_param(IS_SFUNCTIONAL_STATE(pxPktBasicAddresses->xFilterOnMyAddress));
223 | s_assert_param(IS_SFUNCTIONAL_STATE(pxPktBasicAddresses->xFilterOnMulticastAddress));
224 | s_assert_param(IS_SFUNCTIONAL_STATE(pxPktBasicAddresses->xFilterOnBroadcastAddress));
225 |
226 | /* Reads the PCKT_FLT_OPTIONS ragister */
227 | S2LPSpiReadRegisters(PCKT_FLT_OPTIONS_ADDR, 1, &tmpBuffer[0]);
228 |
229 | /* Enables or disables filtering on my address */
230 | if(pxPktBasicAddresses->xFilterOnMyAddress == S_ENABLE) {
231 | tmpBuffer[0] |= DEST_VS_SOURCE_ADDR_REGMASK;
232 | }
233 | else {
234 | tmpBuffer[0] &= ~DEST_VS_SOURCE_ADDR_REGMASK;
235 | }
236 |
237 | /* Enables or disables filtering on multicast address */
238 | if(pxPktBasicAddresses->xFilterOnMulticastAddress == S_ENABLE) {
239 | tmpBuffer[0] |= DEST_VS_MULTICAST_ADDR_REGMASK;
240 | }
241 | else {
242 | tmpBuffer[0] &= ~DEST_VS_MULTICAST_ADDR_REGMASK;
243 | }
244 |
245 | /* Enables or disables filtering on broadcast address */
246 | if(pxPktBasicAddresses->xFilterOnBroadcastAddress == S_ENABLE) {
247 | tmpBuffer[0] |= DEST_VS_BROADCAST_ADDR_REGMASK;
248 | }
249 | else {
250 | tmpBuffer[0] &= ~DEST_VS_BROADCAST_ADDR_REGMASK;
251 | }
252 |
253 | S2LPSpiWriteRegisters(PCKT_FLT_OPTIONS_ADDR, 1, &tmpBuffer[0]);
254 |
255 | /* Fills the array with the addresses passed in the structure */
256 | tmpBuffer[2] = pxPktBasicAddresses->cMyAddress;
257 | tmpBuffer[0] = pxPktBasicAddresses->cBroadcastAddress;
258 | tmpBuffer[1] = pxPktBasicAddresses->cMulticastAddress;
259 | g_xStatus = S2LPSpiWriteRegisters(PCKT_FLT_GOALS2_ADDR, 3, tmpBuffer);
260 | }
261 |
262 |
263 | /**
264 | * @brief Return the S2LP Basic packet addresses structure according to the specified
265 | * parameters in the registers.
266 | * @param pxPktBasicAddresses Basic packet addresses init structure.
267 | * This parameter is a pointer to @ref PktBasicAddresses.
268 | * @retval None.
269 | */
270 | void S2LP::S2LPPktBasicGetAddressesInfo(PktBasicAddressesInit* pxPktBasicAddresses)
271 | {
272 | uint8_t tmpBuffer[3];
273 |
274 | S2LPSpiReadRegisters(PCKT_FLT_GOALS3_ADDR, 3, tmpBuffer);
275 | pxPktBasicAddresses->cMyAddress = tmpBuffer[0];
276 | pxPktBasicAddresses->cBroadcastAddress = tmpBuffer[1];
277 | pxPktBasicAddresses->cMulticastAddress = tmpBuffer[2];
278 |
279 | g_xStatus = S2LPSpiReadRegisters(PCKT_FLT_OPTIONS_ADDR, 1, &tmpBuffer[0]);
280 | pxPktBasicAddresses->xFilterOnBroadcastAddress = (SFunctionalState)((tmpBuffer[0] & DEST_VS_BROADCAST_ADDR_REGMASK) >> 3);
281 | pxPktBasicAddresses->xFilterOnMulticastAddress = (SFunctionalState)((tmpBuffer[0] & DEST_VS_MULTICAST_ADDR_REGMASK) >> 2);
282 | pxPktBasicAddresses->xFilterOnMyAddress = (SFunctionalState)((tmpBuffer[0] & DEST_VS_SOURCE_ADDR_REGMASK) >> 1);
283 | }
284 |
285 |
286 | /**
287 | * @brief Configure the Basic packet format as packet used by S2LP.
288 | * @param None.
289 | * @retval None.
290 | */
291 | void S2LP::S2LPPktBasicSetFormat(void)
292 | {
293 | uint8_t tmp;
294 |
295 | S2LPSpiReadRegisters(PCKTCTRL3_ADDR, 1, &tmp);
296 |
297 | /* Build the new value. Also set to 0 the direct RX mode bits */
298 | tmp &= ~(PCKT_FRMT_REGMASK | RX_MODE_REGMASK);
299 | tmp |= PKT_FORMAT_BASIC_CODE;
300 | S2LPSpiWriteRegisters(PCKTCTRL3_ADDR, 1, &tmp);
301 |
302 | S2LPSpiReadRegisters(PCKTCTRL1_ADDR, 1, &tmp);
303 |
304 | /* Set to 0 the direct TX mode bits */
305 | tmp &= ~TXSOURCE_REGMASK;
306 | g_xStatus = S2LPSpiWriteRegisters(PCKTCTRL1_ADDR, 1, &tmp);
307 |
308 | S2LPPktWMbusSetSubmode(WMBUS_SUBMODE_NOT_CONFIGURED);
309 | }
310 |
311 |
312 | /**
313 | * @brief Set the address length for S2LP Basic packets.
314 | * @param xAddressField length of ADDRESS in bytes.
315 | * This parameter can be: S_ENABLE or S_DISABLE.
316 | * @retval None.
317 | */
318 | void S2LP::S2LPPktBasicAddressField(SFunctionalState xAddressField)
319 | {
320 | uint8_t tmp;
321 | s_assert_param(IS_SFUNCTIONAL_STATE(xAddressField));
322 |
323 | S2LPSpiReadRegisters(PCKTCTRL4_ADDR, 1, &tmp);
324 | if(xAddressField==S_ENABLE) {
325 | tmp |= ADDRESS_LEN_REGMASK;
326 | }
327 | else {
328 | tmp &= ADDRESS_LEN_REGMASK;
329 | }
330 | g_xStatus = S2LPSpiWriteRegisters(PCKTCTRL4_ADDR, 1, &tmp);
331 |
332 | }
333 |
334 |
335 | /**
336 | * @brief Specify if the Address field for S2LP Basic packets is enabled or disabled.
337 | * @param None.
338 | * @retval SFunctionalState Notifies if the address field is enabled or disabled.
339 | */
340 | SFunctionalState S2LP::S2LPPktBasicGetAddressField(void)
341 | {
342 | uint8_t tmp;
343 |
344 | g_xStatus = S2LPSpiReadRegisters(PCKTCTRL4_ADDR, 1, &tmp);
345 | if(tmp & ADDRESS_LEN_REGMASK) {
346 | return S_ENABLE;
347 | }
348 | else {
349 | return S_DISABLE;
350 | }
351 |
352 | }
353 |
354 |
355 | /**
356 | * @brief Set the payload length for S2LP Basic packets. Since the packet length
357 | * depends from the address and the control field size, this
358 | * function reads the correspondent registers in order to determine
359 | * the correct packet length to be written.
360 | * @param nPayloadLength payload length in bytes.
361 | * This parameter is an uint16_t.
362 | * @retval None.
363 | */
364 | void S2LP::S2LPPktBasicSetPayloadLength(uint16_t nPayloadLength)
365 | {
366 | uint8_t tmpBuffer[2];
367 |
368 | if(S2LPPktBasicGetAddressField()) {
369 | nPayloadLength++;
370 | }
371 | tmpBuffer[0] = (uint8_t)(nPayloadLength>>8);
372 | tmpBuffer[1] = (uint8_t)nPayloadLength;
373 | g_xStatus = S2LPSpiWriteRegisters(PCKTLEN1_ADDR, 2, tmpBuffer);
374 | }
375 |
376 |
377 | /**
378 | * @brief Return the payload length for S2LP Basic packets. Since the
379 | * packet length depends from the address and the control
380 | * field size, this function reads the correspondent
381 | * registers in order to determine the correct payload length
382 | * to be returned.
383 | * @param None.
384 | * @retval uint16_t Payload length in bytes.
385 | */
386 | uint16_t S2LP::S2LPPktBasicGetPayloadLength(void)
387 | {
388 | uint8_t tmpBuffer[2];
389 | uint16_t nPayloadLength;
390 |
391 | g_xStatus = S2LPSpiReadRegisters(PCKTLEN1_ADDR, 2, tmpBuffer);
392 | nPayloadLength = (((uint16_t)tmpBuffer[0])<<8) | ((uint16_t)tmpBuffer[1]);
393 |
394 | if(S2LPPktBasicGetAddressField()) {
395 | nPayloadLength--;
396 | }
397 | return nPayloadLength;
398 | }
399 |
400 | /**
401 | * @brief Return the packet length field of the received packet.
402 | * @param None.
403 | * @retval uint16_t Packet length.
404 | */
405 | uint16_t S2LP::S2LPPktBasicGetReceivedPktLength(void)
406 | {
407 | uint8_t tmpBuffer[2];
408 | uint16_t nPayloadLength;
409 |
410 | g_xStatus = S2LPSpiReadRegisters(RX_PCKT_LEN1_ADDR, 2, tmpBuffer);
411 | nPayloadLength = (((uint16_t)tmpBuffer[0])<<8) | ((uint16_t)tmpBuffer[1]);
412 |
413 | if(S2LPPktBasicGetAddressField()) {
414 | nPayloadLength--;
415 | }
416 | return nPayloadLength;
417 | }
418 |
419 |
420 | /**
421 | *@}
422 | */
423 |
424 | /**
425 | *@}
426 | */
427 |
428 |
429 | /**
430 | *@}
431 | */
432 |
433 |
434 |
435 | /******************* (C) COPYRIGHT 2019 STMicroelectronics *****END OF FILE****/
436 |
--------------------------------------------------------------------------------
/src/S2LP_PktBasic.h:
--------------------------------------------------------------------------------
1 | /**
2 | * @file S2LP_PktBasic.h
3 | * @author ST Microelectronics
4 | * @version 1.3.0
5 | * @date June, 2019
6 | * @brief Configuration and management of S2-LP Basic packets.
7 | * @details
8 | *
9 | * This module can be used to manage the configuration of S2LP Basic
10 | * packets.
11 | * The user can obtain a packet configuration filling the structure
12 | * @ref PktBasicInit, defining in it some general parameters
13 | * for the S2-LP Basic packet format.
14 | * Another structure the user can fill is @ref PktBasicAddressesInit
15 | * to define the addresses which will be used during the communication.
16 | * Moreover, functions to set the payload length and the destination address
17 | * are provided.
18 | *
19 | * Example:
20 | * @code
21 | *
22 | * PktBasicInit basicInit={
23 | * 32, // preamble length in bits
24 | * 32, // sync word length in bits
25 | * 0x88888888, // sync word
26 | * S_ENABLE, // variable or fixed payload length
27 | * S_DISABLE, // extended length field width (used only for variable length)
28 | * PKT_NO_CRC, // CRC mode
29 | * S_ENABLE, // address field
30 | * S_DISABLE, // FEC
31 | * S_ENABLE // whitening
32 | * };
33 | *
34 | * PktBasicAddressesInit addressInit={
35 | * S_ENABLE, // enable/disable filtering on my address
36 | * 0x34, // my address (address of the current node)
37 | * S_DISABLE, // enable/disable filtering on multicast address
38 | * 0xEE, // multicast address
39 | * S_DISABLE, // enable/disable filtering on broadcast address
40 | * 0xFF // broadcast address
41 | * };
42 | *
43 | * ...
44 | *
45 | * S2LPPktBasicInit(&basicInit);
46 | * S2LPPktBasicAddressesInit(&addressInit);
47 | *
48 | * ...
49 | *
50 | * S2LPPktBasicSetPayloadLength(20);
51 | * S2LPPktBasicSetDestinationAddress(0x44);
52 | *
53 | * ...
54 | *
55 | * @endcode
56 | *
57 | * The module provides some other functions that can be used to modify
58 | * or read only some configuration parameters.
59 | *
60 | *
61 | * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
62 | * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
63 | * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
64 | * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
65 | * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
66 | * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
67 | *
68 | * THIS SOURCE CODE IS PROTECTED BY A LICENSE.
69 | * FOR MORE INFORMATION PLEASE CAREFULLY READ THE LICENSE AGREEMENT FILE LOCATED
70 | * IN THE ROOT DIRECTORY OF THIS FIRMWARE PACKAGE.
71 | *
72 | * © COPYRIGHT 2019 STMicroelectronics
73 | */
74 |
75 | /* Define to prevent recursive inclusion -------------------------------------*/
76 | #ifndef __S2LP_PKT_BASIC_H
77 | #define __S2LP_PKT_BASIC_H
78 |
79 | /* Includes ------------------------------------------------------------------*/
80 |
81 | #include "S2LP_Regs.h"
82 | #include "S2LP_Types.h"
83 | #include "S2LP_PacketHandler.h"
84 |
85 | #ifdef __cplusplus
86 | extern "C" {
87 | #endif
88 |
89 |
90 | /**
91 | * @addtogroup S2LP_Libraries
92 | * @{
93 | */
94 |
95 |
96 | /**
97 | * @defgroup S2LP_PktBasic Pkt Basic
98 | * @brief Configuration and management of S2LP Basic packets.
99 | * @details See the file @ref S2LP_PktBasic.h for more details.
100 | * @{
101 | */
102 |
103 | /**
104 | * @defgroup PktBasic_Exported_Types Pkt Basic Exported Types
105 | * @{
106 | */
107 |
108 |
109 | /**
110 | * @brief CRC length in bytes enumeration.
111 | */
112 | typedef PktCrcMode BasicCrcMode;
113 |
114 |
115 |
116 | /**
117 | * @brief S2LP Basic Packet Init structure definition.
118 | */
119 | typedef struct {
120 | uint16_t xPreambleLength; /*!< Set the preamble length of packet. From 1 to 1024 chip sequence. */
121 | uint8_t xSyncLength; /*!< Set the sync word length of packet in bits. From 1 to 64 bits. */
122 | uint32_t lSyncWords; /*!< Set the sync words in MSB. */
123 | SFunctionalState xFixVarLength; /*!< Enable the variable length mode. */
124 | SFunctionalState cExtendedPktLenField; /*!< Extend the length field from 1 byte to 2 bytes. Variable length mode only. */
125 | BasicCrcMode xCrcMode; /*!< Set the CRC type. @ref StackCrcMode */
126 | SFunctionalState xAddressField; /*!< Enable the destination address field. */
127 | SFunctionalState xFec; /*!< Enable the FEC/Viterbi. */
128 | SFunctionalState xDataWhitening; /*!< Enable the data whitening. */
129 | } PktBasicInit;
130 |
131 |
132 | /**
133 | * @brief S2LP Basic packet address structure definition. This structure allows users to specify
134 | * the node/multicast/broadcast addresses and the correspondent filtering options.
135 | */
136 | typedef struct {
137 | SFunctionalState xFilterOnMyAddress; /*!< If set packet is received if its destination address matches with cMyAddress. */
138 | uint8_t cMyAddress; /*!< Set the MyAddress. */
139 | SFunctionalState xFilterOnMulticastAddress; /*!< If set packet is received if its destination address matches with cMulticastAddress. */
140 | uint8_t cMulticastAddress; /*!< Set the Multicast address */
141 | SFunctionalState xFilterOnBroadcastAddress; /*!< If set packet is received if its destination address matches with cBroadcastAddress. */
142 | uint8_t cBroadcastAddress; /*!< Set the Broadcast address */
143 | } PktBasicAddressesInit;
144 |
145 |
146 | /**
147 | *@}
148 | */
149 |
150 |
151 | /**
152 | * @defgroup PktBasic_Exported_Macros Pkt Basic Exported Macros
153 | * @{
154 | */
155 |
156 | /**
157 | * @brief Sets the PREAMBLE field length for S2LP Basic packets.
158 | * @param xPreambleLength length of PREAMBLE field in bytes.
159 | * This parameter can be any value of @ref BasicPreambleLength.
160 | * @retval None.
161 | */
162 | #define S2LPPktBasicSetPreambleLength(xPreambleLength) S2LPSetPreambleLength(xPreambleLength)
163 |
164 |
165 | /**
166 | * @brief Returns the PREAMBLE field length mode for S2LP Basic packets.
167 | * @param None.
168 | * @retval uint8_t Preamble field length in bytes.
169 | */
170 | #define S2LPPktBasicGetPreambleLength() S2LPGetPreambleLength()
171 |
172 |
173 | /**
174 | * @brief Sets the SYNC field length for S2LP Basic packets.
175 | * @param xSyncLength length of SYNC field in bytes.
176 | * This parameter can be any value of @ref BasicSyncLength.
177 | * @retval None.
178 | */
179 | #define S2LPPktBasicSetSyncLength(xSyncLength) S2LPSetSyncLength((PktSyncLength)xSyncLength)
180 |
181 |
182 | /**
183 | * @brief Returns the SYNC field length for S2LP Basic packets.
184 | * @param None.
185 | * @retval uint8_t SYNC field length in bytes.
186 | */
187 | #define S2LPPktBasicGetSyncLength() S2LPGetSyncLength()
188 |
189 |
190 | /**
191 | * @brief Enables or Disables the CRC filtering.
192 | * @param xNewState new state for CRC_CHECK.
193 | * This parameter can be S_ENABLE or S_DISABLE.
194 | * @retval None.
195 | */
196 | #define S2LPPktBasicFilterOnCrc(xNewState) S2LPPktCommonFilterOnCrc(xNewState)
197 |
198 |
199 | /**
200 | * @brief Enables or Disables WHITENING for S2LP packets.
201 | * @param xNewState new state for WHITENING mode.
202 | * This parameter can be S_ENABLE or S_DISABLE.
203 | * @retval None.
204 | */
205 | #define S2LPPktBasicWhitening(xNewState) S2LPWhitening(xNewState)
206 |
207 |
208 | /**
209 | * @brief Enables or Disables FEC for S2LP Basic packets.
210 | * @param xNewState new state for FEC mode.
211 | * This parameter can be S_ENABLE or S_DISABLE.
212 | * @retval None.
213 | */
214 | #define S2LPPktBasicFec(xNewState) S2LPFec(xNewState)
215 |
216 |
217 |
218 | /**
219 | * @brief Sets multiple SYNC words for S2LP Basic packets.
220 | * @param lSyncWords SYNC words to be set with format: 0x|SYNC1|SYNC2|SYNC3|SYNC4|.
221 | * This parameter is a uint32_t.
222 | * @param xSyncLength SYNC length in bytes. The 32bit word passed will be stored in the SYNCx registers from the MSb
223 | * until the number of bytes in xSyncLength has been stored.
224 | * This parameter is a @ref BasicSyncLength.
225 | * @retval None.
226 | */
227 | #define S2LPPktBasicSetSyncWords(lSyncWords, xSyncLength) S2LPSetSyncWords(lSyncWords, xSyncLength)
228 |
229 |
230 | /**
231 | *@}
232 | */
233 |
234 |
235 | /**
236 | *@}
237 | */
238 |
239 |
240 | /**
241 | *@}
242 | */
243 |
244 | #ifdef __cplusplus
245 | }
246 | #endif
247 |
248 | #endif
249 |
250 | /******************* (C) COPYRIGHT 2019 STMicroelectronics *****END OF FILE****/
251 |
--------------------------------------------------------------------------------
/src/S2LP_PktStack.cpp:
--------------------------------------------------------------------------------
1 | /**
2 | * @file S2LP_PktStack.c
3 | * @author ST Microelectronics
4 | * @version 1.3.0
5 | * @date June, 2019
6 | * @brief Configuration and management of S2-LP STack packets.
7 | * @details
8 | *
9 | * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
10 | * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
11 | * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
12 | * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
13 | * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
14 | * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
15 | *
16 | * THIS SOURCE CODE IS PROTECTED BY A LICENSE.
17 | * FOR MORE INFORMATION PLEASE CAREFULLY READ THE LICENSE AGREEMENT FILE LOCATED
18 | * IN THE ROOT DIRECTORY OF THIS FIRMWARE PACKAGE.
19 | *
20 | * © COPYRIGHT 2019 STMicroelectronics
21 | */
22 |
23 |
24 | /* Includes ------------------------------------------------------------------*/
25 | #include "S2LP.h"
26 |
27 |
28 | /**
29 | * @addtogroup S2LP_Libraries
30 | * @{
31 | */
32 |
33 |
34 | /**
35 | * @addtogroup S2LP_PktStack
36 | * @{
37 | */
38 |
39 | /**
40 | * @defgroup PktStack_Private_Defines Pkt STack Private Defines
41 | * @{
42 | */
43 | #define PKT_FORMAT_STACK_CODE (uint8_t)3
44 |
45 | /**
46 | *@}
47 | */
48 |
49 |
50 | /**
51 | * @defgroup PktStack_Private_Macros Pkt STack Private Macros
52 | * @{
53 | */
54 |
55 |
56 | #define IS_STACK_PREAMBLE_LENGTH IS_PREAMBLE_LEN
57 | #define IS_STACK_SYNC_LENGTH IS_SYNC_LEN
58 | #define IS_STACK_PKT_LEN_FIELD_WID IS_PKT_LEN_FIELD_WID
59 | #define IS_STACK_CRC_MODE IS_PKT_CRC_MODE
60 | #define IS_STACK_NMAX_RETX(NRETX) (NRETX<=15)
61 | #define IS_STACK_SEQNUM_RELOAD_VAL(VAL) (VAL<=3)
62 |
63 | /**
64 | *@}
65 | */
66 |
67 |
68 | /**
69 | * @defgroup PktStack_Private_Functions Pkt STack Private Functions
70 | * @{
71 | */
72 |
73 |
74 | /**
75 | * @brief Initialize the S2LP STack packet according to the specified
76 | * parameters in the PktStackInit.
77 | * @param pxPktStackInit STack packet init structure.
78 | * This parameter is a pointer to @ref PktStackInit.
79 | * @retval None.
80 | */
81 | void S2LP::S2LPPktStackInit(PktStackInit* pxPktStackInit)
82 | {
83 | uint8_t tmpBuffer[6];
84 |
85 | /* Check the parameters */
86 | s_assert_param(IS_STACK_PREAMBLE_LENGTH(pxPktStackInit->xPreambleLength));
87 | s_assert_param(IS_STACK_SYNC_LENGTH(pxPktStackInit->xSyncLength));
88 | s_assert_param(IS_STACK_CRC_MODE(pxPktStackInit->xCrcMode));
89 | s_assert_param(IS_SFUNCTIONAL_STATE(pxPktStackInit->cExtendedPktLenField));
90 | s_assert_param(IS_SFUNCTIONAL_STATE(pxPktStackInit->xFixVarLength));
91 | s_assert_param(IS_SFUNCTIONAL_STATE(pxPktStackInit->xFec));
92 | s_assert_param(IS_SFUNCTIONAL_STATE(pxPktStackInit->xDataWhitening));
93 |
94 | S2LPPktWMbusSetSubmode(WMBUS_SUBMODE_NOT_CONFIGURED);
95 |
96 | /* Always set the automatic packet filtering */
97 | S2LPSpiReadRegisters(PROTOCOL1_ADDR, 1, &tmpBuffer[0]);
98 | tmpBuffer[0] |= AUTO_PCKT_FLT_REGMASK;
99 | S2LPSpiWriteRegisters(PROTOCOL1_ADDR, 1, &tmpBuffer[0]);
100 |
101 | tmpBuffer[0] = ((pxPktStackInit->xSyncLength)<<2) | (uint8_t)((pxPktStackInit->xPreambleLength)>>8);
102 | tmpBuffer[1] = (uint8_t)(pxPktStackInit->xPreambleLength);
103 | tmpBuffer[2] = ((uint8_t)pxPktStackInit->cExtendedPktLenField)<<7 | ADDRESS_LEN_REGMASK;
104 |
105 | S2LPSpiReadRegisters(PCKTCTRL3_ADDR, 1, &tmpBuffer[3]);
106 | tmpBuffer[3] &= ~(PCKT_FRMT_REGMASK | RX_MODE_REGMASK);
107 | tmpBuffer[3] |= PKT_FORMAT_STACK_CODE<<6;
108 |
109 | S2LPSpiReadRegisters(PCKTCTRL2_ADDR, 2, &tmpBuffer[4]);
110 |
111 | if(pxPktStackInit->xFixVarLength == S_ENABLE) {
112 | tmpBuffer[4] |= FIX_VAR_LEN_REGMASK;
113 | }
114 | else {
115 | tmpBuffer[4] &= ~FIX_VAR_LEN_REGMASK;
116 | }
117 | tmpBuffer[4] &= ~(MANCHESTER_EN_REGMASK | MBUS_3OF6_EN_REGMASK);
118 |
119 | tmpBuffer[5] &= ~(CRC_MODE_REGMASK | TXSOURCE_REGMASK);
120 | tmpBuffer[5] |= (uint8_t)pxPktStackInit->xCrcMode;
121 |
122 | if(pxPktStackInit->xDataWhitening == S_ENABLE) {
123 | tmpBuffer[5] |= WHIT_EN_REGMASK;
124 | }
125 | else {
126 | tmpBuffer[5] &= ~WHIT_EN_REGMASK;
127 | }
128 |
129 | if(pxPktStackInit->xFec == S_ENABLE) {
130 | tmpBuffer[5] |= FEC_EN_REGMASK;
131 | }
132 | else {
133 | tmpBuffer[5] &= ~FEC_EN_REGMASK;
134 | }
135 |
136 | S2LPSpiWriteRegisters(PCKTCTRL6_ADDR, 6, tmpBuffer);
137 |
138 | /* SYNC word */
139 | for(uint8_t i=0 ; i<4 ; i++) {
140 | tmpBuffer[i] = (uint8_t)(pxPktStackInit->lSyncWords>>(8*i));
141 | }
142 | g_xStatus = S2LPSpiWriteRegisters(SYNC3_ADDR, 4, tmpBuffer);
143 |
144 | /* Sets CRC check bit */
145 | if(pxPktStackInit->xCrcMode == PKT_NO_CRC) {
146 | S2LPPktStackFilterOnCrc(S_DISABLE);
147 | }
148 | else {
149 | S2LPPktStackFilterOnCrc(S_ENABLE);
150 | }
151 | /* Constellation map setting */
152 | S2LPSpiReadRegisters(MOD1_ADDR, 1, tmpBuffer);
153 | tmpBuffer[0] &= ~G4FSK_CONST_MAP_REGMASK;
154 | S2LPSpiWriteRegisters(MOD1_ADDR, 1, tmpBuffer);
155 | }
156 |
157 |
158 | /**
159 | * @brief Return the S2LP STack packet structure according to the specified parameters in the registers.
160 | * @param pxPktStackInit STack packet init structure.
161 | * This parameter is a pointer to @ref PktStackInit.
162 | * @retval None.
163 | */
164 | void S2LP::S2LPPktStackGetInfo(PktStackInit* pxPktStackInit)
165 | {
166 | uint8_t tmpBuffer[6];
167 |
168 | S2LPSpiReadRegisters(PCKTCTRL6_ADDR, 6, tmpBuffer);
169 |
170 | /* Sync length */
171 | pxPktStackInit->xSyncLength = ((tmpBuffer[0] & SYNC_LEN_REGMASK)>>2);
172 |
173 | /* Preamble length */
174 | pxPktStackInit->xPreambleLength = (((uint16_t)(tmpBuffer[0] & PREAMBLE_LEN_9_8_REGMASK))<<8) | ((uint16_t)tmpBuffer[1]);
175 |
176 | /* Length width */
177 | pxPktStackInit->cExtendedPktLenField = (SFunctionalState)((tmpBuffer[2] & LEN_WID_REGMASK)>>7);
178 |
179 | /* FIX or VAR bit */
180 | pxPktStackInit->xFixVarLength = (SFunctionalState)(tmpBuffer[4] & FIX_VAR_LEN_REGMASK);
181 |
182 | /* CRC mode */
183 | pxPktStackInit->xCrcMode = (StackCrcMode)(tmpBuffer[5] & CRC_MODE_REGMASK);
184 |
185 | /* Whitening */
186 | pxPktStackInit->xDataWhitening = (SFunctionalState)((tmpBuffer[5] & WHIT_EN_REGMASK)>> 4);
187 |
188 | /* FEC */
189 | pxPktStackInit->xFec = (SFunctionalState)(tmpBuffer[5] & FEC_EN_REGMASK);
190 |
191 | g_xStatus = S2LPSpiReadRegisters(SYNC3_ADDR, 4, tmpBuffer);
192 |
193 | /* SYNC word */
194 | pxPktStackInit->lSyncWords = 0;
195 | for(uint8_t i=0 ; i<4 ; i++) {
196 | pxPktStackInit->lSyncWords |= ((uint32_t)tmpBuffer[i])<<(8*i);
197 | }
198 | }
199 |
200 |
201 | /**
202 | * @brief Initialize the S2LP STack packet addresses according to the specified
203 | * parameters in the PktStackAddresses struct.
204 | * @param pxPktStackAddresses STack packet addresses init structure.
205 | * This parameter is a pointer to @ref PktStackAddressesInit .
206 | * @retval None.
207 | */
208 | void S2LP::S2LPPktStackAddressesInit(PktStackAddressesInit* pxPktStackAddresses)
209 | {
210 | uint8_t tmpBuffer[3];
211 | s_assert_param(IS_SFUNCTIONAL_STATE(pxPktStackAddresses->xFilterOnMyAddress));
212 | s_assert_param(IS_SFUNCTIONAL_STATE(pxPktStackAddresses->xFilterOnMulticastAddress));
213 | s_assert_param(IS_SFUNCTIONAL_STATE(pxPktStackAddresses->xFilterOnBroadcastAddress));
214 |
215 | /* Reads the PCKT_FLT_OPTIONS ragister */
216 | S2LPSpiReadRegisters(PCKT_FLT_OPTIONS_ADDR, 1, &tmpBuffer[0]);
217 |
218 | /* Enables or disables filtering on my address */
219 | if(pxPktStackAddresses->xFilterOnMyAddress == S_ENABLE) {
220 | tmpBuffer[0] |= DEST_VS_SOURCE_ADDR_REGMASK;
221 | }
222 | else {
223 | tmpBuffer[0] &= ~DEST_VS_SOURCE_ADDR_REGMASK;
224 | }
225 |
226 | /* Enables or disables filtering on multicast address */
227 | if(pxPktStackAddresses->xFilterOnMulticastAddress == S_ENABLE) {
228 | tmpBuffer[0] |= DEST_VS_MULTICAST_ADDR_REGMASK;
229 | }
230 | else {
231 | tmpBuffer[0] &= ~DEST_VS_MULTICAST_ADDR_REGMASK;
232 | }
233 |
234 | /* Enables or disables filtering on broadcast address */
235 | if(pxPktStackAddresses->xFilterOnBroadcastAddress == S_ENABLE) {
236 | tmpBuffer[0] |= DEST_VS_BROADCAST_ADDR_REGMASK;
237 | }
238 | else {
239 | tmpBuffer[0] &= ~DEST_VS_BROADCAST_ADDR_REGMASK;
240 | }
241 |
242 | S2LPSpiWriteRegisters(PCKT_FLT_OPTIONS_ADDR, 1, &tmpBuffer[0]);
243 |
244 | /* Fills the array with the addresses passed in the structure */
245 | tmpBuffer[2] = pxPktStackAddresses->cMyAddress;
246 | tmpBuffer[0] = pxPktStackAddresses->cBroadcastAddress;
247 | tmpBuffer[1] = pxPktStackAddresses->cMulticastAddress;
248 | g_xStatus = S2LPSpiWriteRegisters(PCKT_FLT_GOALS2_ADDR, 3, tmpBuffer);
249 | }
250 |
251 |
252 | /**
253 | * @brief Return the S2LP STack packet addresses structure according to the specified
254 | * parameters in the registers.
255 | * @param pxPktStackAddresses STack packet addresses init structure.
256 | * This parameter is a pointer to @ref PktStackAddresses.
257 | * @retval None.
258 | */
259 | void S2LP::S2LPPktStackGetAddressesInfo(PktStackAddressesInit* pxPktStackAddresses)
260 | {
261 | uint8_t tmpBuffer[3];
262 |
263 | S2LPSpiReadRegisters(PCKT_FLT_GOALS3_ADDR, 3, tmpBuffer);
264 | pxPktStackAddresses->cMyAddress = tmpBuffer[0];
265 | pxPktStackAddresses->cBroadcastAddress = tmpBuffer[1];
266 | pxPktStackAddresses->cMulticastAddress = tmpBuffer[2];
267 |
268 | g_xStatus = S2LPSpiReadRegisters(PCKT_FLT_OPTIONS_ADDR, 1, &tmpBuffer[0]);
269 | pxPktStackAddresses->xFilterOnBroadcastAddress = (SFunctionalState)((tmpBuffer[0] & DEST_VS_BROADCAST_ADDR_REGMASK) >> 3);
270 | pxPktStackAddresses->xFilterOnMulticastAddress = (SFunctionalState)((tmpBuffer[0] & DEST_VS_MULTICAST_ADDR_REGMASK) >> 2);
271 | pxPktStackAddresses->xFilterOnMyAddress = (SFunctionalState)((tmpBuffer[0] & DEST_VS_SOURCE_ADDR_REGMASK) >> 1);
272 | }
273 |
274 |
275 | /**
276 | * @brief Configure the STack packet format for S2LP.
277 | * @param None.
278 | * @retval None.
279 | */
280 | void S2LP::S2LPPktStackSetFormat(void)
281 | {
282 | uint8_t tmp;
283 |
284 | S2LPSpiReadRegisters(PCKTCTRL3_ADDR, 1, &tmp);
285 |
286 | /* Build the new value. Also set to 0 the direct RX mode bits */
287 | tmp &= ~(PCKT_FRMT_REGMASK | RX_MODE_REGMASK);
288 | tmp |= PKT_FORMAT_STACK_CODE;
289 | S2LPSpiWriteRegisters(PCKTCTRL3_ADDR, 1, &tmp);
290 |
291 | S2LPSpiReadRegisters(PCKTCTRL1_ADDR, 1, &tmp);
292 |
293 | /* Set to 0 the direct TX mode bits */
294 | tmp &= ~TXSOURCE_REGMASK;
295 | g_xStatus = S2LPSpiWriteRegisters(PCKTCTRL1_ADDR, 1, &tmp);
296 |
297 | S2LPPktWMbusSetSubmode(WMBUS_SUBMODE_NOT_CONFIGURED);
298 | }
299 |
300 |
301 |
302 | /**
303 | * @brief Set the payload length for S2LP STack packets. Since the packet length
304 | * depends from the address (always 2 for this packet format)
305 | * and the control field size, this function reads the control length register
306 | * content in order to determine the correct packet length to be written.
307 | * @param nPayloadLength payload length in bytes.
308 | * This parameter can be any value of uint16_t.
309 | * @retval None.
310 | */
311 | void S2LP::S2LPPktStackSetPayloadLength(uint16_t nPayloadLength)
312 | {
313 | uint8_t tmpBuffer[2];
314 |
315 | nPayloadLength+=2;
316 | tmpBuffer[0] = (uint8_t)(nPayloadLength>>8);
317 | tmpBuffer[1] = (uint8_t)nPayloadLength;
318 | g_xStatus = S2LPSpiWriteRegisters(PCKTLEN1_ADDR, 2, tmpBuffer);
319 | }
320 |
321 |
322 | /**
323 | * @brief Return the payload length for S2LP STack packets. Since the
324 | * packet length depends from the address and the control
325 | * field size, this function reads the correspondent
326 | * registers in order to determine the correct payload length
327 | * to be returned.
328 | * @param None.
329 | * @retval uint16_t Payload length.
330 | */
331 | uint16_t S2LP::S2LPPktStackGetPayloadLength(void)
332 | {
333 | uint8_t tmpBuffer[2];
334 | uint16_t nPayloadLength;
335 |
336 | g_xStatus = S2LPSpiReadRegisters(PCKTLEN1_ADDR, 2, tmpBuffer);
337 | nPayloadLength = (((uint16_t)tmpBuffer[0])<<8) | ((uint16_t)tmpBuffer[1]);
338 | nPayloadLength-=2;
339 |
340 | return nPayloadLength;
341 | }
342 |
343 |
344 | /**
345 | * @brief Return the packet length field of the received packet.
346 | * @param None.
347 | * @retval uint16_t Packet length.
348 | */
349 | uint16_t S2LP::S2LPPktStackGetReceivedPktLength(void)
350 | {
351 | uint8_t tmpBuffer[2];
352 | uint16_t nPayloadLength;
353 |
354 | g_xStatus = S2LPSpiReadRegisters(RX_PCKT_LEN1_ADDR, 2, tmpBuffer);
355 | nPayloadLength = (((uint16_t)tmpBuffer[0])<<8) | ((uint16_t)tmpBuffer[1]);
356 | nPayloadLength--;
357 |
358 | return nPayloadLength;
359 | }
360 |
361 |
362 | /**
363 | * @brief Se the AUTO_ACK bit on the receiver .
364 | * @param xNewState if S_ENABLE, the receiver will check the NO_ACK bit to see if the ack should be sent (NO_ACK=0) or not (NO_ACK=1).
365 | * @retval None.
366 | */
367 | void S2LP::S2LPPktStackAutoAck(SFunctionalState xNewState)
368 | {
369 | uint8_t tmp;
370 | s_assert_param(IS_SFUNCTIONAL_STATE(xNewState));
371 |
372 | S2LPSpiReadRegisters(PROTOCOL0_ADDR, 1, &tmp);
373 | if(xNewState == S_ENABLE) {
374 | tmp |= AUTO_ACK_REGMASK;
375 | }
376 | else {
377 | tmp &= ~AUTO_ACK_REGMASK;
378 | }
379 | g_xStatus = S2LPSpiWriteRegisters(PROTOCOL0_ADDR, 1, &tmp);
380 |
381 | }
382 |
383 |
384 | /**
385 | * @brief Set the number of retransmissions to be done in case of ACK loss.
386 | * @param nRetx number of retransmissions.
387 | * @retval None.
388 | */
389 | void S2LP::S2LPPktStackNRetx(uint8_t nRetx)
390 | {
391 | uint8_t tmp;
392 | s_assert_param(IS_STACK_NMAX_RETX(nRetx));
393 |
394 | S2LPSpiReadRegisters(PROTOCOL0_ADDR, 1, &tmp);
395 | tmp &= ~NMAX_RETX_REGMASK;
396 | tmp |= (nRetx<<4);
397 | g_xStatus = S2LPSpiWriteRegisters(PROTOCOL0_ADDR, 1, &tmp);
398 |
399 | }
400 |
401 |
402 | /**
403 | * @brief Get the NO_ACK bit.
404 | * @param None.
405 | * @retval SFlagStatus if it is S_SET, the ack will be not requested, otherwise it will be.
406 | */
407 | SFlagStatus S2LP::S2LPPktStackGetTXAckRequest(void)
408 | {
409 | uint8_t tmp;
410 |
411 | S2LPSpiReadRegisters(RX_PCKT_INFO_ADDR, 1, &tmp);
412 | tmp &= NACK_RX_REGMASK;
413 | tmp >>= 2;
414 | return (SFlagStatus)tmp;
415 | }
416 |
417 | /**
418 | * @brief This function will set the NO_ACK bit or reset it.
419 | * @param xNewState if it is S_DISABLE, the ack will be not request and thus the NO_ACK bit will be set to 1.
420 | * if this parameter is S_ENABLE, the ack will be request and thus the NO_ACK bit will be set to 0.
421 | * @retval None.
422 | */
423 | void S2LP::S2LPPktStackAckRequest(SFunctionalState xNewState)
424 | {
425 | uint8_t tmp;
426 | s_assert_param(IS_SFUNCTIONAL_STATE(xNewState));
427 |
428 | S2LPSpiReadRegisters(PROTOCOL0_ADDR, 1, &tmp);
429 | if(xNewState == S_ENABLE) {
430 | tmp &= ~NACK_TX_REGMASK;
431 | }
432 | else {
433 | tmp |= NACK_TX_REGMASK;
434 | }
435 | g_xStatus = S2LPSpiWriteRegisters(PROTOCOL0_ADDR, 1, &tmp);
436 |
437 | }
438 |
439 |
440 | /**
441 | * @brief Enable or Disable the piggybacking.
442 | * @param xNewState enable or disable.
443 | * @retval None.
444 | */
445 | void S2LP::S2LPPktStackPiggybacking(SFunctionalState xNewState)
446 | {
447 | uint8_t tmp;
448 | s_assert_param(IS_SFUNCTIONAL_STATE(xNewState));
449 |
450 | S2LPSpiReadRegisters(PROTOCOL1_ADDR, 1, &tmp);
451 | if(xNewState == S_ENABLE) {
452 | tmp |= PIGGYBACKING_REGMASK;
453 | }
454 | else {
455 | tmp &= ~PIGGYBACKING_REGMASK;
456 | }
457 | g_xStatus = S2LPSpiWriteRegisters(PROTOCOL1_ADDR, 1, &tmp);
458 |
459 | }
460 |
461 |
462 | /**
463 | * @brief Set the reload value of the sequence number.
464 | * @note A SEQ_NUM_RELOAD command must be strobed to make this value available for the next packet.
465 | * @param cReloadValue reload value.
466 | * @retval None.
467 | */
468 | void S2LP::S2LPPktStackSeqNumForReload(uint8_t cReloadValue)
469 | {
470 | uint8_t tmp;
471 | s_assert_param(IS_STACK_SEQNUM_RELOAD_VAL(cReloadValue));
472 |
473 | S2LPSpiReadRegisters(PROTOCOL2_ADDR, 1, &tmp);
474 | tmp &= ~TX_SEQ_NUM_RELOAD_REGMASK;
475 | tmp |= (cReloadValue<<3);
476 | g_xStatus = S2LPSpiWriteRegisters(PROTOCOL2_ADDR, 1, &tmp);
477 | }
478 |
479 | /**
480 | * @brief Returns the number of retransmission done on the transmitted packet.
481 | * @param None.
482 | * @retval uint8_t Number of retransmissions done until now.
483 | */
484 | uint8_t S2LP::S2LPPktStackGetNReTx(void)
485 | {
486 | uint8_t tempRetValue;
487 |
488 | /* Reads the TX_PCKT_INFO register value */
489 | g_xStatus = S2LPSpiReadRegisters(TX_PCKT_INFO_ADDR, 1, &tempRetValue);
490 |
491 | /* Obtains and returns the number of retransmission done */
492 | return (tempRetValue & N_RETX_REGMASK);
493 |
494 | }
495 |
496 |
497 | /**
498 | *@}
499 | */
500 |
501 | /**
502 | *@}
503 | */
504 |
505 |
506 | /**
507 | *@}
508 | */
509 |
510 |
511 |
512 | /******************* (C) COPYRIGHT 2019 STMicroelectronics *****END OF FILE****/
513 |
--------------------------------------------------------------------------------
/src/S2LP_PktStack.h:
--------------------------------------------------------------------------------
1 | /**
2 | * @file S2LP_PktStack.h
3 | * @author ST Microelectronics
4 | * @version 1.3.0
5 | * @date June, 2019
6 | * @brief Configuration and management of S2-LP STack packets.
7 | * @details
8 | *
9 | * This module can be used to manage the configuration of S2LP STack
10 | * packets, and it is quite similar to the Basic packets one since the
11 | * STack packets can be considered an extension of Basic.
12 | * The user can obtain a packet configuration filling the structure
13 | * @ref PktStackInit, defining in it some general parameters
14 | * for the S2-LP STack packet format.
15 | * Another structure the user can fill is @ref PktStackAddressesInit
16 | * to define the addresses which will be used during the communication.
17 | * Moreover, functions to set the payload length and the destination address
18 | * are provided.
19 | *
20 | * Example:
21 | * @code
22 | *
23 | * PktStackInit stackInit={
24 | * 32, // preamble length in bits
25 | * 32, // sync word length in bits
26 | * 0x88888888, // sync word
27 | * S_ENABLE, // variable or fixed payload length
28 | * S_DISABLE, // extended length field width (used only for variable length)
29 | * PKT_NO_CRC, // CRC mode
30 | * S_DISABLE, // FEC
31 | * S_ENABLE // whitening
32 | * };
33 | *
34 | * PktStackAddressesInit addressInit={
35 | * S_ENABLE, // enable/disable filtering on my address
36 | * 0x34, // my address (address of the current node)
37 | * S_DISABLE, // enable/disable filtering on multicast address
38 | * 0xEE, // multicast address
39 | * S_DISABLE, // enable/disable filtering on broadcast address
40 | * 0xFF // broadcast address
41 | * };
42 | *
43 | * ...
44 | *
45 | * S2LPPktStackInit(&stackInit);
46 | * S2LPPktStackAddressesInit(&addressInit);
47 | *
48 | * ...
49 | *
50 | * S2LPPktStackSetPayloadLength(20);
51 | * S2LPPktStackSetDestinationAddress(0x44);
52 | *
53 | * ...
54 | *
55 | * @endcode
56 | *
57 | * The module provides some other functions that can be used to modify
58 | * or read only some configuration parameters.
59 | *
60 | *
61 | * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
62 | * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
63 | * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
64 | * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
65 | * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
66 | * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
67 | *
68 | * THIS SOURCE CODE IS PROTECTED BY A LICENSE.
69 | * FOR MORE INFORMATION PLEASE CAREFULLY READ THE LICENSE AGREEMENT FILE LOCATED
70 | * IN THE ROOT DIRECTORY OF THIS FIRMWARE PACKAGE.
71 | *
72 | * © COPYRIGHT 2015 STMicroelectronics
73 | */
74 |
75 | /* Define to prevent recursive inclusion -------------------------------------*/
76 | #ifndef __S2LP_PKT_STACK_H
77 | #define __S2LP_PKT_STACK_H
78 |
79 | /* Includes ------------------------------------------------------------------*/
80 |
81 | #include "S2LP_Regs.h"
82 | #include "S2LP_Types.h"
83 | #include "S2LP_PacketHandler.h"
84 |
85 |
86 | #ifdef __cplusplus
87 | extern "C" {
88 | #endif
89 |
90 |
91 | /**
92 | * @addtogroup S2LP_Libraries
93 | * @{
94 | */
95 |
96 |
97 | /**
98 | * @defgroup S2LP_PktStack Pkt STack
99 | * @brief Configuration and management of S2LP STack packets.
100 | * @details See the file @ref S2LP_PktStack.h for more details.
101 | * @{
102 | */
103 |
104 | /**
105 | * @defgroup PktStack_Exported_Types Pkt STack Exported Types
106 | * @{
107 | */
108 |
109 |
110 | /**
111 | * @brief CRC length in bytes enumeration.
112 | */
113 | typedef PktCrcMode StackCrcMode;
114 |
115 |
116 | /**
117 | * @brief S2LP STack Packet Init structure definition.
118 | */
119 | typedef struct {
120 | uint16_t xPreambleLength; /*!< Set the preamble length of packet. From 1 to 1024 chip sequence. */
121 | uint8_t xSyncLength; /*!< Set the sync word length of packet in bits. From 1 to 64 bits. */
122 | uint32_t lSyncWords; /*!< Set the sync words in MSB. */
123 | SFunctionalState xFixVarLength; /*!< Enable the variable length mode. */
124 | SFunctionalState cExtendedPktLenField; /*!< Extend the length field from 1 byte to 2 bytes. Variable length mode only. */
125 | StackCrcMode xCrcMode; /*!< Set the CRC type. @ref StackCrcMode */
126 | SFunctionalState xFec; /*!< Enable the FEC/Viterbi. */
127 | SFunctionalState xDataWhitening; /*!< Enable the data whitening. */
128 | } PktStackInit;
129 |
130 |
131 | /**
132 | * @brief S2LP STack packet address structure definition. This structure allows users to specify
133 | * the node/multicast/broadcast addresses and the correspondent filtering options.
134 | */
135 | typedef struct {
136 | SFunctionalState xFilterOnMyAddress; /*!< If set packet is received if its destination address matches with cMyAddress. */
137 | uint8_t cMyAddress; /*!< Set the MyAddress. */
138 | SFunctionalState xFilterOnMulticastAddress; /*!< If set packet is received if its destination address matches with cMulticastAddress. */
139 | uint8_t cMulticastAddress; /*!< Set the Multicast address */
140 | SFunctionalState xFilterOnBroadcastAddress; /*!< If set packet is received if its destination address matches with cBroadcastAddress. */
141 | uint8_t cBroadcastAddress; /*!< Set the Broadcast address */
142 | } PktStackAddressesInit;
143 |
144 |
145 | /**
146 | *@}
147 | */
148 |
149 |
150 | /**
151 | * @defgroup PktStack_Exported_Macros Pkt STack Exported Macros
152 | * @{
153 | */
154 |
155 | /**
156 | * @brief Sets the PREAMBLE Length mode for S2LP STack packets.
157 | * @param xPreambleLength length of PREAMBLE field in bytes.
158 | * This parameter can be any value of @ref StackPreambleLength.
159 | * @retval None.
160 | */
161 | #define S2LPPktStackSetPreambleLength(xPreambleLength) S2LPSetPreambleLength(xPreambleLength)
162 |
163 |
164 | /**
165 | * @brief Returns the PREAMBLE Length mode for S2LP STack packets.
166 | * @param None.
167 | * @retval uint8_t Preamble length in bytes.
168 | */
169 | #define S2LPPktStackGetPreambleLength() S2LPGetPreambleLength()
170 |
171 |
172 | /**
173 | * @brief Sets the SYNC Length for S2LP STack packets.
174 | * @param xSyncLength length of SYNC field in bytes.
175 | * This parameter can be any value of @ref StackSyncLength.
176 | * @retval None.
177 | */
178 | #define S2LPPktStackSetSyncLength(xSyncLength) S2LPSetSyncLength((PktSyncLength)xSyncLength)
179 |
180 |
181 | /**
182 | * @brief Returns the SYNC Length for S2LP STack packets.
183 | * @param None.
184 | * @retval uint8_t Sync length in bytes.
185 | */
186 | #define S2LPPktStackGetSyncLength() S2LPGetSyncLength()
187 |
188 |
189 |
190 | /**
191 | * @brief Enables or Disables the CRC filtering.
192 | * @param xNewState new state for CRC_CHECK.
193 | * This parameter can be S_ENABLE or S_DISABLE.
194 | * @retval None.
195 | */
196 | #define S2LPPktStackFilterOnCrc(xNewState) S2LPPktCommonFilterOnCrc(xNewState)
197 |
198 |
199 |
200 | /**
201 | * @brief Enables or Disables WHITENING for S2LP STack packets.
202 | * @param xNewState new state for WHITENING mode.
203 | * This parameter can be S_ENABLE or S_DISABLE.
204 | * @retval None.
205 | */
206 | #define S2LPPktStackWhitening(xNewState) S2LPWhitening(xNewState)
207 |
208 |
209 | /**
210 | * @brief Enables or Disables FEC for S2LP STack packets.
211 | * @param xNewState new state for FEC mode.
212 | * This parameter can be S_ENABLE or S_DISABLE.
213 | * @retval None.
214 | */
215 | #define S2LPPktStackFec(xNewState) S2LPFec(xNewState)
216 |
217 |
218 | /**
219 | * @brief Sets multiple SYNC words for S2LP STack packets.
220 | * @param lSyncWords SYNC words to be set with format: 0x|SYNC1|SYNC2|SYNC3|SYNC4|.
221 | * This parameter is a uint32_t.
222 | * @param xSyncLength SYNC length in bytes. The 32bit word passed will be stored in the SYNCx registers from the MSb
223 | * until the number of bytes in xSyncLength has been stored.
224 | * This parameter is a @ref StackSyncLength.
225 | * @retval None.
226 | */
227 | #define S2LPPktStackSetSyncWords(lSyncWords, xSyncLength) S2LPSetSyncWords(lSyncWords,xSyncLength)
228 |
229 |
230 | /**
231 | *@}
232 | */
233 |
234 |
235 | /**
236 | *@}
237 | */
238 |
239 |
240 | /**
241 | *@}
242 | */
243 |
244 | #ifdef __cplusplus
245 | }
246 | #endif
247 |
248 | #endif
249 |
250 | /******************* (C) COPYRIGHT 2015 STMicroelectronics *****END OF FILE****/
251 |
--------------------------------------------------------------------------------
/src/S2LP_PktWMbus.cpp:
--------------------------------------------------------------------------------
1 | /**
2 | * @file S2LP_PktWMbus.c
3 | * @author ST Microelectronics
4 | * @version 1.3.0
5 | * @date June, 2019
6 | * @brief Configuration and management of S2-LP WMBUS packets.
7 | * @details
8 | *
9 | * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
10 | * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
11 | * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
12 | * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
13 | * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
14 | * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
15 | *
16 | * THIS SOURCE CODE IS PROTECTED BY A LICENSE.
17 | * FOR MORE INFORMATION PLEASE CAREFULLY READ THE LICENSE AGREEMENT FILE LOCATED
18 | * IN THE ROOT DIRECTORY OF THIS FIRMWARE PACKAGE.
19 | *
20 | * © COPYRIGHT 2019 STMicroelectronics
21 | */
22 |
23 |
24 | /* Includes ------------------------------------------------------------------*/
25 | #include "S2LP.h"
26 |
27 | /**
28 | * @addtogroup S2LP_Libraries
29 | * @{
30 | */
31 |
32 |
33 | /**
34 | * @addtogroup S2LP_PktWMbus
35 | * @{
36 | */
37 |
38 |
39 |
40 | /**
41 | * @defgroup PktWMbus_Private_Defines Pkt WMBUS Private Defines
42 | * @{
43 | */
44 | #define PKT_FORMAT_WMBUS_CODE 0x00
45 |
46 | #define WMBUS_PREAMBLE_LEN_S1S2LONGHEADER (uint16_t)279
47 | #define WMBUS_PREAMBLE_LEN_S1MS2T2OTHERTOMETER (uint16_t)15
48 | #define WMBUS_PREAMBLE_LEN_T1T2METERTOOTHER (uint16_t)19
49 | #define WMBUS_PREAMBLE_LEN_R2 (uint16_t)39
50 | #define WMBUS_PREAMBLE_LEN_N1N2 (uint16_t)8
51 |
52 | #define WMBUS_SYNC_LEN_S1S2LONGHEADER (uint8_t)18
53 | #define WMBUS_SYNC_LEN_S1MS2T2OTHERTOMETER (uint8_t)18
54 | #define WMBUS_SYNC_LEN_T1T2METERTOOTHER (uint8_t)10
55 | #define WMBUS_SYNC_LEN_R2 (uint8_t)18
56 | #define WMBUS_SYNC_LEN_N1N2 (uint16_t)16
57 |
58 | #define WMBUS_SYNCWORD_S1S2LONGHEADER (uint32_t)0xE25A4000
59 | #define WMBUS_SYNCWORD_S1MS2T2OTHERTOMETER (uint32_t)0xE25A4000
60 | #define WMBUS_SYNCWORD_T1T2METERTOOTHER (uint32_t)0x0F400000
61 | #define WMBUS_SYNCWORD_R2 (uint32_t)0xE25A4000
62 | #define WMBUS_SYNCWORD_N1N2 (uint32_t)0xf68d0000
63 | /**
64 | *@}
65 | */
66 |
67 |
68 | /**
69 | * @defgroup PktWMbus_Private_Macros Pkt WMBUS Private Macros
70 | * @{
71 | */
72 |
73 | #define IS_WMBUS_SUBMODE(MODE) (((MODE) == WMBUS_SUBMODE_S1_S2_LONG_HEADER) || \
74 | ((MODE) == WMBUS_SUBMODE_NOT_CONFIGURED) || \
75 | ((MODE) == WMBUS_SUBMODE_S1_M_S2_T2_OTHER_TO_METER) || \
76 | ((MODE) == WMBUS_SUBMODE_T1_T2_METER_TO_OTHER) || \
77 | ((MODE) == WMBUS_SUBMODE_R2_SHORT_HEADER))
78 |
79 | /**
80 | *@}
81 | */
82 |
83 |
84 | /**
85 | * @defgroup PktWMbus_Private_Functions Pkt WMBUS Private Functions
86 | * @{
87 | */
88 |
89 |
90 | /**
91 | * @brief Initialize the S2LP WMBUS packet according to the specified parameters in the PktWMbusInit struct.
92 | * @param pxPktWMbusInit pointer to a PktWMbusInit structure that contains the configuration information for the specified S2LP WMBUS PACKET FORMAT.
93 | * This parameter is a pointer to @ref PktWMbusInit.
94 | * @retval None.
95 | */
96 | void S2LP::S2LPPktWMbusInit(PktWMbusInit* pxPktWMbusInit)
97 | {
98 | uint8_t tmp;
99 | s_assert_param(IS_WMBUS_SUBMODE(pxPktWMbusInit->xWMbusSubmode));
100 |
101 | /* Packet format config */
102 | S2LPPktWMbusSetFormat();
103 | S2LPPktCommonFilterOnCrc(S_DISABLE);
104 |
105 | s_cWMbusSubmode = pxPktWMbusInit->xWMbusSubmode;
106 |
107 | if(s_cWMbusSubmode==WMBUS_SUBMODE_S1_S2_LONG_HEADER) {
108 | S2LPSetPreambleLength(((uint16_t)pxPktWMbusInit->cPreambleLength) + WMBUS_PREAMBLE_LEN_S1S2LONGHEADER);
109 | S2LPSetSyncLength(WMBUS_SYNC_LEN_S1S2LONGHEADER);
110 | S2LPSetSyncWords(WMBUS_SYNCWORD_S1S2LONGHEADER, WMBUS_SYNC_LEN_S1S2LONGHEADER);
111 | S2LPPacketHandlerManchester(S_ENABLE);
112 |
113 | /* Constellation map setting */
114 | S2LPSpiReadRegisters(MOD1_ADDR, 1, &tmp);
115 | tmp &= ~G4FSK_CONST_MAP_REGMASK;
116 | tmp |= (((uint8_t)2)<<4);
117 | S2LPSpiWriteRegisters(MOD1_ADDR, 1, &tmp);
118 |
119 | S2LPSpiReadRegisters(0xF1, 1, &tmp);
120 | if((tmp&0xC0)==0xC0)
121 | S2LPPktWMbusSetPostamblePattern(0x01);
122 | }
123 | else if(s_cWMbusSubmode==WMBUS_SUBMODE_S1_M_S2_T2_OTHER_TO_METER) {
124 | S2LPSetPreambleLength(((uint16_t)pxPktWMbusInit->cPreambleLength) + WMBUS_PREAMBLE_LEN_S1MS2T2OTHERTOMETER);
125 | S2LPSetSyncLength(WMBUS_SYNC_LEN_S1MS2T2OTHERTOMETER);
126 | S2LPSetSyncWords(WMBUS_SYNCWORD_S1MS2T2OTHERTOMETER, WMBUS_SYNC_LEN_S1MS2T2OTHERTOMETER);
127 | S2LPPacketHandlerManchester(S_ENABLE);
128 | /* Constellation map setting */
129 | S2LPSpiReadRegisters(MOD1_ADDR, 1, &tmp);
130 | tmp &= ~G4FSK_CONST_MAP_REGMASK;
131 | tmp |= (((uint8_t)2)<<4);
132 | S2LPSpiWriteRegisters(MOD1_ADDR, 1, &tmp);
133 |
134 | S2LPSpiReadRegisters(0xF1, 1, &tmp);
135 | if((tmp&0xC0)==0xC0)
136 | S2LPPktWMbusSetPostamblePattern(0x01);
137 | }
138 | else if(s_cWMbusSubmode==WMBUS_SUBMODE_T1_T2_METER_TO_OTHER) {
139 | S2LPSetPreambleLength(((uint16_t)pxPktWMbusInit->cPreambleLength) + WMBUS_PREAMBLE_LEN_T1T2METERTOOTHER);
140 | S2LPSetSyncLength(WMBUS_SYNC_LEN_T1T2METERTOOTHER);
141 | S2LPSetSyncWords(WMBUS_SYNCWORD_T1T2METERTOOTHER, WMBUS_SYNC_LEN_T1T2METERTOOTHER);
142 | S2LPPacketHandler3OutOf6(S_ENABLE);
143 | }
144 | else if(s_cWMbusSubmode==WMBUS_SUBMODE_R2_SHORT_HEADER) {
145 | S2LPSetPreambleLength(((uint16_t)pxPktWMbusInit->cPreambleLength) + WMBUS_PREAMBLE_LEN_R2);
146 | S2LPSetSyncLength(WMBUS_SYNC_LEN_R2);
147 | S2LPSetSyncWords(WMBUS_SYNCWORD_R2, WMBUS_SYNC_LEN_R2);
148 | S2LPPacketHandlerManchester(S_ENABLE);
149 | /* Constellation map setting */
150 | S2LPSpiReadRegisters(MOD1_ADDR, 1, &tmp);
151 | tmp &= ~G4FSK_CONST_MAP_REGMASK;
152 | tmp |= (((uint8_t)2)<<4);
153 | S2LPSpiWriteRegisters(MOD1_ADDR, 1, &tmp);
154 | }
155 |
156 |
157 | S2LPPktWMbusSetPostamble(pxPktWMbusInit->cPostambleLength);
158 | }
159 |
160 | /**
161 | * @brief Return the S2LP WMBUS packet structure according to the specified parameters in the registers.
162 | * @param pxPktWMbusInit WMBUS packet init structure.
163 | * This parameter is a pointer to @ref PktWMbusInit.
164 | * @retval None.
165 | */
166 | void S2LP::S2LPPktWMbusGetInfo(PktWMbusInit* pxPktWMbusInit)
167 | {
168 | uint16_t tmp;
169 |
170 | tmp = S2LPGetPreambleLength();
171 |
172 | if(s_cWMbusSubmode==WMBUS_SUBMODE_S1_S2_LONG_HEADER) {
173 | if(tmp>=WMBUS_PREAMBLE_LEN_S1S2LONGHEADER)
174 | tmp -= WMBUS_PREAMBLE_LEN_S1S2LONGHEADER;
175 | }
176 | else if(s_cWMbusSubmode==WMBUS_SUBMODE_S1_M_S2_T2_OTHER_TO_METER) {
177 | if(tmp>=WMBUS_PREAMBLE_LEN_S1MS2T2OTHERTOMETER)
178 | tmp -= WMBUS_PREAMBLE_LEN_S1MS2T2OTHERTOMETER;
179 | }
180 | else if(s_cWMbusSubmode==WMBUS_SUBMODE_T1_T2_METER_TO_OTHER) {
181 | if(tmp>=WMBUS_PREAMBLE_LEN_T1T2METERTOOTHER)
182 | tmp -= WMBUS_PREAMBLE_LEN_T1T2METERTOOTHER;
183 | }
184 | else if(s_cWMbusSubmode==WMBUS_SUBMODE_R2_SHORT_HEADER) {
185 | if(tmp>=WMBUS_PREAMBLE_LEN_R2)
186 | tmp -= WMBUS_PREAMBLE_LEN_R2;
187 | }
188 |
189 | pxPktWMbusInit->cPreambleLength = (uint8_t)tmp;
190 | pxPktWMbusInit->cPostambleLength = S2LPPktWMbusGetPostamble();
191 | pxPktWMbusInit->xWMbusSubmode = s_cWMbusSubmode;
192 |
193 | }
194 |
195 |
196 | /**
197 | * @brief Configure the WMBUS packet format as the one used by S2LP.
198 | * @param None.
199 | * @retval None.
200 | */
201 | void S2LP::S2LPPktWMbusSetFormat(void)
202 | {
203 | uint8_t tmpBuffer[4] = {0,0,0,0};
204 |
205 | /* Configure the WMBUS mode packet format and reset all the other setting */
206 | tmpBuffer[1] |= PKT_FORMAT_WMBUS_CODE;
207 | g_xStatus = S2LPSpiWriteRegisters(PCKTCTRL4_ADDR, 4, tmpBuffer);
208 |
209 | }
210 |
211 |
212 |
213 | /**
214 | * @brief Set how many chips will be used in postamble
215 | * @param cPostamble the number of chip sequence.
216 | * This parameter is an uint8_t.
217 | * @retval None.
218 | */
219 | void S2LP::S2LPPktWMbusSetPostamble(uint8_t cPostamble)
220 | {
221 | uint8_t tmp;
222 | g_xStatus = S2LPSpiReadRegisters(PCKT_PSTMBL_ADDR, 1, &tmp);
223 | tmp = (tmp & 0xC0) | cPostamble;
224 | g_xStatus = S2LPSpiWriteRegisters(PCKT_PSTMBL_ADDR, 1, &tmp);
225 | }
226 |
227 |
228 | /**
229 | * @brief Set the pattern of the postamble.
230 | * @param cPostamble id the preamble pattern:
231 | * This parameter can be '00','01','10' or '11'.
232 | * This parameter is an uint8_t.
233 | * @retval None.
234 | */
235 | void S2LP::S2LPPktWMbusSetPostamblePattern(uint8_t cPostamble)
236 | {
237 | uint8_t tmp;
238 | g_xStatus = S2LPSpiReadRegisters(PCKT_PSTMBL_ADDR, 1, &tmp);
239 | tmp = (tmp & 0x3F) | (cPostamble<<6);
240 | g_xStatus = S2LPSpiWriteRegisters(PCKT_PSTMBL_ADDR, 1, &tmp);
241 | }
242 |
243 |
244 | /**
245 | * @brief Returns how many chips are used in the postamble
246 | * @param None.
247 | * @retval uint8_t Postamble in number chip sequences.
248 | */
249 | uint8_t S2LP::S2LPPktWMbusGetPostamble(void)
250 | {
251 | uint8_t tmp;
252 | g_xStatus = S2LPSpiReadRegisters(PCKT_PSTMBL_ADDR, 1, &tmp);
253 | return (tmp & 0x3F);
254 | }
255 |
256 |
257 | /**
258 | * @brief Returns the pattern of the postamble.
259 | * @param None.
260 | * @retval uint8_t Postamble in chips.
261 | */
262 | uint8_t S2LP::S2LPPktWMbusGetPostamblePattern(void)
263 | {
264 | uint8_t tmp;
265 | g_xStatus = S2LPSpiReadRegisters(PCKT_PSTMBL_ADDR, 1, &tmp);
266 | return ((tmp & 0xC0)>>6);
267 | }
268 |
269 |
270 | /**
271 | * @brief Set the W-MBus submode.
272 | * @param xWMbusSubmode This parameter of @ref WMbusSubmode .
273 | * @retval None.
274 | */
275 | void S2LP::S2LPPktWMbusSetSubmode(WMbusSubmode xWMbusSubmode)
276 | {
277 | s_cWMbusSubmode = xWMbusSubmode;
278 | }
279 |
280 |
281 | /**
282 | * @brief Return the WMBUS submode used.
283 | * @param None.
284 | * @retval WMbusSubmode WMBUS submode.
285 | */
286 | WMbusSubmode S2LP::S2LPPktWMbusGetSubmode(void)
287 | {
288 | return s_cWMbusSubmode;
289 | }
290 |
291 |
292 | /**
293 | * @brief Sets the payload length for S2LP WMBUS packets.
294 | * @param nPayloadLength payload length in bytes.
295 | * This parameter is an uint16_t.
296 | * @retval None.
297 | */
298 | void S2LP::S2LPPktWMbusSetPayloadLength(uint16_t nPayloadLength)
299 | {
300 | uint8_t tmpBuffer[2];
301 |
302 | tmpBuffer[0] = (uint8_t)(nPayloadLength>>8);
303 | tmpBuffer[1] = (uint8_t)nPayloadLength;
304 | g_xStatus = S2LPSpiWriteRegisters(PCKTLEN1_ADDR, 2, tmpBuffer);
305 | }
306 |
307 |
308 | /**
309 | * @brief Return the payload length for WMBUS packets.
310 | * @param None.
311 | * @retval uint16_t Payload length in bytes.
312 | */
313 | uint16_t S2LP::S2LPPktWMbusGetPayloadLength(void)
314 | {
315 | uint8_t tmpBuffer[2];
316 | uint16_t nPayloadLength;
317 |
318 | g_xStatus = S2LPSpiReadRegisters(PCKTLEN1_ADDR, 2, tmpBuffer);
319 | nPayloadLength = (((uint16_t)tmpBuffer[0])<<8) | ((uint16_t)tmpBuffer[1]);
320 |
321 | return nPayloadLength;
322 | }
323 |
324 | /**
325 | *@}
326 | */
327 |
328 | /**
329 | *@}
330 | */
331 |
332 |
333 | /**
334 | *@}
335 | */
336 |
337 |
338 |
339 |
340 |
341 | /******************* (C) COPYRIGHT 2019 STMicroelectronics *****END OF FILE****/
342 |
--------------------------------------------------------------------------------
/src/S2LP_PktWMbus.h:
--------------------------------------------------------------------------------
1 | /**
2 | * @file S2LP_PktWMbus.h
3 | * @author ST Microelectronics
4 | * @version 1.3.0
5 | * @date June, 2019
6 | * @brief Configuration and management of S2-LP WMbus packets.
7 | * @details
8 | *
9 | * This module can be used to manage the configuration of S2-LP WMbus
10 | * packets.
11 | * The user can obtain a packet configuration filling the structure
12 | * @ref PktWMbusInit, defining in it some general parameters
13 | * for the S2-LP WMbus packet format.
14 | * Since the WMbus protocol is a standard, the configuration of a WMbus
15 | * packet is very simple to do.
16 | *
17 | * Example:
18 | * @code
19 | *
20 | * PktWMbusInit mbusInit={
21 | * WMbus_SUBMODE_S1_S2_LONG_HEADER, // WMbus submode selection
22 | * 36, // added "01" chips on preamble
23 | * 16 // postamble length in "01" chips
24 | * };
25 | *
26 | * ...
27 | *
28 | * S2LPPktWMbusInit(&mbusInit);
29 | *
30 | * ...
31 | *
32 | * @endcode
33 | *
34 | * The module provides some other functions that can be used to modify
35 | * or read only some configuration parameters.
36 | *
37 | * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
38 | * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
39 | * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
40 | * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
41 | * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
42 | * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
43 | *
44 | * THIS SOURCE CODE IS PROTECTED BY A LICENSE.
45 | * FOR MORE INFORMATION PLEASE CAREFULLY READ THE LICENSE AGREEMENT FILE LOCATED
46 | * IN THE ROOT DIRECTORY OF THIS FIRMWARE PACKAGE.
47 | *
48 | * © COPYRIGHT 2019 STMicroelectronics
49 | */
50 |
51 | /* Define to prevent recursive inclusion -------------------------------------*/
52 | #ifndef __S2LP_PACKET_WMBUS_H
53 | #define __S2LP_PACKET_WMBUS_H
54 |
55 |
56 | /* Includes ------------------------------------------------------------------*/
57 |
58 | #include "S2LP_Regs.h"
59 | #include "S2LP_Types.h"
60 | #include "S2LP_PacketHandler.h"
61 |
62 | #ifdef __cplusplus
63 | extern "C" {
64 | #endif
65 |
66 |
67 |
68 | /**
69 | * @addtogroup S2LP_Libraries
70 | * @{
71 | */
72 |
73 |
74 | /**
75 | * @defgroup S2LP_PktWMbus Pkt WMbus
76 | * @brief Configuration and management of S2LP WMbus packets.
77 | * @details See the file @ref S2LP_PktWMbus.h for more details.
78 | * @{
79 | */
80 |
81 | /**
82 | * @defgroup PktWMbus_Exported_Types Pkt WMbus Exported Types
83 | * @{
84 | */
85 |
86 |
87 |
88 | /**
89 | * @brief WMbus submode enumeration.
90 | */
91 |
92 | typedef enum {
93 | WMBUS_SUBMODE_NOT_CONFIGURED = 0, /*!< WMBUS submode S1, S2 (long header) - Header length = WMBUS_prmbl_ctrl + 279 (in "01" bit pairs) , Sync word = 0x7696 (length 18 bits) */
94 | WMBUS_SUBMODE_S1_S2_LONG_HEADER, /*!< WMBUS submode S1, S2 (long header) - Header length = WMBUS_prmbl_ctrl + 279 (in "01" bit pairs) , Sync word = 0x7696 (length 18 bits) */
95 | WMBUS_SUBMODE_S1_M_S2_T2_OTHER_TO_METER, /*!< WMBUS submode S1-m, S2, T2 (other to meter) - Header length = WMBUS_prmbl_ctrl + 15 (in "01" bit pairs) , Sync word = 0x7696 (length 18 bits)*/
96 | WMBUS_SUBMODE_T1_T2_METER_TO_OTHER, /*!< WMBUS submode T1, T2 (meter to other) - Header length = WMBUS_prmbl_ctrl + 19 (in "01" bit pairs) , Sync word = 0x3D (length 10 bits)*/
97 | WMBUS_SUBMODE_R2_SHORT_HEADER, /*!< WMBUS submode R2, short header - Header length = WMBUS_prmbl_ctrl + 39 (in "01" bit pairs) , Sync word = 0x7696 (length 18 bits)*/
98 | } WMbusSubmode;
99 |
100 |
101 | /**
102 | * @brief S2LP WMBUS Packet Init structure definition
103 | */
104 | typedef struct {
105 | WMbusSubmode xWMbusSubmode; /*!< Set the WMBUS submode. @ref WMbusSubmode */
106 | uint8_t cPreambleLength; /*!< Set the preamble length in chip sequence */
107 | uint8_t cPostambleLength; /*!< Set the postamble length in chip sequence */
108 | } PktWMbusInit;
109 |
110 | /**
111 | *@}
112 | */
113 |
114 |
115 |
116 | /**
117 | * @defgroup PktWMbus_Exported_Functions Pkt WMbus Exported Functions
118 | * @{
119 | */
120 |
121 | /**
122 | * @brief Sets the PREAMBLE field length for S2LP Basic packets.
123 | * @param xPreambleLength length of PREAMBLE field in bytes.
124 | * This parameter can be any value of @ref BasicPreambleLength.
125 | * @retval None.
126 | */
127 | #define S2LPPktWMbusSetPreambleLength(xPreambleLength) S2LPPktCommonSetPreambleLength((PktPreambleLength)xPreambleLength)
128 |
129 |
130 | /**
131 | * @brief Returns the PREAMBLE field length mode for S2LP Basic packets.
132 | * @param None.
133 | * @retval uint8_t Preamble field length in bytes.
134 | */
135 | #define S2LPPktWMbusGetPreambleLength() S2LPPktCommonGetPreambleLength()
136 |
137 |
138 |
139 | /**
140 | *@}
141 | */
142 |
143 | /**
144 | *@}
145 | */
146 |
147 |
148 | /**
149 | *@}
150 | */
151 |
152 |
153 | #ifdef __cplusplus
154 | }
155 | #endif
156 |
157 | #endif
158 |
159 | /******************* (C) COPYRIGHT 2019 STMicroelectronics *****END OF FILE****/
160 |
--------------------------------------------------------------------------------
/src/S2LP_Qi.cpp:
--------------------------------------------------------------------------------
1 | /**
2 | * @file S2LP_Qi.c
3 | * @author ST Microelectronics
4 | * @version 1.3.0
5 | * @date June, 2019
6 | * @brief Configuration and management of S2-LP QI.
7 | * @details
8 | *
9 | * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
10 | * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
11 | * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
12 | * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
13 | * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
14 | * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
15 | *
16 | * THIS SOURCE CODE IS PROTECTED BY A LICENSE.
17 | * FOR MORE INFORMATION PLEASE CAREFULLY READ THE LICENSE AGREEMENT FILE LOCATED
18 | * IN THE ROOT DIRECTORY OF THIS FIRMWARE PACKAGE.
19 | *
20 | * © COPYRIGHT 2019 STMicroelectronics
21 | */
22 |
23 |
24 | /* Includes ------------------------------------------------------------------*/
25 | #include "S2LP.h"
26 |
27 |
28 |
29 | /**
30 | * @addtogroup S2LP_Libraries
31 | * @{
32 | */
33 |
34 |
35 | /**
36 | * @addtogroup S2LP_Qi
37 | * @{
38 | */
39 |
40 |
41 | /**
42 | * @defgroup Qi_Private_TypesDefinitions QI Private Types Definitions
43 | * @{
44 | */
45 |
46 | /**
47 | *@}
48 | */
49 |
50 |
51 | /**
52 | * @defgroup Qi_Private_Defines QI Private Defines
53 | * @{
54 | */
55 |
56 | /**
57 | *@}
58 | */
59 |
60 |
61 | /**
62 | * @defgroup Qi_Private_Macros QI Private Macros
63 | * @{
64 | */
65 |
66 | #define IS_RSSI_MODE(MODE) (MODE<=3)
67 | #define IS_RSSI_DBM(VAL) ((VAL>=-146) && (VAL<=-2))
68 | #define IS_RSSI_FLT(VAL) (VAL<=15)
69 | #define IS_PQI_LVL_CHECK(VAL) (VAL<=15)
70 | #define S2LPRadioRegToRssidBm(VAL) (VAL - 146)
71 | #define S2LPRadioRssidBmToReg(VAL) (uint8_t)(VAL+146)
72 |
73 | /**
74 | *@}
75 | */
76 |
77 |
78 | /**
79 | * @defgroup Qi_Private_Variables QI Private Variables
80 | * @{
81 | */
82 |
83 | /**
84 | *@}
85 | */
86 |
87 |
88 | /**
89 | * @defgroup Qi_Private_FunctionPrototypes QI Private Function Prototypes
90 | * @{
91 | */
92 |
93 | /**
94 | *@}
95 | */
96 |
97 |
98 | /**
99 | * @defgroup Qi_Private_Functions QI Private Functions
100 | * @{
101 | */
102 |
103 | /**
104 | * @brief Returns the RSSI value.
105 | * @param None.
106 | * @retval int32_t RSSI value.
107 | */
108 | int32_t S2LP::S2LPRadioGetRssidBm(void)
109 | {
110 | uint8_t tmp;
111 | g_xStatus = S2LPSpiReadRegisters(RSSI_LEVEL_ADDR, 1, &tmp);
112 | return S2LPRadioRegToRssidBm((int32_t)tmp);
113 | }
114 |
115 | /**
116 | * @brief Returns the RSSI value from a current RX mode.
117 | * @param None.
118 | * @retval uint8_t RSSI value.
119 | */
120 | int32_t S2LP::S2LPRadioGetRssidBmRun(void)
121 | {
122 | uint8_t tmpBuffer[2];
123 |
124 | /*The first value is the previous one, so the first read operation clear this value,
125 | than it is read the actual during RX. */
126 | g_xStatus = S2LPSpiReadRegisters(RSSI_LEVEL_RUN_ADDR, 2, tmpBuffer);
127 |
128 | return S2LPRadioRegToRssidBm((int32_t)tmpBuffer[1]);
129 | }
130 |
131 |
132 |
133 | /**
134 | * @brief Set the RSSI threshold in dBm.
135 | * @param rssiThrehsold in dBm.
136 | * @retval None.
137 | */
138 | void S2LP::S2LPRadioSetRssiThreshdBm(int32_t wRssiThrehsold)
139 | {
140 | uint8_t tmp;
141 | s_assert_param(IS_RSSI_DBM(wRssiThrehsold));
142 |
143 | tmp = S2LPRadioRssidBmToReg(wRssiThrehsold);
144 | g_xStatus = S2LPSpiWriteRegisters(RSSI_TH_ADDR, 1, &tmp);
145 | }
146 |
147 |
148 |
149 | /**
150 | * @brief Initialize the RSSI measurement.
151 | * @param Pointer to the SRssiInit struct to use fot the initialization.
152 | * @retval None.
153 | */
154 | void S2LP::S2LPRadioRssiInit(SRssiInit* xSRssiInit)
155 | {
156 | uint8_t tmpBuffer[2];
157 |
158 | s_assert_param(IS_RSSI_MODE(xSRssiInit->xRssiMode));
159 | s_assert_param(IS_RSSI_DBM(xSRssiInit->cRssiThreshdBm));
160 | s_assert_param(IS_RSSI_FLT(xSRssiInit->cRssiFlt));
161 |
162 | /* Reads the PCKT_FLT_OPTIONS rrgister */
163 | S2LPSpiReadRegisters(RSSI_FLT_ADDR, 1, &tmpBuffer[0]);
164 |
165 | /* Enables or disables filtering on my address */
166 | tmpBuffer[0] &= ~(RSSI_FLT_REGMASK | CS_MODE_REGMASK);
167 | tmpBuffer[0] |= (xSRssiInit->cRssiFlt<<4);
168 | tmpBuffer[0] |= (xSRssiInit->xRssiMode<<2);
169 |
170 | tmpBuffer[1] = S2LPRadioRssidBmToReg(xSRssiInit->cRssiThreshdBm);
171 |
172 | g_xStatus = S2LPSpiWriteRegisters(RSSI_FLT_ADDR, 2, tmpBuffer);
173 | }
174 |
175 |
176 | /**
177 | * @brief Return the RSSI measurements information to be filled with the information.
178 | * @param Pointer to the SRssiInit struct.
179 | * It will be filled with RSSI Mode, RSSI filter gain value and RSSI Threshold.
180 | * @retval None.
181 | */
182 | void S2LP::S2LPRadioGetRssiInfo(SRssiInit* xSRssiInit)
183 | {
184 | uint8_t tmpBuffer[2];
185 |
186 | S2LPSpiReadRegisters(RSSI_FLT_ADDR, 2, tmpBuffer);
187 |
188 | xSRssiInit->xRssiMode = (SRssiMode)((tmpBuffer[0]&CS_MODE_REGMASK)>>2);
189 | xSRssiInit->cRssiFlt = (tmpBuffer[0]&RSSI_FLT_REGMASK)>>4;
190 | xSRssiInit->cRssiThreshdBm = S2LPRadioRegToRssidBm(tmpBuffer[1]);
191 |
192 | }
193 |
194 |
195 | /**
196 | * @brief Enable or disables the CS blanking.
197 | * @param xCsBlank enable or disable.
198 | * @retval None.
199 | */
200 | void S2LP::S2LPRadioCsBlanking(SFunctionalState xCsBlank)
201 | {
202 | uint8_t tmp;
203 |
204 | s_assert_param(IS_SFUNCTIONAL_STATE(xCsBlank));
205 |
206 | S2LPSpiReadRegisters(ANT_SELECT_CONF_ADDR, 1, &tmp);
207 |
208 | if(xCsBlank == S_ENABLE) {
209 | tmp |= CS_BLANKING_REGMASK;
210 | } else {
211 | tmp &= ~CS_BLANKING_REGMASK;
212 | }
213 | g_xStatus = S2LPSpiWriteRegisters(ANT_SELECT_CONF_ADDR, 1, &tmp);
214 |
215 | }
216 |
217 |
218 | /**
219 | * @brief Enable or Disable the antenna switching.
220 | * @param xAntennaSwitch enable or disable.
221 | * @retval None.
222 | */
223 | void S2LP::S2LPRadioAntennaSwitching(SFunctionalState xAntennaSwitch)
224 | {
225 | uint8_t tmp;
226 |
227 | s_assert_param(IS_SFUNCTIONAL_STATE(xAntennaSwitch));
228 |
229 | S2LPSpiReadRegisters(ANT_SELECT_CONF_ADDR, 1, &tmp);
230 |
231 | if(xAntennaSwitch == S_ENABLE) {
232 | tmp |= AS_ENABLE_REGMASK;
233 | } else {
234 | tmp &= ~AS_ENABLE_REGMASK;
235 | }
236 | g_xStatus = S2LPSpiWriteRegisters(ANT_SELECT_CONF_ADDR, 1, &tmp);
237 |
238 | }
239 |
240 |
241 | /**
242 | * @brief Set the PQI check.
243 | * @param PQI_LEVEL.
244 | * @retval None.
245 | */
246 | void S2LP::S2LPRadioSetPqiCheck(uint8_t cPqiLevel)
247 | {
248 | uint8_t tmp;
249 | s_assert_param(IS_PQI_LVL_CHECK(cPqiLevel));
250 |
251 | S2LPSpiReadRegisters(QI_ADDR, 1, &tmp);
252 | tmp &= ~PQI_TH_REGMASK;
253 | tmp |= (((uint8_t)cPqiLevel)<<1);
254 | S2LPSpiWriteRegisters(QI_ADDR, 1, &tmp);
255 |
256 | }
257 |
258 |
259 | /**
260 | * @brief Return the CS (carrier sense) indication.
261 | * @param None.
262 | * @retval CS indication.
263 | */
264 | SFlagStatus S2LP::S2LPQiGetCs(void)
265 | {
266 | uint8_t tmp;
267 |
268 | S2LPSpiReadRegisters(LINK_QUALIF1_ADDR, 1, &tmp);
269 | tmp = (tmp&CS_REGMASK)>>7;
270 | return (SFlagStatus)tmp;
271 | }
272 |
273 |
274 |
275 | /**
276 | *@}
277 | */
278 |
279 | /**
280 | *@}
281 | */
282 |
283 |
284 | /**
285 | *@}
286 | */
287 |
288 |
289 |
290 | /******************* (C) COPYRIGHT 2019 STMicroelectronics *****END OF FILE****/
291 |
--------------------------------------------------------------------------------
/src/S2LP_Qi.h:
--------------------------------------------------------------------------------
1 | /**
2 | * @file S2LP_Qi.h
3 | * @author ST Microelectronics
4 | * @version 1.3.0
5 | * @date June, 2019
6 | * @brief Configuration and management of S2LP QI.
7 | * @details
8 | *
9 | * This module can be used to configure and read some quality indicators
10 | * used by S2-LP.
11 | * API to set thresholds and to read values in raw mode or in dBm are
12 | * provided.
13 | *
14 | * Example:
15 | * @code
16 | *
17 | * int32_t rssiValuedBm;
18 | * uint8_t pqiValue, sqiValue;
19 | *
20 | * S2LPQiPqiCheck(S_ENABLE);
21 | * S2LPQiSqiCheck(S_ENABLE);
22 | *
23 | * ...
24 | *
25 | * rssiValueDbm = S2LPQiGetRssidBm();
26 | * pqiValue = S2LPQiGetPqi();
27 | * sqiValue = S2LPQiGetSqi();
28 | *
29 | * ...
30 | *
31 | * @endcode
32 | *
33 | * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
34 | * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
35 | * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
36 | * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
37 | * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
38 | * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
39 | *
40 | * THIS SOURCE CODE IS PROTECTED BY A LICENSE.
41 | * FOR MORE INFORMATION PLEASE CAREFULLY READ THE LICENSE AGREEMENT FILE LOCATED
42 | * IN THE ROOT DIRECTORY OF THIS FIRMWARE PACKAGE.
43 | *
44 | * © COPYRIGHT 2019 STMicroelectronics
45 | */
46 |
47 |
48 | /* Define to prevent recursive inclusion -------------------------------------*/
49 | #ifndef __S2LP_QI_H
50 | #define __S2LP_QI_H
51 |
52 |
53 | /* Includes ------------------------------------------------------------------*/
54 |
55 | #include "S2LP_Regs.h"
56 | #include "S2LP_Types.h"
57 |
58 |
59 | #ifdef __cplusplus
60 | extern "C" {
61 | #endif
62 |
63 |
64 | /**
65 | * @addtogroup S2LP_Libraries
66 | * @{
67 | */
68 |
69 |
70 | /**
71 | * @defgroup S2LP_Qi QI
72 | * @brief Configuration and management of S2LP QI.
73 | * @details See the file @ref S2LP_Qi.h for more details.
74 | * @{
75 | */
76 |
77 | /**
78 | * @defgroup Qi_Exported_Types QI Exported Types
79 | * @{
80 | */
81 |
82 | /**
83 | * @brief S2LP RSSI mode enumeration
84 | */
85 | typedef enum {
86 | RSSI_STATIC_MODE = 0, /* static mode */
87 | RSSI_DYNAMIC_6DB_STEP_MODE, /* dynamic mode 6 dB above threshold*/
88 | RSSI_DYNAMIC_12DB_STEP_MODE, /* dynamic mode 12 dB above threshold */
89 | RSSI_DYNAMIC_18DB_STEP_MODE /* dynamic mode 18 dB above threshold */
90 | } SRssiMode;
91 |
92 |
93 | /**
94 | * @brief S2LP RSSI Init structure definition
95 | */
96 | typedef struct {
97 | uint8_t cRssiFlt; /*!< Set the RSSI filter gain. From 0 to 15. */
98 | SRssiMode xRssiMode; /*!< Set the RSSI mode. @ref SRssiMode */
99 | int32_t cRssiThreshdBm; /*!< Set the RSSI threshold in dBm. From -130 to -2.5 dBm. */
100 | } SRssiInit;
101 |
102 |
103 | /**
104 | *@}
105 | */
106 |
107 |
108 | /**
109 | * @defgroup Qi_Exported_Constants QI Exported Constants
110 | * @{
111 | */
112 |
113 |
114 | /**
115 | *@}
116 | */
117 |
118 |
119 | /**
120 | * @defgroup Qi_Exported_Macros QI Exported Macros
121 | * @{
122 | */
123 |
124 |
125 | /**
126 | *@}
127 | */
128 |
129 |
130 | /**
131 | *@}
132 | */
133 |
134 |
135 | /**
136 | *@}
137 | */
138 |
139 |
140 | #ifdef __cplusplus
141 | }
142 | #endif
143 |
144 | #endif
145 |
146 | /******************* (C) COPYRIGHT 2019 STMicroelectronics *****END OF FILE****/
147 |
--------------------------------------------------------------------------------
/src/S2LP_Radio.h:
--------------------------------------------------------------------------------
1 | /**
2 | * @file S2LP_Radio.h
3 | * @author ST Microelectronics
4 | * @version 1.3.0
5 | * @date June, 2019
6 | * @brief Configuration and management of S2-LP RF Analog and Digital part.
7 | * @details
8 | *
9 | * In order to configure the Radio main parameters, the user can
10 | * fit SRadioInit structure the and call the S2LPRadioInit()
11 | * function passing its pointer as an argument.
12 | *
13 | * Example:
14 | * @code
15 | *
16 | * SRadioInit radioInit = {
17 | * 433400000, // base frequency
18 | * MOD_2FSK, // modulation select
19 | * 38400, // datarate
20 | * 20000, // frequency deviation
21 | * 100000 // channel filter bandwidth
22 | * };
23 | *
24 | * ...
25 | *
26 | * S2LPRadioInit(&radioInit);
27 | * @endcode
28 | *
29 | * Another important parameter for the radio configuration is the
30 | * transmission power.
31 | * The user is allowed to configure it using the function S2LPRadioSetPALeveldBm()
32 | * which sets the PA LEVEL specified by the first argument to the
33 | * power expressed in dBm by the second parameter.
34 | *
35 | * Example:
36 | * @code
37 | *
38 | * S2LPRadioSetPALeveldBm(0 , 10.0);
39 | *
40 | * @endcode
41 | *
42 | *
43 | * @note The effective power that is set can be a little different from the
44 | * passed argument in dBm because the function performs an approximation.
45 | *
46 | * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
47 | * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
48 | * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
49 | * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
50 | * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
51 | * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
52 | *
53 | * THIS SOURCE CODE IS PROTECTED BY A LICENSE.
54 | * FOR MORE INFORMATION PLEASE CAREFULLY READ THE LICENSE AGREEMENT FILE LOCATED
55 | * IN THE ROOT DIRECTORY OF THIS FIRMWARE PACKAGE.
56 | *
57 | * © COPYRIGHT 2019 STMicroelectronics
58 | */
59 |
60 |
61 | /* Define to prevent recursive inclusion -------------------------------------*/
62 | #ifndef __S2LP_RADIO_H
63 | #define __S2LP_RADIO_H
64 |
65 |
66 | /* Includes ------------------------------------------------------------------*/
67 | #include "S2LP_Regs.h"
68 | #include "S2LP_Types.h"
69 |
70 |
71 | #ifdef __cplusplus
72 | extern "C" {
73 | #endif
74 |
75 |
76 | /** @addtogroup S2LP_Libraries
77 | * @{
78 | */
79 |
80 |
81 | /** @defgroup S2LP_Radio Radio
82 | * @brief Configuration and management of S2LP RF Analog and Digital part.
83 | * @details See the file @ref S2LP_Radio.h for more details.
84 | * @{
85 | */
86 |
87 |
88 |
89 | /** @defgroup Radio_Exported_Types Radio Exported Types
90 | * @{
91 | */
92 |
93 |
94 | /**
95 | * @brief S2LP Modulation enumeration
96 | */
97 | typedef enum {
98 | MOD_NO_MOD = 0x70, /*!< CW modulation selected */
99 | MOD_2FSK = 0x00, /*!< 2-FSK modulation selected */
100 | MOD_4FSK = 0x10, /*!< 4-FSK modulation selected */
101 | MOD_2GFSK_BT05 = 0xA0, /*!< G2FSK modulation selected with BT = 0.5 */
102 | MOD_2GFSK_BT1 = 0x20, /*!< G2FSK modulation selected with BT = 1 */
103 | MOD_4GFSK_BT05 = 0xB0, /*!< G4FSK modulation selected with BT = 0.5 */
104 | MOD_4GFSK_BT1 = 0x30, /*!< G4FSK modulation selected with BT = 1 */
105 | MOD_ASK_OOK = 0x50, /*!< OOK modulation selected. */
106 | MOD_POLAR = 0x60, /*!< OOK modulation selected. */
107 | } ModulationSelect;
108 |
109 |
110 | /**
111 | * @brief S2LP Radio Init structure definition
112 | */
113 | typedef struct {
114 | uint32_t lFrequencyBase; /*!< Specifies the base carrier frequency (in Hz),
115 | i.e. the carrier frequency of channel #0.
116 | This parameter can be in one of the following ranges:
117 | High_Band: from 860 MHz to 940 MHz
118 | Middle Band: from 430 MHz to 470 MHz */
119 | ModulationSelect xModulationSelect; /*!< Specifies the modulation @ref ModulationSelect */
120 | uint32_t lDatarate; /*!< Specifies the datarate expressed in bps.
121 | This parameter can be in the range
122 | between 100 bps and 500 kbps */
123 | uint32_t lFreqDev; /*!< Specifies the frequency deviation expressed in Hz.
124 | This parameter can be in the range:
125 | [F_Xo*8/2^18, F_Xo*7680/2^18] Hz */
126 | uint32_t lBandwidth; /*!< Specifies the channel filter bandwidth
127 | expressed in Hz. This parameter can be
128 | in the range between 1100 and 800100 Hz */
129 | } SRadioInit;
130 |
131 |
132 | /**
133 | * @brief S2LP AFC mode enumeration
134 | */
135 | typedef enum {
136 | AFC_MODE_LOOP_CLOSED_ON_SLICER = 0, /* loop closed on slicer */
137 | AFC_MODE_LOOP_CLOSED_ON_2ND_CONV_STAGE /* loop closed on 2nd conversion stage */
138 | } SAfcMode;
139 |
140 |
141 | /**
142 | * @brief S2LP AFC Init structure definition
143 | */
144 | typedef struct {
145 | SFunctionalState xAfcEnable; /*!< AFC enable */
146 | SFunctionalState xAfcFreezeOnSync; /*!< Freeze the parameters on SYNC word detect */
147 | SAfcMode xAfcMode; /*!< Specify the AFC mode. @ref SAfcMode */
148 | uint8_t cAfcFastPeriod; /*!< Fast period duration */
149 | uint8_t cAfcFastGain; /*!< Gain used during fast loop */
150 | uint8_t cAfcSlowGain; /*!< Gain used during slow loop */
151 | } SAfcInit;
152 |
153 |
154 | /**
155 | * @brief S2LP ISI Equalization type enumeration
156 | */
157 | typedef enum {
158 | ISI_EQUALIZATION_DISABLED = 0, /* static mode */
159 | ISI_EQUALIZATION_SINGLE_PASS, /* dynamic mode 6 dB above threshold*/
160 | ISI_EQUALIZATION_DUAL_PASS /* dynamic mode 18 dB above threshold */
161 | } SIsiEqu;
162 |
163 |
164 | /**
165 | * @brief S2LP Clock Recovery mode enumeration
166 | */
167 | typedef enum {
168 | CLKREC_DLL_MODE = 0, /* DLL mode */
169 | CLKREC_PLL_MODE, /* PLL mode */
170 | } SClkRecMode;
171 |
172 |
173 | /**
174 | * @brief S2LP Clock Recovery Init structure definition
175 | */
176 | typedef struct {
177 | SClkRecMode xSClkRecMode; /*!< Select the clock recovery mode. @ref SClkRecMode */
178 | uint8_t cClkRecPGainSlow; /*!< Gain P for slow stage. From 0 to 7. */
179 | uint8_t cClkRecPGainFast; /*!< Gain P for fast stage. From 0 to 7. */
180 | uint8_t cClkRecIGainSlow; /*!< Gain I for slow stage. From 0 to 15. */
181 | uint8_t cClkRecIGainFast; /*!< Gain I for fast stage. From 0 to 15. */
182 | SFunctionalState cClkRec16SymPostFlt; /*!< Set the post filter to 16 symbols. Default is 8 symbols */
183 | } SSymClkRecInit;
184 |
185 |
186 | /**
187 | * @}
188 | */
189 |
190 |
191 | /**
192 | * @}
193 | */
194 |
195 |
196 | /**
197 | * @}
198 | */
199 |
200 |
201 |
202 | #ifdef __cplusplus
203 | }
204 | #endif
205 |
206 | #endif
207 |
208 | /******************* (C) COPYRIGHT 2019 STMicroelectronics *****END OF FILE****/
209 |
--------------------------------------------------------------------------------
/src/S2LP_Timer.h:
--------------------------------------------------------------------------------
1 | /**
2 | * @file S2LP_Timer.h
3 | * @author ST Microelectronics
4 | * @version 1.3.0
5 | * @date June, 2019
6 | * @brief Configuration and management of S2-LP Timers.
7 | * @details
8 | *
9 | * This module provides API to configure the S2-LP timing mechanisms.
10 | * They allow the user to set the timer registers using raw values or
11 | * compute them since the desired timer value is expressed in ms.
12 | * Moreover the management of the S2-LP LDCR mode can be done using
13 | * these API.
14 | *
15 | * Example:
16 | * @code
17 | * ...
18 | *
19 | * S2LPTimerSetRxTimeoutMs(50.0);
20 | * S2LPTimerSetWakeUpTimerUs(150000);
21 | *
22 | * // IRQ configuration for RX_TIMEOUT and WAKEUP_TIMEOUT
23 | * ...
24 | *
25 | * S2LPTimerLdcrMode(S_ENABLE);
26 | *
27 | * ...
28 | *
29 | * @endcode
30 | *
31 | *
32 | * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
33 | * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
34 | * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
35 | * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
36 | * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
37 | * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
38 | *
39 | * THIS SOURCE CODE IS PROTECTED BY A LICENSE.
40 | * FOR MORE INFORMATION PLEASE CAREFULLY READ THE LICENSE AGREEMENT FILE LOCATED
41 | * IN THE ROOT DIRECTORY OF THIS FIRMWARE PACKAGE.
42 | *
43 | * © COPYRIGHT 2019 STMicroelectronics
44 | */
45 |
46 |
47 | /* Define to prevent recursive inclusion -------------------------------------*/
48 | #ifndef __S2LP1_TIMER_H
49 | #define __S2LP1_TIMER_H
50 |
51 |
52 | /* Includes ------------------------------------------------------------------*/
53 | #include "S2LP_Regs.h"
54 | #include "S2LP_Types.h"
55 |
56 |
57 | #ifdef __cplusplus
58 | extern "C" {
59 | #endif
60 |
61 | /**
62 | * @addtogroup S2LP_Libraries
63 | * @{
64 | */
65 |
66 |
67 | /**
68 | * @defgroup S2LP_Timer Timer
69 | * @brief Configuration and management of S2LP Timers.
70 | * @details See the file @ref S2LP_Timer.h for more details.
71 | * @{
72 | */
73 |
74 |
75 | /**
76 | * @defgroup Timer_Exported_Types Timer Exported Types
77 | * @{
78 | */
79 |
80 | /**
81 | * @brief All the possible RX timeout stop conditions enumeration.
82 | */
83 | typedef enum {
84 | NO_TIMEOUT_STOP = 0x00, /*!< Timeout never stopped */
85 | PQI_ABOVE_THRESHOLD = 0x01, /*!< Timeout stopped on PQI above threshold */
86 | SQI_ABOVE_THRESHOLD = 0x02, /*!< Timeout stopped on SQI above threshold */
87 | SQI_AND_PQI_ABOVE_THRESHOLD = 0x03, /*!< Timeout stopped on both SQI and PQI above threshold */
88 | RSSI_ABOVE_THRESHOLD = 0x04, /*!< Timeout stopped on RSSI above threshold */
89 | RSSI_AND_PQI_ABOVE_THRESHOLD = 0x05, /*!< Timeout stopped on both RSSI and PQI above threshold */
90 | RSSI_AND_SQI_ABOVE_THRESHOLD = 0x06, /*!< Timeout stopped on both RSSI and SQI above threshold */
91 | ALL_ABOVE_THRESHOLD = 0x07, /*!< Timeout stopped only if RSSI, SQI and PQI are above threshold */
92 | TIMEOUT_ALWAYS_STOPPED = 0x08, /*!< Timeout always stopped (default) */
93 | SQI_OR_PQI_ABOVE_THRESHOLD = 0x0B, /*!< Timeout stopped if one between SQI or PQI are above threshold */
94 | RSSI_OR_PQI_ABOVE_THRESHOLD = 0x0D, /*!< Timeout stopped if one between RSSI or PQI are above threshold */
95 | RSSI_OR_SQI_ABOVE_THRESHOLD = 0x0E, /*!< Timeout stopped if one between RSSI or SQI are above threshold */
96 | ANY_ABOVE_THRESHOLD = 0x0F /*!< Timeout stopped if one among RSSI, SQI or SQI are above threshold */
97 | } RxTimeoutStopCondition;
98 |
99 |
100 | /**
101 | * @}
102 | */
103 |
104 |
105 | /**
106 | * @defgroup Timer_Exported_Constants Timer Exported Constants
107 | * @{
108 | */
109 |
110 |
111 | /**
112 | * @}
113 | */
114 |
115 |
116 | /**
117 | * @defgroup Timer_Exported_Macros Timer Exported Macros
118 | * @{
119 | */
120 |
121 | #define SET_INFINITE_RX_TIMEOUT() S2LPTimerSetRxTimerCounter(0)
122 |
123 | /**
124 | * @}
125 | */
126 |
127 | /**
128 | * @}
129 | */
130 |
131 |
132 | /**
133 | * @}
134 | */
135 |
136 | #ifdef __cplusplus
137 | }
138 | #endif
139 |
140 | #endif
141 |
142 | /******************* (C) COPYRIGHT 2019 STMicroelectronics *****END OF FILE****/
143 |
--------------------------------------------------------------------------------
/src/S2LP_Timer_ex.cpp:
--------------------------------------------------------------------------------
1 | /**
2 | * @file S2LP_Timer_ex.c
3 | * @author LowPower RF BU - AMG
4 | * @version 1.2.0
5 | * @date October 31, 2016
6 | * @brief This file provides functions to manage S2-LP debug.
7 | * @details
8 | *
9 | * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
10 | * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
11 | * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
12 | * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
13 | * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
14 | * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
15 | *
16 | * THIS SOURCE CODE IS PROTECTED BY A LICENSE.
17 | * FOR MORE INFORMATION PLEASE CAREFULLY READ THE LICENSE AGREEMENT FILE LOCATED
18 | * IN THE ROOT DIRECTORY OF THIS FIRMWARE PACKAGE.
19 | *
20 | * © COPYRIGHT 2019 STMicroelectronics
21 | *
22 | */
23 |
24 | /* Includes ------------------------------------------------------------------*/
25 | #include "S2LP.h"
26 |
27 |
28 | /** @addtogroup S2LP_Libraries
29 | * @{
30 | */
31 |
32 |
33 | /** @addtogroup S2LP_Types
34 | * @{
35 | */
36 |
37 | /** @defgroup Types_Private_Functions Types Private Functions
38 | * @{
39 | */
40 |
41 |
42 | void S2LP::S2LPTimerSetRxTimerMs(float fDesiredMsec)
43 | {
44 | S2LPTimerSetRxTimerUs((uint32_t)(fDesiredMsec*1000));
45 | }
46 |
47 | void S2LP::S2LPTimerGetRxTimer(float* pfTimeoutMsec, uint8_t* pcCounter , uint8_t* pcPrescaler)
48 | {
49 | uint32_t timeoutUsec;
50 |
51 | S2LPTimerGetRxTimerUs(&timeoutUsec, pcCounter , pcPrescaler);
52 |
53 | (*pfTimeoutMsec)=((float)timeoutUsec)/1000;
54 | }
55 |
56 | void S2LP::S2LPTimerSetWakeUpTimerMs(float fDesiredMsec)
57 | {
58 | S2LPTimerSetWakeUpTimerUs((uint32_t)(fDesiredMsec*1000));
59 | }
60 |
61 | void S2LP::S2LPTimerSetWakeUpTimerReloadMs(float fDesiredMsec)
62 | {
63 | S2LPTimerSetWakeUpTimerReloadUs((uint32_t)(fDesiredMsec*1000));
64 | }
65 |
66 | void S2LP::S2LPTimerGetWakeUpTimer(float* pfWakeUpMsec, uint8_t* pcCounter , uint8_t* pcPrescaler, uint8_t* pcMulti)
67 | {
68 | uint32_t timeoutUsec;
69 |
70 | S2LPTimerGetWakeUpTimerUs(&timeoutUsec, pcCounter , pcPrescaler, pcMulti);
71 |
72 | (*pfWakeUpMsec)=((float)timeoutUsec)/1000;
73 | }
74 |
75 | void S2LP::S2LPTimerGetWakeUpTimerReload(float* pfWakeUpReloadMsec, uint8_t* pcCounter, uint8_t* pcPrescaler, uint8_t* pcMulti)
76 | {
77 | uint32_t timeoutUsec;
78 |
79 | S2LPTimerGetWakeUpTimerReloadUs(&timeoutUsec, pcCounter , pcPrescaler, pcMulti);
80 |
81 | (*pfWakeUpReloadMsec)=((float)timeoutUsec)/1000;
82 | }
83 |
84 |
85 |
86 | /**
87 | * @}
88 | */
89 |
90 |
91 |
92 | /**
93 | * @}
94 | */
95 |
96 |
97 |
98 | /**
99 | * @}
100 | */
101 |
102 |
103 |
104 | /******************* (C) COPYRIGHT 2019 STMicroelectronics *****END OF FILE****/
105 |
--------------------------------------------------------------------------------
/src/S2LP_Timer_ex.h:
--------------------------------------------------------------------------------
1 | /**
2 | * @file S2LP_Timer_ex.h
3 | * @author ST Microelectronics
4 | * @version 1.3.0
5 | * @date June, 2019
6 | * @brief Configuration and management of S2-LP Timers using floating point.
7 | * @details
8 | *
9 | * This module provides API to configure the S2-LP timing mechanisms using floating points.
10 | *
11 | * Example:
12 | * @code
13 | * ...
14 | *
15 | * S2LPTimerSetRxTimeoutMs(50.0);
16 | *
17 | * ...
18 | *
19 | * @endcode
20 | *
21 | * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
22 | * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
23 | * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
24 | * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
25 | * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
26 | * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
27 | *
28 | * THIS SOURCE CODE IS PROTECTED BY A LICENSE.
29 | * FOR MORE INFORMATION PLEASE CAREFULLY READ THE LICENSE AGREEMENT FILE LOCATED
30 | * IN THE ROOT DIRECTORY OF THIS FIRMWARE PACKAGE.
31 | *
32 | * © COPYRIGHT 2017 STMicroelectronics
33 | */
34 |
35 |
36 | /* Define to prevent recursive inclusion -------------------------------------*/
37 | #ifndef __S2LP_TIMER_EX_H
38 | #define __S2LP_TIMER_EX_H
39 |
40 |
41 | /* Includes ------------------------------------------------------------------*/
42 |
43 | #include "S2LP_Timer.h"
44 |
45 |
46 | #ifdef __cplusplus
47 | extern "C" {
48 | #endif
49 |
50 | /**
51 | * @addtogroup S2LP_Libraries
52 | * @{
53 | */
54 |
55 |
56 | /**
57 | * @defgroup S2LP_Timer_ex Timer Wrapper
58 | * @brief Configuration and management of S2LP Timers using floating point.
59 | * @details See the file @ref S2LP_Timer.h for more details.
60 | * @{
61 | */
62 |
63 |
64 | /**
65 | * @defgroup Timer_ex_Exported_Types Timer Wrapper Exported Types
66 | * @{
67 | */
68 |
69 |
70 | /**
71 | * @}
72 | */
73 |
74 |
75 | /**
76 | * @}
77 | */
78 |
79 | #ifdef __cplusplus
80 | }
81 | #endif
82 |
83 | #endif
84 |
85 | /******************* (C) COPYRIGHT 2017 STMicroelectronics *****END OF FILE****/
86 |
87 |
--------------------------------------------------------------------------------
/src/S2LP_Types.cpp:
--------------------------------------------------------------------------------
1 | /**
2 | * @file S2LP_Types.c
3 | * @author ST Microelectronics
4 | * @version 1.3.0
5 | * @date June, 2019
6 | * @brief This file provides functions to manage S2-LP debug.
7 | * @details
8 | *
9 | * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
10 | * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
11 | * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
12 | * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
13 | * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
14 | * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
15 | *
16 | * THIS SOURCE CODE IS PROTECTED BY A LICENSE.
17 | * FOR MORE INFORMATION PLEASE CAREFULLY READ THE LICENSE AGREEMENT FILE LOCATED
18 | * IN THE ROOT DIRECTORY OF THIS FIRMWARE PACKAGE.
19 | *
20 | * © COPYRIGHT 2019 STMicroelectronics
21 | *
22 | */
23 |
24 | /* Includes ------------------------------------------------------------------*/
25 | #include "S2LP.h"
26 |
27 |
28 | /** @addtogroup S2LP_Libraries
29 | * @{
30 | */
31 |
32 |
33 | /** @addtogroup S2LP_Types
34 | * @{
35 | */
36 |
37 |
38 | /** @defgroup Types_Private_TypesDefinitions Types Private Types Definitions
39 | * @{
40 | */
41 |
42 |
43 | /**
44 | * @}
45 | */
46 |
47 |
48 |
49 | /** @defgroup Types_Private_Defines Types Private Defines
50 | * @{
51 | */
52 |
53 |
54 | /**
55 | * @}
56 | */
57 |
58 |
59 |
60 | /** @defgroup Types_Private_Macros Types Private Macros
61 | * @{
62 | */
63 |
64 |
65 | /**
66 | * @}
67 | */
68 |
69 |
70 |
71 | /** @defgroup Types_Private_Variables Types Private Variables
72 | * @{
73 | */
74 |
75 |
76 |
77 | /** @defgroup Types_Private_FunctionPrototypes Types Private FunctionPrototypes
78 | * @{
79 | */
80 |
81 |
82 |
83 | /**
84 | * @}
85 | */
86 |
87 |
88 |
89 | /** @defgroup Types_Private_Functions Types Private Functions
90 | * @{
91 | */
92 |
93 |
94 | /**
95 | * @brief Updates the gState (the global variable used to maintain memory of S2LP Status)
96 | * reading the MC_STATE register of S2LP.
97 | * @param None
98 | * @retval None
99 | */
100 | void S2LP::S2LPRefreshStatus(void)
101 | {
102 | uint8_t tempRegValue;
103 | /* Read the MC_STATE both from register and from SPI header and exit when they match.
104 | This will protect against possible transition state changes */
105 | do
106 | {
107 | /* Reads the MC_STATE register to update the g_xStatus */
108 | g_xStatus = S2LPSpiReadRegisters(MC_STATE0_ADDR, 1, &tempRegValue);
109 | }
110 | while((tempRegValue>>1)!=g_xStatus.MC_STATE);
111 | }
112 |
113 | /**
114 | * @}
115 | */
116 |
117 |
118 |
119 | /**
120 | * @}
121 | */
122 |
123 |
124 |
125 | /**
126 | * @}
127 | */
128 |
129 |
130 |
131 | /******************* (C) COPYRIGHT 2019 STMicroelectronics *****END OF FILE****/
132 |
--------------------------------------------------------------------------------
/src/S2LP_Types.h:
--------------------------------------------------------------------------------
1 | /**
2 | * @file S2LP_Types.h
3 | * @author LowPower RF BU - AMG
4 | * @version 1.3.0
5 | * @date April 12, 2017
6 | * @brief Header file for S2-LP types.
7 | * @details
8 | *
9 | * This module provide some types definitions which will be used in
10 | * all the modules of this library. Here is defined also the global
11 | * variable @ref g_xStatus which contains the status of S2-LP and
12 | * is updated every time an SPI transaction occurs.
13 | *
14 | * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
15 | * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
16 | * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
17 | * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
18 | * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
19 | * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
20 | *
21 | * THIS SOURCE CODE IS PROTECTED BY A LICENSE.
22 | * FOR MORE INFORMATION PLEASE CAREFULLY READ THE LICENSE AGREEMENT FILE LOCATED
23 | * IN THE ROOT DIRECTORY OF THIS FIRMWARE PACKAGE.
24 | *
25 | * © COPYRIGHT 2019 STMicroelectronics
26 | */
27 |
28 |
29 | /* Define to prevent recursive inclusion -------------------------------------*/
30 | #ifndef __S2LP_GENERICTYPES_H
31 | #define __S2LP_GENERICTYPES_H
32 |
33 |
34 | /* Includes ------------------------------------------------------------------*/
35 |
36 | /* Include all integer types definitions */
37 | #include
38 | #include
39 |
40 |
41 |
42 | #ifdef __cplusplus
43 | extern "C" {
44 | #endif
45 |
46 |
47 | /**
48 | * @addtogroup S2LP_Libraries
49 | * @{
50 | */
51 |
52 |
53 | /**
54 | * @defgroup S2LP_Types Types
55 | * @brief Module for S2LP types definition.
56 | * * @details See the file @ref S2LP_Types.h for more details.
57 | * @{
58 | */
59 |
60 | /**
61 | * @defgroup Types_Exported_Types Types Exported Types
62 | * @{
63 | */
64 |
65 | /**
66 | * @brief S2LP Functional state. Used to enable or disable a specific option.
67 | */
68 | typedef enum {
69 | S_DISABLE = 0,
70 | S_ENABLE = !S_DISABLE
71 | } SFunctionalState;
72 |
73 |
74 | /**
75 | * @brief S2LP Flag status. Used to control the state of a flag.
76 | */
77 | typedef enum {
78 | S_RESET = 0,
79 | S_SET = !S_RESET
80 | } SFlagStatus;
81 |
82 |
83 | /**
84 | * @brief boolean type enumeration.
85 | */
86 | typedef enum {
87 | S_FALSE = 0,
88 | S_TRUE = !S_FALSE
89 | } SBool;
90 |
91 |
92 | /**
93 | * @brief S2LP States enumeration.
94 | */
95 | typedef enum {
96 | MC_STATE_READY =0x00, /*!< READY */
97 | MC_STATE_SLEEP_NOFIFO =0x01, /*!< SLEEP NO FIFO RETENTION */
98 | MC_STATE_STANDBY =0x02, /*!< STANDBY */
99 | MC_STATE_SLEEP =0x03, /*!< SLEEP */
100 | MC_STATE_LOCKON =0x0C, /*!< LOCKON */
101 | MC_STATE_RX =0x30, /*!< RX */
102 | MC_STATE_LOCK_ST =0x14, /*!< LOCK_ST */
103 | MC_STATE_TX =0x5C, /*!< TX */
104 | MC_STATE_SYNTH_SETUP =0x50 /*!< SYNTH_SETUP */
105 | } S2LPState;
106 |
107 |
108 | /**
109 | * @brief S2LP Status. This definition represents the single field of the S2LP
110 | * status returned on each SPI transaction, equal also to the MC_STATE registers.
111 | * This field-oriented structure allows user to address in simple way the single
112 | * field of the S2LP status.
113 | * The user shall define a variable of S2LPStatus type to access on S2LP status fields.
114 | * @note The fields order in the structure depends on used endianness (little or big
115 | * endian). The actual definition is valid ONLY for LITTLE ENDIAN mode. Be sure to
116 | * change opportunely the fields order when use a different endianness.
117 | */
118 | typedef struct {
119 | uint8_t XO_ON:1; /*!< XO is operating state */
120 | S2LPState MC_STATE: 7; /*!< The state of the Main Controller of S2LP @ref S2LPState */
121 | uint8_t ERROR_LOCK: 1; /*!< RCO calibration error */
122 | uint8_t RX_FIFO_EMPTY: 1; /*!< RX FIFO is empty */
123 | uint8_t TX_FIFO_FULL: 1; /*!< TX FIFO is full */
124 | uint8_t ANT_SELECT: 1; /*!< Currently selected antenna */
125 | uint8_t RCCAL_OK: 1; /*!< RCO successfully terminated */
126 | uint8_t : 3; /*!< This 3 bits field are reserved and equal to 2 */
127 | }S2LPStatus;
128 |
129 | /**
130 | * @brief S2LP Range Extender type. This definition represents the possible Range Extender of the S2-LP
131 | * component.
132 | */
133 | typedef enum
134 | {
135 | RANGE_EXT_NONE = 0,
136 | RANGE_EXT_SKY_66100_11 = 1,
137 | RANGE_EXT_SKYWORKS_SE2435L = 2,
138 | RANGE_EXT_SKYWORKS_SKY66420 = 3,
139 | RANGE_EXT_CUSTOM = 4
140 | } RangeExtType;
141 |
142 | /**
143 | * @brief S2LP CUT type. This definition represents the possible CUT versions of the S2-LP
144 | * component.
145 | */
146 | typedef enum
147 | {
148 | S2LP_CUT_2_1 = 0x91,
149 | S2LP_CUT_2_0 = 0x81,
150 | S2LP_CUT_3_0 = 0xC1,
151 | } S2LPCutType;
152 |
153 | /**
154 | * @brief FEM Operation type. This definition represents the structure to manage External PA.
155 | */
156 | typedef enum
157 | {
158 | FEM_SHUTDOWN = 0x00,
159 | FEM_TX_BYPASS = 0x01,
160 | FEM_TX = 0x02,
161 | FEM_RX = 0x03,
162 | } FEM_OperationType;
163 |
164 |
165 | /**
166 | * @}
167 | */
168 |
169 |
170 | /**
171 | * @defgroup Types_Exported_Constants Types Exported Constants
172 | * @{
173 | */
174 |
175 |
176 | /**
177 | * @}
178 | */
179 |
180 | /**
181 | * @defgroup Types_Exported_Macros Types Exported Macros
182 | * @{
183 | */
184 |
185 | #define IS_SFUNCTIONAL_STATE(STATE) (STATE == S_DISABLE || STATE == S_ENABLE)
186 | #define IS_SFLAG_STATUS(STATUS) (STATUS == S_RESET || STATUS == S_SET)
187 | #define IS_SBOOL(STATUS) (STATUS == S_FALSE || STATUS == S_TRUE)
188 |
189 | #define S_ABS(a) ((a)>0?(a):-(a))
190 |
191 | /**
192 | * @}
193 | */
194 |
195 |
196 | /**
197 | * @defgroup Types_Exported_Functions Types Exported Functions
198 | * @{
199 | */
200 |
201 | #ifdef S2LP_USE_FULL_ASSERT
202 | /**
203 | * @brief The s_assert_param macro is used for function's parameters check.
204 | * @param expr If expr is false, it calls assert_failed function which reports
205 | * the name of the source file and the source line number of the call
206 | * that failed. If expr is true, it returns no value.
207 | * @retval None
208 | */
209 | #define s_assert_param(expr) ((expr) ? (void)0 : s_assert_failed((uint8_t *)__FILE__, __LINE__))
210 | void s_assert_failed(uint8_t* file, uint32_t line);
211 | #elif S2LP_USE_VCOM_ASSERT
212 | /**
213 | * @brief The s_assert_param macro is used for function's parameters check.
214 | * @param expr If expr is false, it calls assert_failed function which reports
215 | * the name of the source file and the source line number of the call
216 | * that failed. If expr is true, it returns no value.
217 | * @retval None
218 | */
219 | #define s_assert_param(expr) ((expr) ? (void)0 : s_assert_failed((uint8_t *)__FILE__, __LINE__,#expr))
220 | void s_assert_failed(uint8_t* file, uint32_t line, char* expression);
221 | #else
222 | #define s_assert_param(expr) {}
223 | #endif
224 |
225 | /**
226 | *@}
227 | */
228 |
229 | /**
230 | * @}
231 | */
232 |
233 |
234 | /**
235 | * @}
236 | */
237 |
238 |
239 | #ifdef __cplusplus
240 | }
241 | #endif
242 |
243 | #endif
244 |
245 | /******************* (C) COPYRIGHT 2019 STMicroelectronics *****END OF FILE****/
246 |
--------------------------------------------------------------------------------