sergiotarxz/nuttx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Squashed commit of the following:

Browse Source 
commit 855cf9713052a851a1daeb3842db2edd6ff6f658
Author: Gregory Nutt <gnutt@nuttx.org>
Date:   Thu Jul 27 18:03:56 2017 -0600

    Spirit Network Driver:  Add some hooks that will eventually support address filtering.

commit 3b3fb24ea86cf8233b034871d5c550f47ab852e6
Author: Gregory Nutt <gnutt@nuttx.org>
Date:   Thu Jul 27 17:13:21 2017 -0600

    Spirit: Add a PktStack header file.

commit 705e8fff6a21264ab751fb34c107cb109430ac89
Author: Gregory Nutt <gnutt@nuttx.org>
Date:   Thu Jul 27 15:00:03 2017 -0600

    Spirit:  Bring in last of timer interfaces.

commit f8984b2f82e165f5bba132d6b099222d1beb1fbd
Merge: cb79778a30 f287cc25d6
Author: Gregory Nutt <gnutt@nuttx.org>
Date:   Thu Jul 27 11:57:01 2017 -0600

    Merge remote-tracking branch 'origin/master' into spirit

commit cb79778a3044ae97a1cc615dfa24099144f04bd0
Author: Gregory Nutt <gnutt@nuttx.org>
Date:   Thu Jul 27 11:46:31 2017 -0600

    Spirit:  Bring in last of QI interfaces.

commit 0245b330a33aa73531b82ae261b1312be9922e0f
Author: Gregory Nutt <gnutt@nuttx.org>
Date:   Thu Jul 27 10:14:34 2017 -0600

    Spirit:  Add general interfaces.

commit 121845a8f229ec2c88e5721da5512135f6624ee5
Author: Gregory Nutt <gnutt@nuttx.org>
Date:   Thu Jul 27 09:41:23 2017 -0600

    Spirit:  Bring in last of GPIO interfaces.

commit 279bfcc92bcd0cfa48c0ed7862fa2b75fbee99b8
Author: Gregory Nutt <gnutt@nuttx.org>
Date:   Wed Jul 26 17:09:19 2017 -0600

    Spirit: Add some missing configuration options: Add register -level debug options.

commit 4be89324a5908e35afc70373c279f4d05f62b48f
Merge: 66e87f9bb3 598386ef90
Author: Gregory Nutt <gnutt@nuttx.org>
Date:   Wed Jul 26 15:36:20 2017 -0600

    Merge remote-tracking branch 'origin/master' into spirit

commit 66e87f9bb3ef75fddf25400bc08475c5e6ad4c30
Author: Gregory Nutt <gnutt@nuttx.org>
Date:   Wed Jul 26 15:19:56 2017 -0600

    Spirit:  Brings in last of PktBasic logic.

commit 8b4c89d6a103003fa04363e2c2ae7b9ee390bf49
Author: Gregory Nutt <gnutt@nuttx.org>
Date:   Wed Jul 26 11:55:50 2017 -0600

    Spirit:  Bring in AES and MBUS logic.

commit d00022d39ab0ce839de29386949481e5c24feff3
Author: Gregory Nutt <gnutt@nuttx.org>
Date:   Wed Jul 26 09:22:03 2017 -0600

    Spirit:  Bring in remainder of calibration interfaces.

commit 40b4b2f902e04293f8940551a97a9a24a48988dd
Author: Gregory Nutt <gnutt@nuttx.org>
Date:   Wed Jul 26 08:44:32 2017 -0600

    Spirit:  Bring in DirectRF interfaces.

commit 7c109608e1a2989f3edbc2fd939a2d225fff382a
Author: Gregory Nutt <gnutt@nuttx.org>
Date:   Wed Jul 26 07:46:19 2017 -0600

    Spirit: Add CSMA support.

commit 0f88896595d162c4ac6138e7b1af2fc35c865b3d
Author: Gregory Nutt <gnutt@nuttx.org>
Date:   Tue Jul 25 18:57:43 2017 -0600

    Spirit:  Add some initial TX logic to network driver.

commit 4dc7058dfcdcf40980578680b7e1a4206dea4ea2
Author: Gregory Nutt <gnutt@nuttx.org>
Date:   Tue Jul 25 17:02:11 2017 -0600

    Spirit: Completes ports of spirit_management.* files

commit c904eef51d929e041b87d0c8aff6fa3c2f895341
Merge: 91e985a877 c9ff8cbab9
Author: Gregory Nutt <gnutt@nuttx.org>
Date:   Tue Jul 25 15:15:04 2017 -0600

    Merge remote-tracking branch 'origin/master' into spirit

commit 91e985a87729017a66d19276c4d47681064f95ea
Author: Gregory Nutt <gnutt@nuttx.org>
Date:   Tue Jul 25 15:13:54 2017 -0600

    Spirit:  Add a few more functions that will soon be needed for packet transmission.

commit b5981d29983907c2194fbc26af4b72ad532bee78
Author: Gregory Nutt <gnutt@nuttx.org>
Date:   Tue Jul 25 13:30:07 2017 -0600

    Spirit:  Finish off some initialization issues; Started some interrupt handling logic.

commit c21073e0bc2870b3d9ba40bdfdfd5151ce4f5890
Author: Gregory Nutt <gnutt@nuttx.org>
Date:   Tue Jul 25 09:35:52 2017 -0600

    Spirit:  Completes very basic radio initialization for network driver

commit 1b544334361c54f46bcf0ba313c125932e8dafc6
Author: Gregory Nutt <gnutt@nuttx.org>
Date:   Tue Jul 25 07:58:30 2017 -0600

    Spirit: Add more radio initialization logic... getting closer.

commit 45d1047db60843c57d394ec910c63e7c127671e0
Author: Gregory Nutt <gnutt@nuttx.org>
Date:   Mon Jul 24 19:15:33 2017 -0600

    Spirit: add some CSMA initialization logic

commit bcf55c71336d48947fe19bb09a799169852301c2
Merge: 89e9d426e9 2fc0fbcf7e
Author: Gregory Nutt <gnutt@nuttx.org>
Date:   Mon Jul 24 16:47:11 2017 -0600

    Merge remote-tracking branch 'origin/master' into spirit

commit 89e9d426e91c056e659fccf5e5c4392618f8f777
Author: Gregory Nutt <gnutt@nuttx.org>
Date:   Mon Jul 24 16:44:19 2017 -0600

    Update some comments

commit 9c5d8a5833350006ed389e898b11c8c8a20e5f4f
Author: Gregory Nutt <gnutt@nuttx.org>
Date:   Mon Jul 24 16:15:54 2017 -0600

    Spirit:  Rename drivers/wireless/spirit/src to lib.  Move Spirit network driver out of IEEE802.15.4 into drivers/wireless/spirit/drivers

commit cabc0ec9e6eb558dcb715ab17264383aa0105e7a
Merge: 87b616414a 6bd744c4b3
Author: Gregory Nutt <gnutt@nuttx.org>
Date:   Mon Jul 24 15:38:40 2017 -0600

    Merge remote-tracking branch 'origin/master' into spirit

commit 87b616414a79c01a71acea78f8258e05325c1996
Author: Gregory Nutt <gnutt@nuttx.org>
Date:   Mon Jul 24 15:37:27 2017 -0600

    Spirit radio driver is mutating into a standalone network driver.

commit 507798233868a661ae8adad3e3aa117075a7a146
Author: Gregory Nutt <gnutt@nuttx.org>
Date:   Mon Jul 24 13:32:08 2017 -0600

    Spirit: More radio initialization logic

commit 33af25704ce9ca83d576300d153cfe31cc6d2576
Author: Gregory Nutt <gnutt@nuttx.org>
Date:   Mon Jul 24 12:19:14 2017 -0600

    Spirit:  Beginning of radio initialization logic

commit 97b20014c016e55952a8f9d8f4ae29e2cc555b23
Author: Gregory Nutt <gnutt@nuttx.org>
Date:   Mon Jul 24 09:42:06 2017 -0600

    Spirit: More initialization logic.

commit 295d8e27824c0417fccea2344b30bb5c93ffbabe
Author: Gregory Nutt <gnutt@nuttx.org>
Date:   Sun Jul 23 15:39:53 2017 -0600

    Spirit:  Add header file containing enumeration of commands.

commit 8a2d9dd8eb9cc70cbcdd1b913fc9022b9c9ec8da
Author: Gregory Nutt <gnutt@nuttx.org>
Date:   Sun Jul 23 11:33:50 2017 -0600

    Spirit:  Add GPIO initialization logic

commit 8b6d80c44f92024c45a6ba63ba1af3fdafe94dc3
Author: Gregory Nutt <gnutt@nuttx.org>
Date:   Sun Jul 23 10:07:25 2017 -0600

    Spirit:  Add interrupt control logic.

commit 423f846fe5c914f92a4bfea4d9d1fa33de1c77a5
Author: Gregory Nutt <gnutt@nuttx.org>
Date:   Sat Jul 22 19:06:52 2017 -0600

    Spirit: Yet a little more radio initialization logic.

commit 5895b979823e51ddde5ad52e6de66a8ad662e883
Author: Gregory Nutt <gnutt@nuttx.org>
Date:   Sat Jul 22 15:36:05 2017 -0600

    Spirit: A little more radio initialization logic.

commit 86311ab30aad386203c181c792847dd1d37f9a02
Author: Gregory Nutt <gnutt@nuttx.org>
Date:   Sat Jul 22 13:02:32 2017 -0600

    Spirit: A miniscule amount of radio initialization logic.

commit ad55e89d5ee12ea1eeea95fcd38ff3da0db4416a
Merge: 90a7666655 f4e46b0da7
Author: Gregory Nutt <gnutt@nuttx.org>
Date:   Sat Jul 22 10:56:30 2017 -0600

    Merge remote-tracking branch 'origin/master' into spirit

commit 90a766665534b05da0157dbc383cb06a98c86a79
Author: Gregory Nutt <gnutt@nuttx.org>
Date:   Sat Jul 22 10:52:52 2017 -0600

    Spirit1:  A few fixes for a clean build of initial configuration (not much there yet)

commit bbbf04c223230a52a7705a2161128265cfbaa480
Merge: 623d54a7f7 2319ea53a9
Author: Gregory Nutt <gnutt@nuttx.org>
Date:   Sat Jul 22 09:53:57 2017 -0600

    Merge remote-tracking branch 'origin/master' into spirit

commit 623d54a7f719e9032099f88f38203efee4b80722
Author: Gregory Nutt <gnutt@nuttx.org>
Date:   Sat Jul 22 09:43:52 2017 -0600

    b-l475e-iot01a: Add a configuration for testing sprit radio.

commit d309d73d9f4665f9d870eb03531f450043d9389d
Merge: 52c3ddfae6 d88dc9b2e5
Author: Gregory Nutt <gnutt@nuttx.org>
Date:   Sat Jul 22 09:02:06 2017 -0600

    Merge remote-tracking branch 'origin/master' into spirit

commit 52c3ddfae6802e111c2b5cf1207baf21a61dd00b
Author: Gregory Nutt <gnutt@nuttx.org>
Date:   Sat Jul 22 08:33:04 2017 -0600

    Spirit:  Add register definition header file.

commit 8d842ab5e8f9ca653b42f9ee88dc279f06b4fa98
Author: Gregory Nutt <gnutt@nuttx.org>
Date:   Fri Jul 21 17:27:03 2017 -0600

    b-l475e-iot01a: Add initial, unverified support for the SPSRGF/Spirit1 module.

commit 73d902a1048616fb9c2dd2147cabcd8ee78e19ac
Author: Gregory Nutt <gnutt@nuttx.org>
Date:   Fri Jul 21 15:49:43 2017 -0600

    Spirit: Fixes to get skeleton IEEE 802.15.4 driver build.

commit ebc5a8387bb94f0cc3827533795f3e4a33207e67
Author: Gregory Nutt <gnutt@nuttx.org>
Date:   Fri Jul 21 15:16:29 2017 -0600

    Spirit1:  Add framework for IEEE 802.15.4 driver.  Does not yet build.

commit 52e195a7ae14ddb18bdd56258f4877381d2501ca
Author: Gregory Nutt <gnutt@nuttx.org>
Date:   Fri Jul 21 14:02:42 2017 -0600

    Spirit:  A little more SPI logic.

commit 90048d0c5b8a5af4d81a15d99535c84ed38d8ae9
Author: Gregory Nutt <gnutt@nuttx.org>
Date:   Fri Jul 21 11:19:06 2017 -0600

    Spirit: Build directories setup.  Some initial files added, mostly just to verify build.

commit 8273a381ac1f6bb081b292b5e73226185e9e634c
Author: Gregory Nutt <gnutt@nuttx.org>
Date:   Fri Jul 21 08:34:04 2017 -0600

    USB composite:  Remove references to CDC/ACM and USB MSC from composite logic.  They are no longer coupled.
This commit is contained in:
Gregory Nutt 2017-07-27 18:04:35 -06:00
parent 6b6d7ce9b9
commit b458934ac4
8 changed files with 1662 additions and 42 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
drivers/wireless/spirit/Kconfig
View File

@ -23,7 +23,7 @@ config WL_SPIRIT_SPIFREQUENCY
config WL_SPIRIT_REGDEBUG
bool "Enable register level debug"
default n
depenes ont DEBUG_WIRELESS_INFO
depends on DEBUG_WIRELESS_INFO
---help---
Enable logic to dump each value read from and written to the Sprit
registers.
@ -31,7 +31,7 @@ config WL_SPIRIT_REGDEBUG
config WL_SPIRIT_FIFODUMP
bool "Enable debug FIFO dump"
default n
depenes ont DEBUG_WIRELESS_INFO
depends on DEBUG_WIRELESS_INFO
---help---
Enable logic to dump data written to and read from the linear FIFO.

22
drivers/wireless/spirit/drivers/Kconfig
View File

@ -54,6 +54,26 @@ config SPIRIT_MTU
6LoWPAN support fragmenting and reassembly of large IPv6 packets.
Each fragment will be up CONFIG_SPIRIT_PKTLEN in length. An single
IPv6 packet maybe fragment into several such frames. This setting
provides the MTU which is the largest fully assembled IPv6 packet that can be sent.
provides the MTU which is the largest fully assembled IPv6 packet
that can be sent.
config SPIRIT_PROMISICUOUS
bool "Promiscuous mode"
default n
---help---
Disables all address filtering. Otherwise, filtering the node
address will be supported.
config SPIRIT_MULTICAST
bool "Multicast address filter"
default n
---help---
Enables address filtering for the multicast addess 0xee.
config SPIRIT_BROADCAST
bool "Broadcast address filter"
default n
---help---
Enables address filtering for the broadcast addess 0xff.
endif # SPIRIT_NETDEV

50
drivers/wireless/spirit/drivers/spirit_netdev.c
View File

@ -279,6 +279,36 @@ static const struct spirit_csma_init_s g_csma_init =
8 /* BU prescaler */
};
#ifdef CONFIG_SPIRIT_MULTICAST
static struct pktbasic_addr_s g_addrinit =
{
S_DISABLE, /* Disable filtering on node address */
0x34, /* Note address (Temporary, until assigned) */
S_DISABLE, /* Disable filtering on multicast address */
0xee, /* Multicast address */
S_DISABLE, /* Disable filtering on broadcast address */
0xff /* Broadcast address */
};
#else
static struct pktbasic_addr_s g_addrinit =
{
S_ENABLE, /* Enable filtering on node address */
0x34, /* Note address (Temporary, until assigned) */
#ifdef CONFIG_SPIRIT_MULTICAST
S_ENABLE, /* Enable filtering on multicast address */
#else
S_DISABLE, /* Disable filtering on multicast address */
#endif
0xee, /* Multicast address */
#ifdef CONFIG_SPIRIT_BROADCAST
S_ENABLE, /* Enable filtering on broadcast address */
#else
S_DISABLE, /* Disable filtering on broadcast address */
#endif
0xff /* Broadcast address */
};
#endif
/****************************************************************************
* Private Functions
****************************************************************************/
@ -1171,8 +1201,16 @@ static int spirit_ifup(FAR struct net_driver_s *dev)
goto error_with_ifalmostup;
}
/* Instantiate the MAC address from dev->d_mac.ether.ether_addr_octet */
/* Instantiate the assigned node address */
#warning Missing logic
#if 0
ret = spirit_pktcommon_set_nodeaddress(spirit, node_address);
if (ret < 0)
{
goto error_with_ifalmostup;
}
#endif
/* Set and activate a timer process */
@ -1655,6 +1693,14 @@ int spirit_hw_initialize(FAR struct spirit_driver_s *priv,
return ret;
}
/* Configure address filtering */
ret = spirit_pktbasic_addr_initialize(spirit, &g_addrinit);
if (ret < 0)
{
return ret;
}
/* Enable the following interrupt sources, routed to GPIO */
ret = spirit_irq_disable_all(spirit);
@ -1752,7 +1798,7 @@ int spirit_hw_initialize(FAR struct spirit_driver_s *priv,
return ret;
}
ret = spirit_timer_set_rxtimeout(spirit, 0); /* 0=No timeout */
ret = spirit_timer_set_rxtimeout_counter(spirit, 0); /* 0=No timeout */
if (ret < 0)
{
return ret;

27
drivers/wireless/spirit/include/spirit_pktbasic.h
View File

@ -37,13 +37,12 @@
#ifndef __DRIVERS_WIRELESS_SPIRIT_INCLUDE_SPIRIT_PKTBASIC_H
#define __DRIVERS_WIRELESS_SPIRIT_INCLUDE_SPIRIT_PKTBASIC_H
/* This module can be used to manage the configuration of Spirit Basic
* packets. The user can obtain a packet configuration filling the
* structure struct pktbasic_init_s, defining in it some general
* parameters for the Spirit Basic packet format. Another structure
* the user can fill is struct struct pktbasic_addr_s to define the
* addresses which will be used during the communication. Moreover,
* functions to set the payload length and the destination address
/* This module can be used to manage the configuration of Spirit Basic packets.
* The user can obtain a packet configuration filling the structure struct
* pktbasic_init_s, defining in it some general parameters for the Spirit Basic
* packet format. Another structure the user can fill is struct pktbasic_addr_s
* to define the addresses which will be used during the communication. In
* addition, functions to set the payload length and the destination address
* are provided.
*
* Example:
@ -62,25 +61,25 @@
* S_ENABLE # whitening
* };
*
* struct struct pktbasic_addr_s g_addrinit =
* struct pktbasic_addr_s g_pktbasic_addrinit =
* {
* S_ENABLE, # enable/disable filtering on my address
* 0x34, # my address (address of the current node)
* S_DISABLE, # enable/disable filtering on multicast address
* 0xEE, # multicast address
* 0xee, # multicast address
* S_DISABLE, # enable/disable filtering on broadcast address
* 0xFF # broadcast address
* 0xff # broadcast address
* };
*
* ...
*
* spirit_pktbasic_initialize(spirit, &g_pkbasic_init);
* spirit_pktbasic_addrinit(spirit, &g_addrinit);
* spirit_pktbasic_addr_initialize(spirit, &g_pktbasic_addrinit);
*
* ...
*
* SpiritPktBasicSetPayloadLength(spirit, 20);
* SpiritPktBasicSetDestinationAddress(spirit, 0x44);
* spirit_pktbasic_set_payloadlen(spirit, 20);
* spirit_pktcommon_set_nodeaddress(spirit, 0x44);
*
* ...
*
@ -223,7 +222,7 @@ int spirit_pktbasic_get_setup(FAR struct spirit_library_s *spirit,
*
* Description:
* Initializes the SPIRIT Basic packet addresses according to the specified
* parameters in the struct struct pktbasic_init_s struct.
* parameters in the struct pktbasic_init_s struct.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance

204
drivers/wireless/spirit/include/spirit_pktstack.h Normal file
View File

@ -0,0 +1,204 @@
/******************************************************************************
* include/nuttx/wireless/spirit/spirit_pktstack.h
* Configuration and management of SPIRIT STack packets.
*
* Copyright(c) 2015 STMicroelectronics
* Author: VMA division - AMS
* Version 3.2.2 08-July-2015
*
* Adapted for NuttX by:
* Author: Gregory Nutt <gnutt@nuttx.org>
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* 3. Neither the name of STMicroelectronics nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
******************************************************************************/
#ifndef __INCLUDE_NUTT_WIRELESS_SPIRIT_SPIRIT_PKTSTACK_H
#define __INCLUDE_NUTT_WIRELESS_SPIRIT_SPIRIT_PKTSTACK_H
/* This module can be used to manage the configuration of Spirit STack
* packets, and it is quite similar to the Basic packets one since the
* STack packets can be considered an extension of Basic.
*
* The user can obtain a packet configuration filling the structure
* struct spirit_pktstack_init_s, defining in it some general parameters
* for the Spirit STack packet format.
*
* Another structure the user can fill is struct spirit_pktstack_address_s
* to define the addresses which will be used during the communication.
* The structure struct spirit_pktstack_llp_s is provided in order to
* configure the link layer protocol features like autoack,
* autoretransmission or piggybacking.
*
* In addiiton, functions to set the payload length and the destination
* address are provided.
*
* Example:
*
* struct spirit_pktstack_init_s g_pktstck_init =
* {
* 0x1a2635a8, # sync word
* PKT_PREAMBLE_LENGTH_08BYTES, # preamble length in bytes
* PKT_SYNC_LENGTH_4BYTES, # sync word length in bytes
* PKT_LENGTH_VAR, # variable or fixed payload length
* 7, # length field width in bits (used only for variable length)
* PKT_NO_CRC, # CRC mode
* PKT_CONTROL_LENGTH_0BYTES, # control field length
* S_DISABLE, # FEC
* S_ENABLE # whitening
* };
*
* struct spirit_pktstack_address_s g_pktstack_addrinit =
* {
* S_ENABLE, # enable/disable filtering on my address
* 0x34, # my address (address of the current node)
* S_DISABLE, # enable/disable filtering on multicast address
* 0xee, # multicast address
* S_DISABLE, # enable/disable filtering on broadcast address
* 0xff # broadcast address
* };
*
* struct spirit_pktstack_llp_s g_pktstack_llpinit =
* {
* S_DISABLE, # enable/disable the autoack feature
* S_DISABLE, # enable/disable the piggybacking feature
* PKT_DISABLE_RETX # set the max number of retransmissions or disable them
* };
* ...
*
* spirit_pktstack_initialize(spirit, &g_pktstck_init);
* spirit_pktstack_address_initialize(spirit, &g_pktstack_addrinit);
* spirit_pktstack_llp_initialize(spirit, &g_pktstack_llpinit);
*
* ...
*
* spirit_pktstack_set_payloadlen(spirit, 20);
* spirit_pktcommon_set_nodeaddress(spirit, 0x44);
*
* ...
*
* The module provides some other functions that can be used to modify or
* read only some configuration parameters.
*/
/******************************************************************************
* Included Files
******************************************************************************/
#include <stding.h>
/******************************************************************************
* Public Types
******************************************************************************/
#ifdef __cplusplus
extern "C"
{
#endif
/* SPIRIT STack Packet Init structure definition. This structure allows users
* to set the main options for the STack packet.
*/
struct spirit_pktstack_init_s
{
uint32_t syncwords; /* Specifies the sync words. This parameter is a
* uint32_t word with format: 0x|SYNC1|SYNC2|SYNC3|SYNC4| */
uint8_t premblen; /* Specifies the preamble length of packet. This
* parameter can be any value from enum pkt_premblen_e */
uint8_t synclen; /* Specifies the sync word length of packet. This
* parameter can be any value of enum pkt_premblen_e */
uint8_t fixedvarlen; /* Specifies if a fixed length of packet has to be
* used. This parameter can be any value of enum
* pkt_fixvar_len_e */
uint8_t pktlenwidth; /* Specifies the size of the length of packet in
* bits. This field is useful only if the field
* fixedvarlen is set to STACK_LENGTH_VAR. For STack
* packets the length width is log2( max payload
* length + control length (0 to 4) + address length
* (always 2)). This parameter is an FAR uint8_t */
uint8_t crcmode; /* Specifies the CRC word length of packet. This
* parameter can be any value of enum pkt_crcmode_e */
uint8_t ctrllen; /* Specifies the length of a control field to be
* sent. This parameter can be any value from
* enum pkt_ctrllen_e */
uint8_t fec; /* Specifies if FEC has to be enabled. This parameter
* can be any value from enum spirit_functional_state_e */
uint8_t datawhite; /* Specifies if data whitening has to be enabled.
* This parameter can be any value from enum
* spirit_functional_state_e */
};
/* SPIRIT STack packet address structure definition. This structure allows
* users to specify the node/multicast/broadcast addresses and the correspondent
* filtering options.
*/
struct spirit_pktstack_address_s
{
uint8_t destfilter; /* If set RX packet is accepted if its destination
* address matches with srcaddr. This parameter
* can be S_ENABLE or S_DISABLE */
uint8_t srcaddr; /* Specifies the TX packet source address (address
* of this node). */
uint8_t mcastfilter; /* If set RX packet is accepted if its destination
* address matches with mcastaddr. This parameter
* can be S_ENABLE or S_DISABLE */
uint8_t mcastaddr; /* Specifies the Multicast group address for this
* node. */
uint8_t bcastfilter; /* If set RX packet is accepted if its destination
* address matches with bcastaddr. This parameter
* can be S_ENABLE or S_DISABLE */
uint8_t bcastaddr; /* Specifies the Broadcast address for this node. */
};
/* SPIRIT STack packet LLP structure definition. This structure allows users
* to configure all the LLP options for STack packets.
*/
struct spirit_pktstack_llp_s
{
uint8_t autoack; /* Specifies if the auto ACK feature
* is used or not. This parameter can
* be a value of
* enum spirit_functional_state_e */
uint8_t piggyback; /* Specifies if the
* piggybacking feature is used
* or not. This parameter can
* be a value of
* enum spirit_functional_state_e */
uint8_t maxretx; /* Specifies the number of
* MAX-Retransmissions. This parameter can be a
* value of enum spirit_maxretx_e */
};
/******************************************************************************
* Public Function Prototypes
******************************************************************************/
#ifdef __cplusplus
}
#endif
#endif /* __INCLUDE_NUTT_WIRELESS_SPIRIT_SPIRIT_PKTSTACK_H */

9
drivers/wireless/spirit/include/spirit_regs.h
View File

@ -1265,11 +1265,12 @@
*
* Default value: 0x00
* Read Write
*
* 7:0 BROADCAST[7:0]: Address shared for broadcast communication link
*/
#define PCKT_FLT_GOALS_BROADCAST_BASE ((uint8_t)0x4c) /* Address shared for broadcast
* communication links */
* communication links */
/* PCKT_FLT_GOALS_MULTICAST register
*
@ -1285,19 +1286,19 @@
*
* Default value: 0x00
* Read Write
*
* 7:0 TX_SOURCE_ADDR[7:0]: TX packet source / RX packet destination fields
*/
#define PCKT_FLT_GOALS_TX_ADDR_BASE ((uint8_t)0x4e) /* Address of the destination (also
* device own address)
*/
* device own address) */
/* PCKT_FLT_OPTIONS register
*
* Default value: 0x70
* Read Write
* 7 Reserved.
*
* 7 Reserved.
* 6 RX_TIMEOUT_AND_OR_SELECT[0]: 1 - ‘OR’ logical function applied to CS/SQI/PQI
* values (masked by 7:5 bits in PROTOCOL register)
* 5 CONTROL_FILTERING[0]: 1 - RX packet accepted if its control fields matches

524
drivers/wireless/spirit/include/spirit_timer.h
View File

@ -37,6 +37,26 @@
#ifndef __DRIVERS_WIRELESS_SPIRIT_INCLUDE_SPIRIT_TIMER_H
#define __DRIVERS_WIRELESS_SPIRIT_INCLUDE_SPIRIT_TIMER_H
/* This module provides API to configure the Spirit timing mechanisms.
* This allows the user to set the timer registers using raw values or
* compute them since the desired timer value is expressed in milliseconds.
* In addition, the management of the Spirit LDCR mode can be done using
* these interfaces.
*
* Example:
* ...
*
* spirit_timer_set_rxtimeout(spirit, 50.0);
* spirit_timer_set_wakeuptimer(spirit, 150.0);
*
* # IRQ configuration for RX_TIMEOUT and WAKEUP_TIMEOUT
* ...
*
* spirit_timer_enable_ldcrmode(spirit, S_ENABLE);
*
* ...
*/
/******************************************************************************
* Included Files
******************************************************************************/
@ -48,6 +68,34 @@
* Pre-processor Definitions
******************************************************************************/
/* This represents the Time Step for RX_Timeout timer in case of 24 MHz
* Crystal, expressed in microseconds. It is equal to 1210/(24*10^6). With
* this time step it is possible to fix the RX_Timeout to a minimum value of
* 50.417us to a maximum value of about 3.278 seconds. Remember that it is
* possible to have infinite RX_Timeout writing 0 in the RX_Timeout_Counter
* and/or RX_Timeout_Prescaler registers.
*/
#define RX_TCLK_24MHz 50.417f
/* This represents the Time Step for RX_Timeout timer in case of 26 MHz
* Crystal, expressed in microseconds. It is equal to 1210/(26*10^6). With
* this time step it is possible to fix the RX_Timeout to a minimum value of
* 46.538us to a maximum value of about 3.026 seconds. Remember that it is
* possible to have infinite RX_Timeout writing 0 in the RX_Timeout_Counter
* register.
*/
#define RX_TCLK_26MHz 46.538f
/* This represents the Time Step for RX_Wakeup timer expressed in
* microseconds. This timer is based on RCO (about 34.7 kHZ). With this
* time step it is possible to fix the Wakeup_Timeout to a minimum value of
* 28.818us to a maximum value of about 1.888 seconds.
*/
#define WAKEUP_TCLK 28.818f
/* Macros used in debug assertions */
#define IS_RX_TIMEOUT_STOP_CONDITION(cond) \
@ -58,6 +106,9 @@
cond == ALL_ABOVE_THRESHOLD || cond == RSSI_OR_SQI_ABOVE_THRESHOLD || \
cond == RSSI_OR_PQI_ABOVE_THRESHOLD || cond == SQI_OR_PQI_ABOVE_THRESHOLD || \
cond == ANY_ABOVE_THRESHOLD)
#define IS_RX_TIMEOUT_24MHz(timeout) ((timeout * 1000) >= RX_TCLK_24MHz)
#define IS_RX_TIMEOUT_26MHz(timeout) ((timeout * 1000) >= RX_TCLK_26MHz)
#define IS_WKUP_TIMEOUT(timeout) ((timeout * 1000) >= WAKEUP_TCLK)
/******************************************************************************
* Public Types
@ -105,10 +156,106 @@ enum spirit_rxtimeout_stopcondition_e
* Public Function Prototypes
******************************************************************************/
/******************************************************************************
* Name: spirit_timer_enable_ldcrmode
*
* Description:
* Enables or Disables the LDCR mode.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* newstate - New state for LDCR mode.
*
* Returned Value:
* Zero (OK) on success; a negated errno value on failure.
*
******************************************************************************/
int spirit_timer_enable_ldcrmode(FAR struct spirit_library_s *spirit,
enum spirit_functional_state_e newstate);
/******************************************************************************
* Name: spirit_timer_enable_autoreload
*
* Description:
* Enables or Disables the LDCR timer reloading with the value stored in the
* LDCR_RELOAD registers.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* newstate - New state for LDCR reloading.
*
* Returned Value:
* Zero (OK) on success; a negated errno value on failure.
*
******************************************************************************/
int spirit_timer_enable_autoreload(FAR struct spirit_library_s *spirit,
enum spirit_functional_state_e newstate);
/******************************************************************************
* Name: spirit_timer_get_autoreload
*
* Description:
* Returns the LDCR timer reload bit.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
*
* Returned Value:
* Value of the reload bit.
*
******************************************************************************/
enum spirit_functional_state_e
spirit_timer_get_autoreload(FAR struct spirit_library_s *spirit);
/******************************************************************************
* Name: spirit_timer_setup_rxtimeout
*
* Description:
* Sets the RX timeout timer initialization registers with the values of
* COUNTER and PRESCALER according to the formula: Trx=PRESCALER*COUNTER*Tck.
* Remember that it is possible to have infinite RX_Timeout writing 0 in the
* RX_Timeout_Counter and/or RX_Timeout_Prescaler registers.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* counter - Value for the timer counter.
* prescaler - Value for the timer prescaler.
*
* Returned Value:
* Zero (OK) on success; a negated errno value on failure.
*
******************************************************************************/
int spirit_timer_setup_rxtimeout(FAR struct spirit_library_s *spirit,
uint8_t counter, uint8_t prescaler);
/******************************************************************************
* Name: spirit_timer_set_rxtimeout
*
* Description:
* Sets the RX timeout timer counter and prescaler from the desired value in
* ms. it is possible to fix the RX_Timeout to a minimum value of 50.417us
* to a maximum value of about 3.28 s.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* desired - Desired timer value.
*
* Returned Value:
* Zero (OK) on success; a negated errno value on failure.
*
******************************************************************************/
int spirit_timer_set_rxtimeout(FAR struct spirit_library_s *spirit,
float desired);
/******************************************************************************
* Name: spirit_timer_set_rxtimeout_counter
*
* Description:
* Sets the RX timeout timer counter. If 'counter' is equal to 0 the
* timeout is disabled.
*
@ -121,8 +268,364 @@ enum spirit_rxtimeout_stopcondition_e
*
******************************************************************************/
int spirit_timer_set_rxtimeout(FAR struct spirit_library_s *spirit,
uint8_t counter);
int spirit_timer_set_rxtimeout_counter(FAR struct spirit_library_s *spirit,
uint8_t counter);
/******************************************************************************
* Name: spirit_timer_set_rxtimeout_prescaler
*
* Description:
* Sets the RX timeout timer prescaler. If it is equal to 0 the timeout is
* infinite.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* prescaler - Value for the timer prescaler.
*
* Returned Value:
* Zero (OK) on success; a negated errno value on failure.
*
******************************************************************************/
int spirit_timer_set_rxtimeout_prescaler(FAR struct spirit_library_s *spirit,
uint8_t prescaler);
/******************************************************************************
* Name: spirit_timer_get_rxtimeout_setup
*
* Description:
* Returns the RX timeout timer.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* mstimeout - Pointer to the variable in which the timeout expressed in
* milliseconds has to be stored. If the returned value is 0,
* it means that the RX_Timeout is infinite.
* counter - Pointer to the variable in which the timer counter has to
* be stored.
* prescaler - Pointer to the variable in which the timer prescaler has to
* be stored.
*
* Returned Value:
* Zero (OK) on success; a negated errno value on failure.
*
******************************************************************************/
int spirit_timer_get_rxtimeout_setup(FAR struct spirit_library_s *spirit,
FAR float *mstimeout,
FAR uint8_t *counter,
FAR uint8_t *prescaler);
/******************************************************************************
* Name: spirit_timer_setup_wakeuptimer
*
* Description:
* Sets the LDCR wake up timer initialization registers with the values of
* COUNTER and PRESCALER according to the formula: Twu=(PRESCALER +1)*(COUNTER+1)*Tck,
* where Tck = 28.818 us. The minimum vale of the wakeup timeout is 28.818us
* (PRESCALER and COUNTER equals to 0) and the maximum value is about 1.89 s
* (PRESCALER anc COUNTER equals to 255).
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* counter - Value for the timer counter.
* prescaler - Value for the timer prescaler.
*
* Returned Value:
* Zero (OK) on success; a negated errno value on failure.
*
******************************************************************************/
int spirit_timer_setup_wakeuptimer(FAR struct spirit_library_s *spirit,
uint8_t counter, uint8_t prescaler);
/******************************************************************************
* Name: spirit_timer_set_wakeuptimer
*
* Description:
* Sets the LDCR wake up timer counter and prescaler from the desired value
* in ms, according to the formula: Twu=(PRESCALER +1)*(COUNTER+1)*Tck,
* where Tck = 28.818 us. The minimum vale of the wakeup timeout is
* 28.818us (PRESCALER and COUNTER equals to 0) and the maximum value is
* about 1.89 s (PRESCALER anc COUNTER equals to 255).
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* desired - Desired timer value.
*
* Returned Value:
* Zero (OK) on success; a negated errno value on failure.
*
******************************************************************************/
int spirit_timer_set_wakeuptimer(FAR struct spirit_library_s *spirit,
float desired);
/******************************************************************************
* Name: spirit_timer_set_wakeuptimer_counter
*
* Description:
* Sets the LDCR wake up timer counter. Remember that this value is
* increased by one in the Twu calculation.
* Twu=(PRESCALER +1)*(COUNTER+1)*Tck, where Tck = 28.818 us
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* counter - Value for the timer counter.
*
* Returned Value:
* Zero (OK) on success; a negated errno value on failure.
*
******************************************************************************/
int spirit_timer_set_wakeuptimer_counter(FAR struct spirit_library_s *spirit,
uint8_t counter);
/******************************************************************************
* Name: spirit_timer_set_wakeuptimer_prescaler
*
* Description:
* Sets the LDCR wake up timer prescaler. Remember that this value is
* increased by one in the Twu calculation.
* Twu=(PRESCALER +1)*(COUNTER+1)*Tck, where Tck = 28.818 us
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* prescaler - Value for the timer prescaler.
*
* Returned Value:
* Zero (OK) on success; a negated errno value on failure.
*
******************************************************************************/
int spirit_timer_set_wakeuptimer_prescaler(FAR struct spirit_library_s *spirit,
uint8_t prescaler);
/******************************************************************************
* Name: spirit_timer_get_wakeuptimer_setup
*
* Description:
* Returns the LDCR wake up timer, according to the formula:
* Twu=(PRESCALER +1)*(COUNTER+1)*Tck, where Tck = 28.818 us.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* wakeupmsec - Pointer to the variable in which the wake-up time expressed
* in milliseconds has to be stored.
* counter - Pointer to the variable in which the timer counter has to
* be stored.
* prescaler - Pointer to the variable in which the timer prescaler has to
* be stored.
*
* Returned Value:
* Zero (OK) on success; a negated errno value on failure.
*
******************************************************************************/
int spirit_timer_get_wakeuptimer_setup(FAR struct spirit_library_s *spirit,
FAR float *wakeupmsec,
FAR uint8_t *counter,
FAR uint8_t *prescaler);
/******************************************************************************
* Name: spirit_timer_setup_wakeuptimer_reload
*
* Description:
* Sets the LDCR wake up timer reloading registers with the values of
* COUNTER and PRESCALER according to the formula:
*
* Twu=(PRESCALER +1)*(COUNTER+1)*Tck
*
* where Tck = 28.818 us. The minimum vale of the wakeup timeout is
* 28.818us (PRESCALER and COUNTER equals to 0) and the maximum value is
* about 1.89 s (PRESCALER anc COUNTER equals to 255).
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* counter - Reload value for the timer counter.
* prescaler - Reload value for the timer prescaler.
*
* Returned Value:
* Zero (OK) on success; a negated errno value on failure.
*
******************************************************************************/
int spirit_timer_setup_wakeuptimer_reload(FAR struct spirit_library_s *spirit,
uint8_t counter, uint8_t prescaler);
/******************************************************************************
* Name: spirit_timer_wakeuptimer_reload
*
* Description:
* Sets the LDCR wake up reload timer counter and prescaler from the desired
* value in ms, according to the formula:
*
* Twu=(PRESCALER +1)*(COUNTER+1)*Tck
*
* where Tck = 28.818 us. The minimum vale of the wakeup timeout is 28.818us
* (PRESCALER and COUNTER equals to 0) and the maximum value is about 1.89 s
* (PRESCALER anc COUNTER equals to 255).
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* desired - Desired timer value.
*
* Returned Value:
* Zero (OK) on success; a negated errno value on failure.
*
******************************************************************************/
int spirit_timer_wakeuptimer_reload(FAR struct spirit_library_s *spirit,
float desired);
/******************************************************************************
* Name: spirit_timer_set_wakeuptimer_reloadcounter
*
* Description:
* Sets the LDCR wake up timer reload counter. Remember that this value is
* increasedd by one in the Twu calculation.
*
* Twu=(PRESCALER +1)*(COUNTER+1)*Tck
*
* where Tck = 28.818 us.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* counter - Value for the timer counter.
*
* Returned Value:
* Zero (OK) on success; a negated errno value on failure.
*
******************************************************************************/
int spirit_timer_set_wakeuptimer_reloadcounter(FAR struct spirit_library_s *spirit,
uint8_t counter);
/******************************************************************************
* Name: spirit_timer_set_wakeuptimer_reloadprescaler
*
* Description:
* Sets the LDCR wake up timer reload prescaler. Remember that this value
* is increasedd by one in the Twu calculation.
*
* Twu=(PRESCALER +1)*(COUNTER+1)*Tck
*
* where Tck = 28.818 us.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* prescaler - Value for the timer prescaler.
*
* Returned Value:
* Zero (OK) on success; a negated errno value on failure.
*
******************************************************************************/
int spirit_timer_set_wakeuptimer_reloadprescaler(FAR struct spirit_library_s *spirit,
uint8_t prescaler);
/******************************************************************************
* Name: spirit_timer_get_wakeuptimer_reload_setup
*
* Description:
* Returns the LDCR wake up reload timer, according to the formula:
*
* Twu=(PRESCALER +1)*(COUNTER+1)*Tck
*
* where Tck = 28.818 us.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* reload - Pointer to the variable in which the wake-up reload time
* expressed in milliseconds has to be stored.
* counter - Pointer to the variable in which the timer counter has to be
* stored.
* prescaler - Pointer to the variable in which the timer prescaler has to
* be stored.
*
* Returned Value:
* Zero (OK) on success; a negated errno value on failure.
*
******************************************************************************/
int spirit_timer_get_wakeuptimer_reload_setup(FAR struct spirit_library_s *spirit,
FAR float *reload,
FAR uint8_t *counter,
FAR uint8_t *prescaler);
/******************************************************************************
* Name: spirit_timer_get_rcofrequency
*
* Description:
* Computes and returns the RCO frequency. This frequency depends on the
* xtal frequency and the XTAL bit in register 0x01.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
*
* Returned Value:
* RCO frequency in Hz.
*
******************************************************************************/
uint16_t spirit_timer_get_rcofrequency(FAR struct spirit_library_s *spirit);
/******************************************************************************
* Name: spirit_timer_calc_wakeup_values
*
* Description:
* Computes the values of the wakeup timer counter and prescaler from the
* user time expressed in millisecond. The prescaler and the counter values
* are computed maintaining the prescaler value as small as possible in
* order to obtain the best resolution, and in the meantime minimizing the error.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* desired - Desired wakeup timeout in millisecs. Since the counter and
* prescaler are 8 bit registers the maximum reachable value is
* maxTime = fTclk x 256 x 256.
* counter - Pointer to the variable in which the value for the wakeup
* timer counter has to be stored.
* prescaler - Pointer to the variable in which the value for the wakeup
* timer prescaler has to be stored.
*
* Returned Value:
* None
*
******************************************************************************/
void spirit_timer_calc_wakeup_values(FAR struct spirit_library_s *spirit,
float desired, FAR uint8_t *counter,
FAR uint8_t *prescaler);
/******************************************************************************
* Name: spirit_timer_calc_rxtimeout_values
*
* Description:
* Computes the values of the rx_timeout timer counter and prescaler from
* the user time expressed in millisecond. The prescaler and the counter
* values are computed maintaining the prescaler value as small as possible
* in order to obtain the best resolution, and in the meantime minimizing
* the error.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* desired - Desired rx_timeout in millisecs. Since the counter and
* prescaler are 8 bit registers the maximum reachable value
* is maxTime = fTclk x 255 x 255.
* counter - Pointer to the variable in which the value for the rx_timeout
* counter has to be stored.
* prescaler - Pointer to the variable in which the value for the rx_timeout
* prescaler has to be stored.
*
* Returned Value:
* None
*
******************************************************************************/
void spirit_timer_calc_rxtimeout_values(FAR struct spirit_library_s *spirit,
float desired, FAR uint8_t *counter,
FAR uint8_t *prescaler);
/******************************************************************************
* Name: spirit_timer_set_rxtimeout_stopcondition
@ -143,4 +646,21 @@ int spirit_timer_set_rxtimeout_stopcondition(FAR struct spirit_library_s *spirit
enum spirit_rxtimeout_stopcondition_e
stopcondition);
/******************************************************************************
* Name: spirit_timer_cmd_reload
*
* Description:
* Sends the LDC_RELOAD command to SPIRIT. Reload the LDC timer with the
* value stored in the LDC_PRESCALER / COUNTER registers.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
*
* Returned Value:
* Zero (OK) on success; a negated errno value on failure.
*
******************************************************************************/
int spirit_timer_cmd_reload(FAR struct spirit_library_s *spirit);
#endif /* __DRIVERS_WIRELESS_SPIRIT_INCLUDE_SPIRIT_TIMER_H */

864
drivers/wireless/spirit/lib/spirit_timer.c
View File

@ -40,6 +40,7 @@
#include <assert.h>
#include "spirit_config.h"
#include "spirit_timer.h"
#include "spirit_radio.h"
#include "spirit_spi.h"
@ -52,29 +53,195 @@
#define S_ABS(a) ((a) > 0 ? (a) : -(a))
/******************************************************************************
* Private Functions
******************************************************************************/
/******************************************************************************
* Name:
*
* Description:
*
* Parameters:
*
* Returned Value:
*
******************************************************************************/
/******************************************************************************
* Public Functions
******************************************************************************/
/******************************************************************************
* Name: spirit_timer_enable_ldcrmode
*
* Description:
* Enables or Disables the LDCR mode.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* newstate - New state for LDCR mode.
*
* Returned Value:
* Zero (OK) on success; a negated errno value on failure.
*
******************************************************************************/
int spirit_timer_enable_ldcrmode(FAR struct spirit_library_s *spirit,
enum spirit_functional_state_e newstate)
{
uint8_t regval;
int ret;
/* Reads the register value */
ret = spirit_reg_read(spirit, PROTOCOL2_BASE, &regval, 1);
if (ret >= 0)
{
/* Mask the read value to enable or disable the LDC mode */
if (newstate == S_ENABLE)
{
regval |= PROTOCOL2_LDC_MODE_MASK;
}
else
{
regval &= ~PROTOCOL2_LDC_MODE_MASK;
}
/* Write to the register to Enable or Disable the LDCR mode */
ret = spirit_reg_write(spirit, PROTOCOL2_BASE, &regval, 1);
}
return ret;
}
/******************************************************************************
* Name: spirit_timer_enable_autoreload
*
* Description:
* Enables or Disables the LDCR timer reloading with the value stored in the
* LDCR_RELOAD registers.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* newstate - New state for LDCR reloading.
*
* Returned Value:
* Zero (OK) on success; a negated errno value on failure.
*
******************************************************************************/
int spirit_timer_enable_autoreload(FAR struct spirit_library_s *spirit,
enum spirit_functional_state_e newstate)
{
uint8_t regval;
int ret;
/* Reads the register value */
ret = spirit_reg_read(spirit, PROTOCOL1_BASE, &regval, 1);
if (ret >= 0)
{
/* Mask te read value to enable or disable the reload on sync mode */
if (newstate == S_ENABLE)
{
regval |= PROTOCOL1_LDC_RELOAD_ON_SYNC_MASK;
}
else
{
regval &= ~PROTOCOL1_LDC_RELOAD_ON_SYNC_MASK;
}
/* Writes the register to Enable or Disable the Auto Reload */
ret = spirit_reg_write(spirit, PROTOCOL1_BASE, &regval, 1);
}
return ret;
}
/******************************************************************************
* Name: spirit_timer_get_autoreload
*
* Description:
* Returns the LDCR timer reload bit.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
*
* Returned Value:
* Value of the reload bit.
*
******************************************************************************/
enum spirit_functional_state_e
spirit_timer_get_autoreload(FAR struct spirit_library_s *spirit)
{
uint8_t regval;
/* Reads the register value */
(void)spirit_reg_read(spirit, PROTOCOL1_BASE, &regval, 1);
return (enum spirit_functional_state_e)(regval & 0x80);
}
/******************************************************************************
* Name: spirit_timer_setup_rxtimeout
*
* Description:
* Sets the RX timeout timer initialization registers with the values of
* COUNTER and PRESCALER according to the formula: Trx=PRESCALER*COUNTER*Tck.
* Remember that it is possible to have infinite RX_Timeout writing 0 in the
* RX_Timeout_Counter and/or RX_Timeout_Prescaler registers.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* counter - Value for the timer counter.
* prescaler - Value for the timer prescaler.
*
* Returned Value:
* Zero (OK) on success; a negated errno value on failure.
*
******************************************************************************/
int spirit_timer_setup_rxtimeout(FAR struct spirit_library_s *spirit,
uint8_t counter, uint8_t prescaler)
{
uint8_t regval[2] = { prescaler, counter };
/* Writes the prescaler and counter value for RX timeout to the corresponding
* register.
*/
return spirit_reg_write(spirit, TIMERS5_RX_TIMEOUT_PRESCALER_BASE, regval, 2);
}
/******************************************************************************
* Name: spirit_timer_set_rxtimeout
*
* Description:
* Sets the RX timeout timer counter and prescaler from the desired value in
* ms. it is possible to fix the RX_Timeout to a minimum value of 50.417us
* to a maximum value of about 3.28 s.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* desired - Desired timer value.
*
* Returned Value:
* Zero (OK) on success; a negated errno value on failure.
*
******************************************************************************/
int spirit_timer_set_rxtimeout(FAR struct spirit_library_s *spirit,
float desired)
{
uint8_t regval[2];
/* Computes the counter and prescaler value */
spirit_timer_calc_rxtimeout_values(spirit, desired, &regval[1], &regval[0]);
/* Writes the prescaler and counter value for RX timeout in the corresponding
* register.
*/
return spirit_reg_write(spirit, TIMERS5_RX_TIMEOUT_PRESCALER_BASE, regval, 2);
}
/******************************************************************************
* Name: spirit_timer_set_rxtimeout_counter
*
* Description:
* Sets the RX timeout timer counter. If 'counter' is equal to 0 the
* timeout is disabled.
*
@ -87,14 +254,654 @@
*
******************************************************************************/
int spirit_timer_set_rxtimeout(FAR struct spirit_library_s *spirit,
uint8_t counter)
int spirit_timer_set_rxtimeout_counter(FAR struct spirit_library_s *spirit,
uint8_t counter)
{
/* Writes the counter value for RX timeout in the corresponding register */
return spirit_reg_write(spirit, TIMERS4_RX_TIMEOUT_COUNTER_BASE, &counter, 1);
}
/******************************************************************************
* Name: spirit_timer_set_rxtimeout_prescaler
*
* Description:
* Sets the RX timeout timer prescaler. If it is equal to 0 the timeout is
* infinite.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* prescaler - Value for the timer prescaler.
*
* Returned Value:
* Zero (OK) on success; a negated errno value on failure.
*
******************************************************************************/
int spirit_timer_set_rxtimeout_prescaler(FAR struct spirit_library_s *spirit,
uint8_t prescaler)
{
/* Writes the prescaler value for RX timeout in the corresponding register */
return spirit_reg_write(spirit, TIMERS5_RX_TIMEOUT_PRESCALER_BASE, &prescaler, 1);
}
/******************************************************************************
* Name: spirit_timer_get_rxtimeout_setup
*
* Description:
* Returns the RX timeout timer.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* mstimeout - Pointer to the variable in which the timeout expressed in
* milliseconds has to be stored. If the returned value is 0,
* it means that the RX_Timeout is infinite.
* counter - Pointer to the variable in which the timer counter has to
* be stored.
* prescaler - Pointer to the variable in which the timer prescaler has to
* be stored.
*
* Returned Value:
* Zero (OK) on success; a negated errno value on failure.
*
******************************************************************************/
int spirit_timer_get_rxtimeout_setup(FAR struct spirit_library_s *spirit,
FAR float *mstimeout,
FAR uint8_t *counter,
FAR uint8_t *prescaler)
{
float xtal_frequency;
uint8_t regval[2];
int ret;
/* Reads the RX timeout registers value */
ret = spirit_reg_read(spirit, TIMERS5_RX_TIMEOUT_PRESCALER_BASE, regval, 2);
if (ret >= 0)
{
/* Returns values */
*prescaler = regval[0];
*counter = regval[1];
xtal_frequency = (float)spirit->xtal_frequency;
if (xtal_frequency > DOUBLE_XTAL_THR)
{
xtal_frequency /= 2.0;
}
xtal_frequency /= 1000.0;
*mstimeout = (float)((regval[0] + 1) * regval[1] * (1210.0 / xtal_frequency));
}
return ret;
}
/******************************************************************************
* Name: spirit_timer_setup_wakeuptimer
*
* Description:
* Sets the LDCR wake up timer initialization registers with the values of
* COUNTER and PRESCALER according to the formula: Twu=(PRESCALER +1)*(COUNTER+1)*Tck,
* where Tck = 28.818 us. The minimum vale of the wakeup timeout is 28.818us
* (PRESCALER and COUNTER equals to 0) and the maximum value is about 1.89 s
* (PRESCALER anc COUNTER equals to 255).
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* counter - Value for the timer counter.
* prescaler - Value for the timer prescaler.
*
* Returned Value:
* Zero (OK) on success; a negated errno value on failure.
*
******************************************************************************/
int spirit_timer_setup_wakeuptimer(FAR struct spirit_library_s *spirit,
uint8_t counter, uint8_t prescaler)
{
uint8_t regval[2] = { prescaler, counter };
/* Writes the counter and prescaler value of wake-up timer in the
* corresponding register */
return spirit_reg_write(spirit, TIMERS3_LDC_PRESCALER_BASE, regval, 2);
}
/******************************************************************************
* Name: spirit_timer_set_wakeuptimer
*
* Description:
* Sets the LDCR wake up timer counter and prescaler from the desired value
* in ms, according to the formula: Twu=(PRESCALER +1)*(COUNTER+1)*Tck,
* where Tck = 28.818 us. The minimum vale of the wakeup timeout is
* 28.818us (PRESCALER and COUNTER equals to 0) and the maximum value is
* about 1.89 s (PRESCALER anc COUNTER equals to 255).
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* desired - Desired timer value.
*
* Returned Value:
* Zero (OK) on success; a negated errno value on failure.
*
******************************************************************************/
int spirit_timer_set_wakeuptimer(FAR struct spirit_library_s *spirit,
float desired)
{
uint8_t regval[2];
/* Computes counter and prescaler */
spirit_timer_calc_wakeup_values(spirit, desired, &regval[1], &regval[0]);
/* Writes the counter and prescaler value of wake-up timer in the
* corresponding register */
return spirit_reg_write(spirit, TIMERS3_LDC_PRESCALER_BASE, regval, 2);
}
/******************************************************************************
* Name: spirit_timer_set_wakeuptimer_counter
*
* Description:
* Sets the LDCR wake up timer counter. Remember that this value is
* increased by one in the Twu calculation.
* Twu=(PRESCALER +1)*(COUNTER+1)*Tck, where Tck = 28.818 us
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* counter - Value for the timer counter.
*
* Returned Value:
* Zero (OK) on success; a negated errno value on failure.
*
******************************************************************************/
int spirit_timer_set_wakeuptimer_counter(FAR struct spirit_library_s *spirit,
uint8_t counter)
{
/* Writes the counter value for Wake_Up timer in the corresponding register */
return spirit_reg_write(spirit, TIMERS2_LDC_COUNTER_BASE, &counter, 1);
}
/******************************************************************************
* Name: spirit_timer_set_wakeuptimer_prescaler
*
* Description:
* Sets the LDCR wake up timer prescaler. Remember that this value is
* increased by one in the Twu calculation.
* Twu=(PRESCALER +1)*(COUNTER+1)*Tck, where Tck = 28.818 us
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* prescaler - Value for the timer prescaler.
*
* Returned Value:
* Zero (OK) on success; a negated errno value on failure.
*
******************************************************************************/
int spirit_timer_set_wakeuptimer_prescaler(FAR struct spirit_library_s *spirit,
uint8_t prescaler)
{
/* Writes the prescaler value for Wake_Up timer in the corresponding
* register .
*/
return spirit_reg_write(spirit, TIMERS3_LDC_PRESCALER_BASE, &prescaler, 1);
}
/******************************************************************************
* Name: spirit_timer_get_wakeuptimer_setup
*
* Description:
* Returns the LDCR wake up timer, according to the formula:
* Twu=(PRESCALER +1)*(COUNTER+1)*Tck, where Tck = 28.818 us.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* wakeupmsec - Pointer to the variable in which the wake-up time expressed
* in milliseconds has to be stored.
* counter - Pointer to the variable in which the timer counter has to
* be stored.
* prescaler - Pointer to the variable in which the timer prescaler has to
* be stored.
*
* Returned Value:
* Zero (OK) on success; a negated errno value on failure.
*
******************************************************************************/
int spirit_timer_get_wakeuptimer_setup(FAR struct spirit_library_s *spirit,
FAR float *wakeupmsec,
FAR uint8_t *counter,
FAR uint8_t *prescaler)
{
uint8_t regval[2];
float rco_freq;
int ret;
rco_freq = (float)spirit_timer_get_rcofrequency(spirit);
/* Reads the Wake_Up timer registers value */
ret = spirit_reg_read(spirit, TIMERS3_LDC_PRESCALER_BASE, regval, 2);
if (ret >= 0)
{
/* Return values */
*prescaler = regval[0];
*counter = regval[1];
*wakeupmsec = (float)((((*prescaler) + 1) * ((*counter) + 1) * (1000.0 / rco_freq)));
}
return ret;
}
/******************************************************************************
* Name: spirit_timer_setup_wakeuptimer_reload
*
* Description:
* Sets the LDCR wake up timer reloading registers with the values of
* COUNTER and PRESCALER according to the formula:
*
* Twu=(PRESCALER +1)*(COUNTER+1)*Tck
*
* where Tck = 28.818 us. The minimum vale of the wakeup timeout is
* 28.818us (PRESCALER and COUNTER equals to 0) and the maximum value is
* about 1.89 s (PRESCALER anc COUNTER equals to 255).
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* counter - Reload value for the timer counter.
* prescaler - Reload value for the timer prescaler.
*
* Returned Value:
* Zero (OK) on success; a negated errno value on failure.
*
******************************************************************************/
int spirit_timer_setup_wakeuptimer_reload(FAR struct spirit_library_s *spirit,
uint8_t counter, uint8_t prescaler)
{
uint8_t regval[2] = { prescaler, counter };
/* Write the counter and prescaler value of reload wake-up timer in the
* corresponding register
*/
return spirit_reg_write(spirit, TIMERS1_LDC_RELOAD_PRESCALER_BASE, regval, 2);
}
/******************************************************************************
* Name: spirit_timer_wakeuptimer_reload
*
* Description:
* Sets the LDCR wake up reload timer counter and prescaler from the desired
* value in ms, according to the formula:
*
* Twu=(PRESCALER +1)*(COUNTER+1)*Tck
*
* where Tck = 28.818 us. The minimum vale of the wakeup timeout is 28.818us
* (PRESCALER and COUNTER equals to 0) and the maximum value is about 1.89 s
* (PRESCALER anc COUNTER equals to 255).
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* desired - Desired timer value.
*
* Returned Value:
* Zero (OK) on success; a negated errno value on failure.
*
******************************************************************************/
int spirit_timer_wakeuptimer_reload(FAR struct spirit_library_s *spirit,
float desired)
{
uint8_t regval[2];
/* Computes counter and prescaler */
spirit_timer_calc_wakeup_values(spirit, desired, &regval[1], &regval[0]);
/* Writes the counter and prescaler value of reload wake-up timer in the
* corresponding register */
return spirit_reg_write(spirit, TIMERS1_LDC_RELOAD_PRESCALER_BASE, regval, 2);
}
/******************************************************************************
* Name: spirit_timer_set_wakeuptimer_reloadcounter
*
* Description:
* Sets the LDCR wake up timer reload counter. Remember that this value is
* increased by one in the Twu calculation.
*
* Twu=(PRESCALER +1)*(COUNTER+1)*Tck
*
* where Tck = 28.818 us.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* counter - Value for the timer counter.
*
* Returned Value:
* Zero (OK) on success; a negated errno value on failure.
*
******************************************************************************/
int spirit_timer_set_wakeuptimer_reloadcounter(FAR struct spirit_library_s *spirit,
uint8_t counter)
{
/* Write the counter value for reload Wake_Up timer in the corresponding
* register.
*/
return spirit_reg_write(spirit, TIMERS0_LDC_RELOAD_COUNTER_BASE, &counter, 1);
}
/******************************************************************************
* Name: spirit_timer_set_wakeuptimer_reloadprescaler
*
* Description:
* Sets the LDCR wake up timer reload prescaler. Remember that this value
* is increasedd by one in the Twu calculation.
*
* Twu=(PRESCALER +1)*(COUNTER+1)*Tck
*
* where Tck = 28.818 us.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* prescaler - Value for the timer prescaler.
*
* Returned Value:
* Zero (OK) on success; a negated errno value on failure.
*
******************************************************************************/
int spirit_timer_set_wakeuptimer_reloadprescaler(FAR struct spirit_library_s *spirit,
uint8_t prescaler)
{
/* Writes the prescaler value for reload Wake_Up timer in the corresponding
* register.
*/
return spirit_reg_write(spirit, TIMERS1_LDC_RELOAD_PRESCALER_BASE, &prescaler, 1);
}
/******************************************************************************
* Name: spirit_timer_get_wakeuptimer_reload_setup
*
* Description:
* Returns the LDCR wake up reload timer, according to the formula:
*
* Twu=(PRESCALER +1)*(COUNTER+1)*Tck
*
* where Tck = 28.818 us.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* reload - Pointer to the variable in which the wake-up reload time
* expressed in milliseconds has to be stored.
* counter - Pointer to the variable in which the timer counter has to be
* stored.
* prescaler - Pointer to the variable in which the timer prescaler has to
* be stored.
*
* Returned Value:
* Zero (OK) on success; a negated errno value on failure.
*
******************************************************************************/
int spirit_timer_get_wakeuptimer_reload_setup(FAR struct spirit_library_s *spirit,
FAR float *reload,
FAR uint8_t *counter,
FAR uint8_t *prescaler)
{
uint8_t regval[2];
float rco_freq;
int ret;
rco_freq = (float)spirit_timer_get_rcofrequency(spirit);
/* Reads the reload Wake_Up timer registers value */
ret = spirit_reg_read(spirit, TIMERS1_LDC_RELOAD_PRESCALER_BASE, regval, 2);
if (ret >= 0)
{
/* Returns values */
*prescaler = regval[0];
*counter = regval[1];
*reload = (float)((((*prescaler) + 1) * ((*counter) + 1) * (1000.0 / rco_freq)));
}
return ret;
}
/******************************************************************************
* Name: spirit_timer_get_rcofrequency
*
* Description:
* Computes and returns the RCO frequency. This frequency depends on the
* xtal frequency and the XTAL bit in register 0x01.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
*
* Returned Value:
* RCO frequency in Hz.
*
******************************************************************************/
uint16_t spirit_timer_get_rcofrequency(FAR struct spirit_library_s *spirit)
{
uint32_t xtal_frequency = spirit->xtal_frequency;
uint16_t rco_freq = 34700;
uint8_t xtal_flag;
if (xtal_frequency > 30000000)
{
xtal_frequency /= 2;
}
if (xtal_frequency == 25000000)
{
(void)spirit_reg_read(spirit, 0x01, &xtal_flag, 1);
xtal_flag = (xtal_flag & 0x40);
if (xtal_flag == 0)
{
rco_freq = 36100;
}
else
{
rco_freq = 33300;
}
}
return rco_freq;
}
/******************************************************************************
* Name: spirit_timer_calc_wakeup_values
*
* Description:
* Computes the values of the wakeup timer counter and prescaler from the
* user time expressed in millisecond. The prescaler and the counter values
* are computed maintaining the prescaler value as small as possible in
* order to obtain the best resolution, and in the meantime minimizing the error.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* desired - Desired wakeup timeout in millisecs. Since the counter and
* prescaler are 8 bit registers the maximum reachable value is
* maxTime = fTclk x 256 x 256.
* counter - Pointer to the variable in which the value for the wakeup
* timer counter has to be stored.
* prescaler - Pointer to the variable in which the value for the wakeup
* timer prescaler has to be stored.
*
* Returned Value:
* None
*
******************************************************************************/
void spirit_timer_calc_wakeup_values(FAR struct spirit_library_s *spirit,
float desired, FAR uint8_t *counter,
FAR uint8_t *prescaler)
{
float rco_freq, err;
uint32_t n;
rco_freq = ((float)spirit_timer_get_rcofrequency(spirit)) / 1000;
/* N cycles in the time base of the timer: - clock of the timer is RCO
* frequency - divide times 1000 more because we have an input in ms
* (variable rco_freq is already this frequency divided by 1000) */
n = (uint32_t)(desired * rco_freq);
/* check if it is possible to reach that target with prescaler and counter of
* spirit1 */
if (n / 0xff > 0xfd)
{
/* if not return the maximum possible value */
*counter = 0xff;
*prescaler = 0xff;
return;
}
/* prescaler is really 2 as min value */
*prescaler = (n / 0xff) + 2;
*counter = n / (*prescaler);
/* check if the error is minimum */
err = S_ABS((float)(*counter) * (*prescaler) / rco_freq - desired);
if ((*counter) <= 254)
{
if (S_ABS((float)((*counter) + 1) * (*prescaler) / rco_freq - desired) < err)
{
(*counter)++;
}
}
/* decrement prescaler and counter according to the logic of this timer in
* spirit1.
*/
(*prescaler)--;
if (*counter > 1)
{
(*counter)--;
}
else
{
*counter = 1;
}
}
/******************************************************************************
* Name: spirit_timer_calc_rxtimeout_values
*
* Description:
* Computes the values of the rx_timeout timer counter and prescaler from
* the user time expressed in millisecond. The prescaler and the counter
* values are computed maintaining the prescaler value as small as possible
* in order to obtain the best resolution, and in the meantime minimizing
* the error.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* desired - Desired rx_timeout in millisecs. Since the counter and
* prescaler are 8 bit registers the maximum reachable value
* is maxTime = fTclk x 255 x 255.
* counter - Pointer to the variable in which the value for the rx_timeout
* counter has to be stored.
* prescaler - Pointer to the variable in which the value for the rx_timeout
* prescaler has to be stored.
*
* Returned Value:
* None
*
******************************************************************************/
void spirit_timer_calc_rxtimeout_values(FAR struct spirit_library_s *spirit,
float desired, FAR uint8_t *counter,
FAR uint8_t *prescaler)
{
uint32_t xtal_frequency = spirit->xtal_frequency;
uint32_t n;
float err;
/* if xtal_frequency is doubled divide it by 2 */
if (xtal_frequency > DOUBLE_XTAL_THR)
{
xtal_frequency >>= 1;
}
/* N cycles in the time base of the timer: - clock of the timer is xtal/1210
* - divide times 1000 more because we have an input in ms.
*/
n = (uint32_t)(desired * xtal_frequency / 1210000);
/* check if it is possible to reach that target with prescaler and counter of
* spirit1.
*/
if (n / 0xff > 0xfd)
{
/* if not return the maximum possible value */
*counter = 0xff;
*prescaler = 0xff;
return;
}
/* prescaler is really 2 as min value */
*prescaler = (n / 0xff) + 2;
*counter = n / (*prescaler);
/* check if the error is minimum */
err = S_ABS((float)(*counter) * (*prescaler) * 1210000 / xtal_frequency - desired);
if ((*counter) <= 254)
{
if (S_ABS((float)((*counter) + 1) * (*prescaler) * 1210000 / xtal_frequency - desired) < err)
{
(*counter)++;
}
}
/* decrement prescaler and counter according to the logic of this timer in
* spirit1 */
(*prescaler)--;
if ((*counter) > 1)
{
(*counter)--;
}
else
{
*counter = 1;
}
}
/******************************************************************************
* Name: spirit_timer_set_rxtimeout_stopcondition
*
@ -139,3 +946,26 @@ int spirit_timer_set_rxtimeout_stopcondition(FAR struct spirit_library_s *spirit
return ret;
}
/******************************************************************************
* Name: spirit_timer_cmd_reload
*
* Description:
* Sends the LDC_RELOAD command to SPIRIT. Reload the LDC timer with the
* value stored in the LDC_PRESCALER / COUNTER registers.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
*
* Returned Value:
* Zero (OK) on success; a negated errno value on failure.
*
******************************************************************************/
int spirit_timer_cmd_reload(FAR struct spirit_library_s *spirit)
{
/* Sends the CMD_LDC_RELOAD command */
return spirit_command(spirit, COMMAND_LDC_RELOAD);
}