Compare commits

..

64 Commits

Author SHA1 Message Date
Roy 986350ef5e Modify(#2): remove Display code 2023-04-18 16:08:40 +08:00
Roy d2e37ce574 Revert(#2): Elite BAT1.0 renascent 2023-04-18 15:35:23 +08:00
ROY cdf50c6c48 [clean] 2023-03-16 16:02:26 +08:00
ROY 47f4fd49e5 [clean] 2023-03-16 15:41:54 +08:00
ROY 9e623f46da [clean] 2023-03-16 15:39:41 +08:00
ROY 42d803e739 [clean] 2023-03-16 15:31:56 +08:00
ROY e4bef28ead [clean] 2023-03-16 15:17:18 +08:00
ROY ae61ec610f [clean] 2023-03-16 15:09:45 +08:00
ROY f3a8943c1e [clean] 2023-03-16 15:02:55 +08:00
ROY 3990c4db8f [clean] 2023-03-16 14:57:37 +08:00
ROY ead65c3c94 [clean] 2023-03-16 14:51:06 +08:00
ROY b41e757e44 [clean] 2023-03-16 14:44:57 +08:00
ROY bfcf716b94 [clean] 2023-03-16 14:35:27 +08:00
ROY ba1aeb4670 [clean] 2023-03-16 14:29:54 +08:00
ROY 6541fd1386 [update] update timer 2023-03-16 13:40:35 +08:00
ROY b95ebc697e [update] update gpio 2023-03-16 12:43:01 +08:00
ROY dbb85e508a [update] update gpio 2023-03-15 18:03:03 +08:00
ROY 39dd62b0a0 [update] update gpio code 2023-03-15 16:45:21 +08:00
ROY 2a24c65ad6 [update] update i2c code 2023-03-15 16:39:02 +08:00
ROY 2908c595d1 [update] update main.c code 2023-03-15 10:51:35 +08:00
ROY f9aa353292 [update] edit code 2023-03-15 10:48:08 +08:00
ROY df0f87c281 [update] fix MCP23008 2023-03-15 10:46:11 +08:00
ROY 82ca5435f5 [update] update spi0/1_write 2023-03-15 09:44:29 +08:00
ROY 18c25c1e62 [update] update ADGS1412 library 2023-03-08 18:04:18 +08:00
ROY ce47324003 [update] define header file 2023-03-08 16:56:02 +08:00
ROY 390822f893 [update] update MAX5136 library 2023-03-08 15:07:15 +08:00
ROY fa06908a08 [update] update APA102 library 2023-03-08 14:57:20 +08:00
ROY bb425dd5bd [update] update MCP23008 library 2023-03-08 14:54:31 +08:00
ROY 607702ae23 [update] update MCP23008 library 2023-03-08 11:11:19 +08:00
ROY 09c3a67657 [update] update i2c function 2023-03-06 14:34:04 +08:00
ROY 05e8dc5982 [update] update led function 2023-03-03 15:01:06 +08:00
ROY 62d28c4054 [update] update spi function 2023-03-03 14:46:23 +08:00
ROY 84339ea967 [update] clean up pin define and gatt function 2023-03-03 11:07:28 +08:00
ROY b5da45124d [update] clean up pin define and gatt function 2023-03-03 11:07:09 +08:00
ROY 8d9e4eab63 [update] update gatt file 2023-03-02 14:52:21 +08:00
ROY 41d20603d1 [update] update gatt file 2023-03-02 13:35:36 +08:00
ROY 10a9a617ab [update] update device name 2023-02-14 14:21:18 +08:00
ROY 7fb3bd976f [update] fix led status 2023-02-14 14:17:25 +08:00
ROY d2a3a9a712 [update] spi 10M & update boot process 2023-01-30 17:33:03 +08:00
ROY ee75ad8341 [update] note spi 2023-01-30 17:31:21 +08:00
ROY 552569d985 [update] note mcp23008 reg_name 2023-01-17 10:16:04 +08:00
JayC319 d0fe825a7b [update] update switch control 2022-08-31 14:37:12 +08:00
JayC319 07e31e42ab [update] update DAC 2022-08-29 16:41:28 +08:00
ROY 508b257e35 [update] add dev tool for open spi1 2022-06-09 10:32:02 +08:00
ROY 45ecdf8835 [update] add dev tool for open spi 2022-06-09 09:42:19 +08:00
ROY 3e8ab75923 [update] add dev tool for open spi 2022-06-09 09:41:29 +08:00
Roy 925183496c [update] don't use GPT_MODE_PERIODIC_DOWN 2022-05-18 15:21:17 +08:00
Roy 9977a323b2 [update] fix 15v error 2022-05-13 11:18:11 +08:00
Roy 33ea52104f [update] spi of dev tool 2022-05-13 10:20:28 +08:00
Roy cc8ac71bda [update] switch on/off elite ok 2022-05-12 18:28:14 +08:00
Roy 09e8cbbc89 [update] switch on/off elite ok 2022-05-12 14:09:16 +08:00
Roy cca7cf7b5d [update] switch on/off elite 2022-05-12 09:33:50 +08:00
Roy eb5366c3c2 [update] edc2.0 i2c ok 2022-05-10 18:32:38 +08:00
Roy 14fcd46d4b [update] edc2.0 i2c ok 2022-05-10 14:29:51 +08:00
Roy 26f412f1b0 [update] edc2.0 boot ok 2022-05-04 16:57:05 +08:00
Roy 31874d41d7 [update] DEV_TOOL_I2C finished 2022-04-28 17:40:46 +08:00
Roy efd9656a0f [update] edc2.0 i2c not done 2022-04-26 18:27:37 +08:00
Roy cbd5099942 [update] edc2.0 led ok 2022-04-22 09:35:43 +08:00
Roy 2778dd245b [update] edc2.0 led ok 2022-04-22 09:35:34 +08:00
Roy e9a366450b [update] step3 - dev_tool_led ok 2022-04-21 18:47:48 +08:00
Roy 86eec48e68 [update] step2 - board ok 2022-04-19 16:48:55 +08:00
Roy 3b1fe9d4cd [update] step2 - board ok 2022-04-19 15:42:13 +08:00
Roy 7003cbaa7a [update] step1 - merge led code ok 2022-04-19 13:02:44 +08:00
Roy 868bf3ab5b [update] merge all code 2022-04-18 17:54:25 +08:00
45 changed files with 435 additions and 25267 deletions
@@ -50,7 +50,7 @@ extern "C" {
* ==========================================================================*/
#include <ti/drivers/PIN.h>
#include <driverlib/ioc.h>
#include "boards_config/elite_boards_select.h"
// #include "application_config/application_config.h"
/** ============================================================================
* Externs
@@ -146,12 +146,6 @@ extern const PIN_Config BoardGpioInitTable[];
#define Board_UART_TX Board_BP_UART_Rx /* RXD */
#define Board_UART_RX Board_BP_UART_Tx /* TXD */
// /* SPI Board */
// #define Board_SPI0_MISO Board_BP_SPI_MISO
// #define Board_SPI0_MOSI Board_BP_SPI_MOSI
// #define Board_SPI0_CLK Board_BP_SPI_CLK
// #define Board_SPI0_CS Board_BP_SPI_CS_Wireless
/* Power Management Board */
#define Board_SRDY Board_BP_Pin_J2_19
#define Board_MRDY Board_BP_Pin_J1_2
@@ -166,6 +160,35 @@ extern const PIN_Config BoardGpioInitTable[];
#define Board_PWMPIN6 PIN_UNASSIGNED
#define Board_PWMPIN7 PIN_UNASSIGNED
/* SPI & I2C Board */
#ifndef DEF_ELITE_MODEL
#define Board_SPI0_MISO Board_BP_SPI_MISO
#define Board_SPI0_MOSI Board_BP_SPI_MOSI
#define Board_SPI0_CLK Board_BP_SPI_CLK
#define Board_SPI0_CS Board_BP_SPI_CS_Wireless
#define Board_SPI1_MISO PIN_UNASSIGNED
#define Board_SPI1_MOSI PIN_UNASSIGNED
#define Board_SPI1_CLK PIN_UNASSIGNED
#define Board_SPI1_CS PIN_UNASSIGNED
#define Board_I2C0_SCL0 PIN_UNASSIGNED
#define Board_I2C0_SDA0 PIN_UNASSIGNED
#else
#define Board_SPI0_MISO E_SPI0_MISO
#define Board_SPI0_MOSI E_SPI0_MOSI
#define Board_SPI0_CLK E_SPI0_CLK
#define Board_SPI0_CS E_SPI0_CS
#define Board_SPI1_MISO E_SPI1_MISO
#define Board_SPI1_MOSI E_SPI1_MOSI
#define Board_SPI1_CLK E_SPI1_CLK
#define Board_SPI1_CS E_SPI1_CS
#define Board_I2C0_SCL0 E_I2C0_SCL0
#define Board_I2C0_SDA0 E_I2C0_SDA0
#endif
/** ============================================================================
* Instance identifiers
* ==========================================================================*/
@@ -1,143 +0,0 @@
#ifndef ELITE_BOARDS_SELECT_H
#define ELITE_BOARDS_SELECT_H
#ifdef __cplusplus
extern "C" {
#endif
/*
*
* product number: MAJOR_PRODUCT_NUMBER, MINOR_PRODUCT_NUMBER, MAJOR_VERSION_NUMBER, MINOR_VERSION_NUMBER
* MAJOR_PRODUCT_NUMBER -> 0:Elite, 1:other serial
* Elite:
* MINOR_PRODUCT_NUMBER -> 1:legacy, 2:EDC, 3:BAT, 4:EIS, 5:TRIG, 6:MEGAFLY
*
* +------------------------+----------------------+-------------------------+----------------+----------------------+----------------------+----------+
* | model name | hw upper board | hw lower board | product number | device name | data server lib name | UI |
* +------------------------+----------------------+-------------------------+----------------+----------------------+----------------------+----------+
* | DEF_ELITE_EDC_14 | Elite1.4-re Jun.2019 | Elite1.4-re Jun. 2019 | 0, 2, 1, 5 | "Elite-EDC" | Elite_EDC_1.4 | null |
* | DEF_ELITE_EDC_15 | Elite1.5 Dec. 2019 | Elite1.5 Dec. 2019 | 0, 2, 1, 6 | "Elite-EDC" | Elite_EDC_1.5 | EliteEDC |
* | DEF_ELITE_EDC_15RE | Elite1.5 Dec. 2019 | Elite1.5-re Jan. 2021 | 0, 2, 1, 7 | "Elite-EDC" | Elite_EDC_1.5re | EliteEDC |
* | DEF_ELITE_EDC_15R2 | Elite1.5 Dec. 2019 | Elite1.5-r2 May. 2022 | 0, 2, 1, 8 | "Elite-EDC" | Elite_EDC_1.5r2 | EliteEDC |
* | DEF_ELITE_BAT_10 | Elite2.0 Feb. 2022 | 0, 3, 1, 0 | "Elite-BAT" | Elite_BAT_1.0 | EliteEDC |
* | DEF_ELITE_EIS_10 | Elite1.5 Dec. 2019 | Elite EIS1.0 Aug. 2020 | 0, 4, 1, 0 | "Elite-EIS" | Elite_EIS_1.0 | EliteEIS |
* | DEF_ELITE_EIS_11 | Elite1.5 Dec. 2019 | Elite EIS1.1 Feb. 2022 | 0, 4, 1, 1 | "Elite-EIS" | Elite_EIS_1.1 | EliteEIS |
* | DEF_ELITE_EIS_MINI_10 | EIS MINI May. 2022 | 0, 4, 1, 2 | "Elite-EIS-MINI" | Elite_EIS_MINI_1.0 | EliteEIS |
* | DEF_ELITE_TRIG_01 | Elite TRIG01 Jan. 2021 | 0, 5, 1, 0 | "Elite-TRIG" | Elite_TRIG_0.1 | null |
* | DEF_ELITE_MEGAFLY_01 | Elite1.5 Dec. 2019 | Elite Megafly Sep. 2020 | 0, 6, 1, 0 | "Elite-MEGAFLY" | Elite_MEGAFLY_0.1 | null |
* +------------------------+----------------------+-------------------------+----------------+----------------------+----------------------+----------+
* ps.
* model name is FW engineer defined
* device name is used for controller
*/
#define DEF_ELITE_EDC_14 0
#define DEF_ELITE_EDC_15 1
#define DEF_ELITE_EDC_15RE 2
#define DEF_ELITE_EDC_15R2 3
#define DEF_ELITE_BAT_10 4
#define DEF_ELITE_EIS_10 5
#define DEF_ELITE_EIS_11 6
#define DEF_ELITE_EIS_MINI_10 7
#define DEF_ELITE_TRIG_01 8
#define DEF_ELITE_MEGAFLY_01 9
#define DEF_ELITE_MAX 10
#define DEF_ELITE_MODEL DEF_ELITE_EIS_11
#ifndef DEF_ELITE_MODEL
#error "DEF_ELITE_MODEL not defined"
#endif
#if (DEF_ELITE_MODEL == DEF_ELITE_EDC_14)
#error "code no support" // need fix
#elif (DEF_ELITE_MODEL == DEF_ELITE_EDC_15)
#error "code no support" // need fix
#elif (DEF_ELITE_MODEL == DEF_ELITE_EDC_15RE)
#include "boards_config/pin_def_edc15re.h"
#elif (DEF_ELITE_MODEL == DEF_ELITE_EDC_15R2)
#error "code no support" // need fix
#elif (DEF_ELITE_MODEL == DEF_ELITE_EIS_10)
#error "code no support" // need fix
#elif (DEF_ELITE_MODEL == DEF_ELITE_EIS_11)
#include "boards_config/pin_def_eis11.h"
#elif (DEF_ELITE_MODEL == DEF_ELITE_EIS_MINI_10)
#include "boards_config/pin_config_eis_mini_10.h"
#elif (DEF_ELITE_MODEL == DEF_ELITE_BAT_10)
#error "code no support" // need fix
#elif (DEF_ELITE_MODEL == DEF_ELITE_MEGAFLY_01)
#error "code no support" // need fix
#elif (DEF_ELITE_MODEL == DEF_ELITE_TRIG_01)
#error "code no support" // need fix
#else
#error "no this model"
#endif
// model information
#if (DEF_ELITE_MODEL == DEF_ELITE_EDC_14)
#define DEVICE_NAME "Elite-EDC"
#define MAJOR_PRODUCT_NUMBER 0
#define MINOR_PRODUCT_NUMBER 2
#define MAJOR_VERSION_NUMBER 1
#define MINOR_VERSION_NUMBER 5
#elif (DEF_ELITE_MODEL == DEF_ELITE_EDC_15)
#define DEVICE_NAME "Elite-EDC"
#define MAJOR_PRODUCT_NUMBER 0
#define MINOR_PRODUCT_NUMBER 2
#define MAJOR_VERSION_NUMBER 1
#define MINOR_VERSION_NUMBER 6
#elif (DEF_ELITE_MODEL == DEF_ELITE_EDC_15RE)
#define DEVICE_NAME "Elite-EDC"
#define MAJOR_PRODUCT_NUMBER 0
#define MINOR_PRODUCT_NUMBER 2
#define MAJOR_VERSION_NUMBER 1
#define MINOR_VERSION_NUMBER 7
#elif (DEF_ELITE_MODEL == DEF_ELITE_EDC_15R2)
#define DEVICE_NAME "Elite-EDC"
#define MAJOR_PRODUCT_NUMBER 0
#define MINOR_PRODUCT_NUMBER 2
#define MAJOR_VERSION_NUMBER 1
#define MINOR_VERSION_NUMBER 8
#elif (DEF_ELITE_MODEL == DEF_ELITE_BAT_10)
#define DEVICE_NAME "Elite-BAT"
#define MAJOR_PRODUCT_NUMBER 0
#define MINOR_PRODUCT_NUMBER 3
#define MAJOR_VERSION_NUMBER 1
#define MINOR_VERSION_NUMBER 0
#elif (DEF_ELITE_MODEL == DEF_ELITE_EIS_10)
#define DEVICE_NAME "Elite-EIS"
#define MAJOR_PRODUCT_NUMBER 0
#define MINOR_PRODUCT_NUMBER 4
#define MAJOR_VERSION_NUMBER 1
#define MINOR_VERSION_NUMBER 0
#elif (DEF_ELITE_MODEL == DEF_ELITE_EIS_11)
#define DEVICE_NAME "Elite-EIS"
#define MAJOR_PRODUCT_NUMBER 0
#define MINOR_PRODUCT_NUMBER 4
#define MAJOR_VERSION_NUMBER 1
#define MINOR_VERSION_NUMBER 1
#elif (DEF_ELITE_MODEL == DEF_ELITE_EIS_MINI_10)
#define DEVICE_NAME "Elite-EIS"
#define MAJOR_PRODUCT_NUMBER 0
#define MINOR_PRODUCT_NUMBER 4
#define MAJOR_VERSION_NUMBER 1
#define MINOR_VERSION_NUMBER 2
#elif (DEF_ELITE_MODEL == DEF_ELITE_TRIG_01)
#define DEVICE_NAME "Elite-TRIG"
#define MAJOR_PRODUCT_NUMBER 0
#define MINOR_PRODUCT_NUMBER 5
#define MAJOR_VERSION_NUMBER 1
#define MINOR_VERSION_NUMBER 0
#elif (DEF_ELITE_MODEL == DEF_ELITE_MEGAFLY_01)
#define DEVICE_NAME "Elite-MEGAFLY"
#define MAJOR_PRODUCT_NUMBER 0
#define MINOR_PRODUCT_NUMBER 6
#define MAJOR_VERSION_NUMBER 1
#define MINOR_VERSION_NUMBER 0
#endif
#ifdef __cplusplus
}
#endif
#endif // ELITE_BOARDS_SELECT_H
@@ -1,81 +0,0 @@
/*
* +------------------------------+
* | CC2650moda |
* +-------------+----------------+
* | MISO | DIO1 |
* | D0 | DIO3 |
* | D1 | DIO4 |
* | D2/JTAG_TDO | DIO5/JTAG_TDO |
* | D3/JTAG_TDI | DIO6/JTAG_TDI |
* | D4 | DIO7 |
* | D5 | DIO8 |
* | D6 | DIO9 |
* | D7 | DIO10 |
* | LOAD2 | DIO11 |
* | LOAD1 | DIO12 |
* | LOAD0 | DIO13 |
* | SHUT_DOWN | DIO14 |
* +-------------+----------------+
*
* +-----------------------------+
* | Elite Pin for EIS1.1 Board |
* +------------+----------------+
* | AD_GPIO2 | D0 |
* | AD_GPIO1 | D1 |
* | AD_CLK | D2 |
* | AD_MOSI | D3 |
* | AD_RST | D4 |
* | MEM_CS | D5 |
* | 5V_ENABLE | D6 |
* | AD_CS | D7 |
* | AD_GPIO0 | LOAD2 |
* | OFF | LOAD0 |<--OFF:shutdown_6994
* | AD_MISO | MISO |
* | SHUT_DOWN | SHUT_DOWN |<--SHUT_DOWN:switch on/off
* +------------+----------------+
* | LED_SCLK_A | E_PIN_AD_GPIO2 |<--jumper
* | LED_MOSI_A | E_PIN_AD_GPIO1 |<--jumper
* +------------+----------------+
*/
/* CC2650moda */
/* Elite Pin for EIS1.1 Board */
#define E_PIN_AD_GPIO2 DIO3
#define E_PIN_AD_GPIO1 DIO4
#define E_PIN_AD_CLK DIO5
#define E_PIN_AD_MOSI DIO6
#define E_PIN_AD_RST DIO7
#define E_PIN_MEM_CS DIO8
#define E_PIN_AD_CS DIO10
#define E_PIN_AD_GPIO0 DIO11
#define E_PIN_BAT DIO12
#define E_PIN_AD_MISO DIO1
#define E_PIN_SHUT_DOWN DIO14
#define E_PIN_5V_ENABLE PIN_UNASSIGNED
#define E_PIN_LED_SCLK_A DIO2
#define E_PIN_LED_MOSI_A DIO0
/* SPI Board */
#define Board_SPI0_MISO PIN_UNASSIGNED
#define Board_SPI0_MOSI E_PIN_LED_MOSI_A
#define Board_SPI0_CLK E_PIN_LED_SCLK_A
#define Board_SPI0_CS PIN_UNASSIGNED
#define Board_SPI1_MISO E_PIN_AD_MISO
#define Board_SPI1_MOSI E_PIN_AD_MOSI
#define Board_SPI1_CLK E_PIN_AD_CLK
#define Board_SPI1_CS PIN_UNASSIGNED
/* I2C */
#define Board_I2C0_SCL0 PIN_UNASSIGNED
#define Board_I2C0_SDA0 PIN_UNASSIGNED
// delete in the future
#define Turnon_I_LARGE PIN_UNASSIGNED
#define Turnon_I_MID PIN_UNASSIGNED
#define Turnon_I_SMALL PIN_UNASSIGNED
#define Turnon_V_MID PIN_UNASSIGNED
#define Turnon_V_SMALL PIN_UNASSIGNED
#define Turon_VOUT_SMALL PIN_UNASSIGNED
@@ -1,98 +0,0 @@
#ifndef PIN_DEF_EIS11_H
#define PIN_DEF_EIS11_H
#ifdef __cplusplus
extern "C" {
#endif
/*
* +------------------------------+
* | CC2650moda |
* +-------------+----------------+
* | MISO | DIO1 |
* | D0 | DIO3 |
* | D1 | DIO4 |
* | D2/JTAG_TDO | DIO5/JTAG_TDO |
* | D3/JTAG_TDI | DIO6/JTAG_TDI |
* | D4 | DIO7 |
* | D5 | DIO8 |
* | D6 | DIO9 |
* | D7 | DIO10 |
* | LOAD2 | DIO11 |
* | LOAD1 | DIO12 |
* | LOAD0 | DIO13 |
* | SHUT_DOWN | DIO14 |
* +-------------+----------------+
*
* +------------------------------------+
* | Elite Pin for ELITE_EIS_1_1 Board |
* +------------+-----------------------+
* | AD_GPIO2 | D0 |
* | AD_GPIO1 | D1 |
* | AD_CLK | D2 |
* | AD_MOSI | D3 |
* | AD_RST | D4 |
* | MEM_CS | D5 |
* | 5V_ENABLE | D6 |
* | AD_CS | D7 |
* | AD_GPIO0 | LOAD2 |
* | OFF | LOAD0 |<--OFF: shutdown_6994
* | AD_MISO | MISO |
* | SHUT_DOWN | SHUT_DOWN |<--SHUT_DOWN: switch on/off
* +------------+-----------------------+
* | LED_SCLK_A | AD_GPIO2 |<--jumper
* | LED_MOSI_A | AD_GPIO1 |<--jumper
* +------------+-----------------------+
*/
/* CC2650moda */
#define MISO DIO1
#define D0 DIO3
#define D1 DIO4
#define D2 DIO5
#define D3 DIO6
#define D4 DIO7
#define D5 DIO8
#define D6 DIO9
#define D7 DIO10
#define LOAD2 DIO11
#define LOAD1 DIO12
#define LOAD0 DIO13
#define SHUT_DOWN DIO14
/* Elite Pin for ELITE_EIS_1_1 Board */
#define E_PIN_AD_GPIO2 D0
#define E_PIN_AD_GPIO1 D1
#define E_PIN_AD_CLK D2
#define E_PIN_AD_MOSI D3
#define E_PIN_AD_RST D4 //eis1.1-> use D4; eis1.0-> use LOAD0
#define E_PIN_MEM_CS D5
#define E_PIN_5V_ENABLE D6
#define E_PIN_AD_CS D7
#define E_PIN_AD_GPIO0 LOAD2
#define E_PIN_OFF LOAD0
#define E_PIN_AD_MISO MISO
#define E_PIN_SHUT_DOWN SHUT_DOWN
#define E_PIN_LED_SCLK_A E_PIN_AD_GPIO2
#define E_PIN_LED_MOSI_A E_PIN_AD_GPIO1
/* SPI Board */
#define Board_SPI0_MISO PIN_UNASSIGNED
#define Board_SPI0_MOSI E_PIN_LED_MOSI_A
#define Board_SPI0_CLK E_PIN_LED_SCLK_A
#define Board_SPI0_CS PIN_UNASSIGNED
#define Board_SPI1_MISO E_PIN_AD_MISO
#define Board_SPI1_MOSI E_PIN_AD_MOSI
#define Board_SPI1_CLK E_PIN_AD_CLK
#define Board_SPI1_CS PIN_UNASSIGNED
/* I2C */
#define Board_I2C0_SCL0 PIN_UNASSIGNED
#define Board_I2C0_SDA0 PIN_UNASSIGNED
#ifdef __cplusplus
}
#endif
#endif // PIN_DEF_EIS11_H
@@ -1,14 +0,0 @@
#ifndef GPIO_EIS11_H
#define GPIO_EIS11_H
#ifdef __cplusplus
extern "C" {
#endif
uint8_t gpio_create(void);
int8_t pin_set(uint8_t pin, uint8_t set_value);
#ifdef __cplusplus
}
#endif
#endif // GPIO_EIS11_H
@@ -1,58 +0,0 @@
#include "board.h"
#include <ti/drivers/pin/PINCC26XX.h>
#include "driver/gpio_eis11.h"
static PIN_Handle PinHandle;
static PIN_State PinStatus;
const PIN_Config BLE_IO[] = {
E_PIN_5V_ENABLE | PIN_GPIO_OUTPUT_EN | PIN_GPIO_LOW | PIN_PUSHPULL | PIN_DRVSTR_MAX,
E_PIN_AD_RST | PIN_GPIO_OUTPUT_EN | PIN_GPIO_HIGH | PIN_PUSHPULL | PIN_DRVSTR_MAX,
E_PIN_AD_CS | PIN_GPIO_OUTPUT_EN | PIN_GPIO_HIGH | PIN_PUSHPULL | PIN_DRVSTR_MAX,
E_PIN_OFF | PIN_GPIO_OUTPUT_EN | PIN_GPIO_HIGH | PIN_PUSHPULL | PIN_DRVSTR_MAX, // E_PIN_OFF = 1: turn off 6994
E_PIN_SHUT_DOWN | PIN_INPUT_EN | PIN_PULLDOWN,
PIN_TERMINATE
};
static PIN_Handle __get_gpio_handle(void)
{
return PinHandle;
}
static void __set_gpio_handle(PIN_Handle handle)
{
PinHandle = handle;
return;
}
int8_t pin_set(uint8_t pin, uint8_t set_value)
{
/*
* if status = 0: success
* else: fail
*/
uint8_t p = pin;
uint8_t v = set_value;
PIN_Status status;
PIN_Handle handle = __get_gpio_handle();
status = PIN_setOutputValue(handle, p, v);
return status;
}
uint8_t gpio_create(void)
{
PIN_Handle h;
h = PIN_open(&PinStatus, BLE_IO);
__set_gpio_handle(h);
if (h == NULL)
return 1;
return 0;
}
@@ -1,14 +0,0 @@
#ifndef GPIO_EIS_MINI10_H
#define GPIO_EIS_MINI10_H
#ifdef __cplusplus
extern "C" {
#endif
uint8_t gpio_create(void);
int8_t pin_set(uint8_t pin, uint8_t set_value);
#ifdef __cplusplus
}
#endif
#endif // GPIO_EIS_MINI10_H
@@ -1,57 +0,0 @@
#include "board.h"
#include <ti/drivers/pin/PINCC26XX.h>
#include "driver/gpio_eis_mini10.h"
static PIN_Handle PinHandle;
static PIN_State PinStatus;
const PIN_Config BLE_IO[] = {
E_PIN_5V_ENABLE | PIN_GPIO_OUTPUT_EN | PIN_GPIO_LOW | PIN_PUSHPULL | PIN_DRVSTR_MAX,
E_PIN_AD_RST | PIN_GPIO_OUTPUT_EN | PIN_GPIO_HIGH | PIN_PUSHPULL | PIN_DRVSTR_MAX,
E_PIN_AD_CS | PIN_GPIO_OUTPUT_EN | PIN_GPIO_HIGH | PIN_PUSHPULL | PIN_DRVSTR_MAX,
E_PIN_SHUT_DOWN | PIN_INPUT_EN | PIN_PULLDOWN,
PIN_TERMINATE
};
static PIN_Handle __get_gpio_handle(void)
{
return PinHandle;
}
static void __set_gpio_handle(PIN_Handle handle)
{
PinHandle = handle;
return;
}
int8_t pin_set(uint8_t pin, uint8_t set_value)
{
/*
* if status = 0: success
* else: fail
*/
uint8_t p = pin;
uint8_t v = set_value;
PIN_Status status;
PIN_Handle handle = __get_gpio_handle();
status = PIN_setOutputValue(handle, p, v);
return status;
}
uint8_t gpio_create(void)
{
PIN_Handle h;
h = PIN_open(&PinStatus, BLE_IO);
__set_gpio_handle(h);
if (h == NULL)
return 1;
return 0;
}
@@ -1,27 +0,0 @@
#ifndef SPI_CTRL_H
#define SPI_CTRL_H
#ifdef __cplusplus
extern "C" {
#endif
#define POL0 0
#define POL1 1
#define PHA0 0
#define PHA1 1
#define SPI_CLK_1M 1000000
#define SPI_CLK_4M 4000000
uint8_t spi0_open(uint32_t bitRate, uint8_t polarity, uint8_t phase);
uint8_t spi0_close(void);
uint8_t spi0_write(uint8_t *rxBuf, uint8_t *txBuf, uint8_t len);
uint8_t spi1_open(uint32_t bitRate, uint8_t polarity, uint8_t phase);
uint8_t spi1_close(void);
uint8_t spi1_write(uint8_t *rxBuf, uint8_t *txBuf, uint8_t len);
#ifdef __cplusplus
}
#endif
#endif // SPI_CTRL_H
@@ -1,208 +0,0 @@
#include "board.h"
#include <ti/drivers/SPI.h>
#include "driver/spi_ctrl.h"
#define CC2650_SPI_BITRATE_MAX 4000000 //4M
static SPI_Handle SpiHandle0 = NULL;
static SPI_Params SpiParams0;
static SPI_Handle SpiHandle1 = NULL;
static SPI_Params SpiParams1;
static SPI_Handle __get_spi_handle(uint8_t spi_channel)
{
uint8_t c = spi_channel;
if (c >= BOOSTXL_CC2650MA_SPICOUNT)
return NULL;
if (c == Board_SPI0)
return SpiHandle0;
if (c == Board_SPI1)
return SpiHandle1;
return 0;
}
static void __set_spi_handle(uint8_t spi_channel, SPI_Handle handle)
{
uint8_t c = spi_channel;
if (c == Board_SPI0)
SpiHandle0 = handle;
else if (c == Board_SPI1)
SpiHandle1 = handle;
return;
}
static SPI_FrameFormat __get_spi_mode(uint8_t polarity, uint8_t phase)
{
uint8_t pol = polarity;
uint8_t pha = phase;
SPI_FrameFormat mode;
if (pol == 0 && pha == 0)
mode = SPI_POL0_PHA0;
else if (pol == 0 && pha == 1)
mode = SPI_POL0_PHA1;
else if (pol == 1 && pha == 0)
mode = SPI_POL1_PHA0;
else if (pol == 1 && pha == 1)
mode = SPI_POL1_PHA1;
return mode;
}
uint8_t spi0_open(uint32_t bitRate, uint8_t polarity, uint8_t phase)
{
uint32_t rate = bitRate;
uint8_t pol = polarity;
uint8_t pha = phase;
SPI_Handle h = __get_spi_handle(Board_SPI0);
SPI_Params *para = &SpiParams0;
if (rate > CC2650_SPI_BITRATE_MAX)
return 1;
if (pol > 1 || pha > 1)
return 2;
if (h != NULL)
return 3;
SPI_Params_init(para);
para->bitRate = rate;
para->mode = SPI_MASTER;
para->dataSize = 8;
para->frameFormat = __get_spi_mode(pol, pha);
h = SPI_open(Board_SPI0, para);
__set_spi_handle(Board_SPI0, h);
if (h == NULL)
return 4;
return 0;
}
uint8_t spi0_close(void)
{
SPI_Handle h = __get_spi_handle(Board_SPI0);
if (h == NULL)
return 1;
SPI_close(h);
__set_spi_handle(Board_SPI0, NULL);
return 0;
}
uint8_t spi0_write(uint8_t *rxBuf, uint8_t *txBuf, uint8_t len)
{
SPI_Handle h = __get_spi_handle(Board_SPI0);
SPI_Transaction spi0_tran;
uint8_t ret;
if (h == NULL)
return 1;
spi0_tran.count = len;
spi0_tran.txBuf = txBuf;
spi0_tran.arg = NULL;
spi0_tran.rxBuf = NULL;
ret = SPI_transfer(h, &spi0_tran);
if (ret == false)
return 2;
return 0;
}
uint8_t spi1_open(uint32_t bitRate, uint8_t polarity, uint8_t phase)
{
uint32_t rate = bitRate;
uint8_t pol = polarity;
uint8_t pha = phase;
SPI_Handle h = __get_spi_handle(Board_SPI1);
SPI_Params *para = &SpiParams1;
if (rate > CC2650_SPI_BITRATE_MAX)
return 1;
if (pol > 1 || pha > 1)
return 2;
if (h != NULL)
return 3;
SPI_Params_init(para);
para->bitRate = rate;
para->mode = SPI_MASTER;
para->dataSize = 8;
para->frameFormat = __get_spi_mode(pol, pha);
h = SPI_open(Board_SPI1, para);
__set_spi_handle(Board_SPI1, h);
if (h == NULL)
return 4;
return 0;
}
uint8_t spi1_close(void)
{
SPI_Handle h = __get_spi_handle(Board_SPI1);
if (h == NULL)
return 1;
SPI_close(h);
__set_spi_handle(Board_SPI1, NULL);
return 0;
}
uint8_t spi1_write(uint8_t *rxBuf, uint8_t *txBuf, uint8_t len)
{
SPI_Handle h = __get_spi_handle(Board_SPI1);
SPI_Transaction spi1_tran;
uint8_t ret;
if (h == NULL)
return 1;
spi1_tran.count = len;
spi1_tran.txBuf = txBuf;
spi1_tran.arg = NULL;
spi1_tran.rxBuf = rxBuf;
ret = SPI_transfer(h, &spi1_tran);
if (ret == false)
return 2;
return 0;
}
/* utils.c.h */
/*
#include <stdio.h>
#include <stdint.h>
static void ___print_hex(uint8_t* p, int len)
{
// ___print_hex((uint8_t *)p, sizeof(struct led_series_data_t));
int i;
for (i = 0; i < len; i++) {
printf("0x%x, ", *p++);
}
printf("\n\n");
return;
}
*/
@@ -1,40 +0,0 @@
#ifndef TIMERS_H
#define TIMERS_H
#ifdef __cplusplus
extern "C" {
#endif
//timer
enum gptimer0_ctrl_e {
GPT_CTRL_START = 0,
GPT_CTRL_STOP,
GPT_CTRL_CLOSE,
GPT_CTRL_MAX,
};
void elite_gptimer_open();
uint8_t gptimer0_ctrl(enum gptimer0_ctrl_e gpt_ctrl);
//clock
/***************************************************
* Q: Why define CPU_1us = 16?
* A:
* 3 cycles per loop: 16 loops @ 48 Mhz ~= 1 us
* 3 cycles * X loops / 48Mhz = 1us(ideal value)
* 3 cycles * X loops / 48us = 1us(ideal value)
* X = 48 / 3 => X = 16 loops
***************************************************/
#define CPU_1us 16
#define CPU_1ms 16000
void CPUdelay_us(uint32_t delay_t);
void CPUdelay_ms(uint32_t delay_t);
void GPT_timerIncrement();
#ifdef __cplusplus
}
#endif
#endif // TIMERS_H
@@ -1,90 +0,0 @@
#include "board.h"
#include <ti/drivers/timer/GPTimerCC26XX.h>
#include <xdc/runtime/Types.h>
#include <ti/sysbios/BIOS.h>
#include "driver/timers.h"
#include "simple_peripheral.h"
static GPTimerCC26XX_Handle gptimer_handle; // was defined static
#define CLOCK_FREQ 4769 // clock freq = 0.1 ms(4800), Measured(4769)
static void elite_gptimer_callback(GPTimerCC26XX_Handle handle, GPTimerCC26XX_IntMask interruptMask) {
elite_gptimer_task();
return;
}
void elite_gptimer_open()
{
GPTimerCC26XX_Params params;
GPTimerCC26XX_Params_init(&params);
params.width = GPT_CONFIG_16BIT;
params.mode = GPT_MODE_PERIODIC_UP;
params.debugStallMode = GPTimerCC26XX_DEBUG_STALL_OFF;
gptimer_handle = GPTimerCC26XX_open(Board_GPTIMER0A, &params);
if (gptimer_handle == NULL) {
Task_exit();
}
Types_FreqHz freq;
BIOS_getCpuFreq(&freq);
GPTimerCC26XX_Value loadVal = freq.lo / 1000 - 1; //47999 = 1ms
loadVal = CLOCK_FREQ; //0.1ms
GPTimerCC26XX_setLoadValue(gptimer_handle, loadVal);
GPTimerCC26XX_registerInterrupt(gptimer_handle, elite_gptimer_callback, GPT_INT_TIMEOUT);
GPTimerCC26XX_start(gptimer_handle);
return;
}
uint8_t gptimer0_ctrl(enum gptimer0_ctrl_e gpt_ctrl)
{
enum gptimer0_ctrl_e gc = gpt_ctrl;
if (gc > GPT_CTRL_MAX)
return 1;
switch (gc) {
case GPT_CTRL_START:
GPTimerCC26XX_start(gptimer_handle);
break;
case GPT_CTRL_STOP:
GPTimerCC26XX_stop(gptimer_handle);
break;
case GPT_CTRL_CLOSE:
GPTimerCC26XX_close(gptimer_handle);
break;
}
return 0;
}
/*******************************************************************************************/
//clock
void CPUdelay_us(uint32_t delay_t)
{
uint32_t t = delay_t;
CPUdelay(t * CPU_1us);
return;
}
void CPUdelay_ms(uint32_t delay_t)
{
uint32_t t = delay_t;
CPUdelay(t * CPU_1ms);
return;
}
void GPT_timerIncrement() {
GPT.cnt_gpt_delta = GPT.cnt_gpt - GPT.cnt_gpt0;
GPT.cnt_gpt0 = GPT.cnt_gpt;
}
@@ -1,26 +0,0 @@
#ifndef ELITE_GPTIMER_H
#define ELITE_GPTIMER_H
#ifdef __cplusplus
extern "C" {
#endif
struct gptimer0_t{
uint32_t cnt_gpt;
uint32_t cnt_gpt0;
uint8_t cnt_gpt_delta;
uint32_t cnt_adc_rate;
uint32_t cnt_notify_rate;
uint32_t cnt_v_scan_rate;
uint32_t cnt_lead_time;
uint32_t BatteryADCCounter;
uint32_t BatteryCheckCounter;
uint32_t GptimerMultiple;
};
void InitGPT();
#ifdef __cplusplus
}
#endif
#endif // ELITE_GPTIMER_H
@@ -1,16 +0,0 @@
#include "elite_task/elite_GPtimer.h"
void InitGPT()
{
GPT.cnt_gpt = 0;
GPT.cnt_gpt0 = 0;
GPT.cnt_gpt_delta = 0;
GPT.cnt_adc_rate = 0;
GPT.cnt_notify_rate = 0;
GPT.cnt_v_scan_rate = 0;
GPT.cnt_lead_time = 0;
GPT.BatteryADCCounter = 0;
GPT.BatteryCheckCounter = 0;
return;
}
@@ -1,97 +0,0 @@
#ifndef LED_APA_102_H
#define LED_APA_102_H
#ifdef __cplusplus
extern "C" {
#endif
/*
* APA-102-2020-256-8A-20190612: Series data structure
* +-------------------+------------------------- ... -+-----------------+
* | start_frame(4B) | led_frame(4B) *LED_TANDEM_N | end_frame(4B) |
* +-------------------+------------------------- ... -+-----------------+
* / \
* / led_frame(4B) \
* / \
* 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
* | 111 | bright | blue | green | red |
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
*/
#include "driver/spi_ctrl.h"
#if (DEF_ELITE_MODEL == DEF_ELITE_EIS_11)
#define DEF_LED_TANDEN_N 12
#elif (DEF_ELITE_MODEL == DEF_ELITE_EIS_MINI_10)
#define DEF_LED_TANDEN_N 1
#endif
#ifdef DEF_LED_TANDEN_N
#define LED_TANDEM_N DEF_LED_TANDEN_N
#else
#define LED_TANDEM_N 12
#endif
enum led_series_nb_e {
LED_NB_1 = 0,
LED_NB_2,
LED_NB_3,
LED_NB_4,
LED_NB_5,
LED_NB_6,
LED_NB_7,
LED_NB_8,
LED_NB_9,
LED_NB_10,
LED_NB_11,
LED_NB_12,
LED_NB_MAX = LED_TANDEM_N,
};
enum led_bright_e {
LED_BR_LV0 = 0x00,
LED_BR_LV1 = 0x01,
LED_BR_LV8 = 0x08,
LED_BR_MAX = 0x1F,
};
enum led_color_e {
LED_CLR_BLACK = 0,
LED_CLR_WHITE,
LED_CLR_RED,
LED_CLR_ORANGE,
LED_CLR_YELLOW,
LED_CLR_GREEN,
LED_CLR_CYAN,
LED_CLR_BLUE,
LED_CLR_PURPLE,
LED_CLR_MAGENTA,
LED_CLR_YELLOWGREEN,
LED_CLR_EMERALD,
LED_CLR_MAX,
};
struct led_color_t {
uint8_t b;
uint8_t g;
uint8_t r;
};
struct led_frame_t {
uint8_t bright: 5,
rsvd: 3;
struct led_color_t color;
};
int led_color_set(enum led_series_nb_e led_nb, enum led_bright_e bright, enum led_color_e color);
int led_color_code_set(enum led_series_nb_e led_nb, enum led_bright_e bright, struct led_color_t *color);
int led_rainbow(enum led_bright_e bright);
#ifdef __cplusplus
}
#endif
#endif // LED_APA_102_H
@@ -1,189 +0,0 @@
#include "hardware/led_APA_102.h"
#define LED_FRME_FILL_RSVD(_f) (_f)->rsvd = 0x07 // 0x11100000 || bright
#define LED_SERIES_D_START 0x00000000
#define LED_SERIES_D_END 0xFFFFFFFF
struct led_series_data_t {
uint32_t f_start;
struct led_frame_t f_led[LED_TANDEM_N];
uint32_t f_end;
};
static struct led_series_data_t led_series_data_g = {0};
const struct led_color_t led_color_list_g[LED_CLR_MAX] = {
// {blue, green, red}
{0x00, 0x00, 0x00}, // LED_CLR_BLACK
{0xFF, 0xFF, 0xCA}, // LED_CLR_WHITE
{0x00, 0x00, 0xFF}, // LED_CLR_RED
{0x09, 0x58, 0xFF}, // LED_CLR_ORANGE
{0x00, 0xE1, 0xE1}, // LED_CLR_YELLOW
{0x00, 0xFA, 0x00}, // LED_CLR_GREEN
{0x40, 0x40, 0x00}, // LED_CLR_CYAN
{0xAA, 0x00, 0x00}, // LED_CLR_BLUE
{0x6F, 0x00, 0x3A}, // LED_CLR_PURPLE
{0xFF, 0x00, 0xFF}, // LED_CLR_MAGENTA
{0x00, 0xA6, 0x64}, // LED_CLR_YELLOWGREEN
{0x78, 0xC8, 0x50}, // LED_CLR_EMERALD
};
static int __led_single_set(struct led_series_data_t *led_s_d, struct led_frame_t *led_f, enum led_series_nb_e led_nb)
{
struct led_series_data_t *sd = led_s_d;
struct led_frame_t *f = led_f;
enum led_series_nb_e nb = led_nb;
memcpy(&sd->f_led[nb], f, sizeof(struct led_frame_t));
return 0;
}
static int __led_multiple_set(struct led_series_data_t *led_s_d, struct led_frame_t *led_f)
{
struct led_series_data_t *sd = led_s_d;
struct led_frame_t *f = led_f;
int i;
/*
* use __led_single_set() to finish all led;
*/
for (i = LED_NB_1; i < LED_NB_MAX; i++) {
__led_single_set(sd, f, (enum led_series_nb_e)i);
}
return 0;
}
static int __led_complete(struct led_series_data_t *led_s_d)
{
struct led_series_data_t *sd = led_s_d;
struct led_frame_t *f = sd->f_led;
int i;
for (i = LED_NB_1; i < LED_NB_MAX; i++) {
LED_FRME_FILL_RSVD(f);
f++;
}
sd->f_start = LED_SERIES_D_START;
sd->f_end = LED_SERIES_D_END;
return 0;
}
static int __led_color_set(enum led_series_nb_e led_nb, struct led_frame_t *led_f)
{
enum led_series_nb_e nb = led_nb;
struct led_frame_t *f = led_f;
struct led_series_data_t *sd = &led_series_data_g;
if (f == NULL)
return -1;
/*
* nb - < LED_NB_MAX: fill one led_frame
* == LED_NB_MAX: fill multiple led_frame
*
* complete: then, fill (start_frame, end_frame and the rsvd of every led_frame)
*
* finally, write cmd to hw by spi
*/
if (nb < LED_NB_MAX) {
__led_single_set(sd, f, nb);
} else if (nb == LED_NB_MAX) {
__led_multiple_set(sd, f);
} else {
return -2;
}
__led_complete(sd);
#define WRITE_TO_HW(_d, _l) spi0_write(NULL, (uint8_t *)(_d), (_l))
WRITE_TO_HW(sd, sizeof(struct led_series_data_t));
return 0;
}
int led_color_set(enum led_series_nb_e led_nb, enum led_bright_e bright, enum led_color_e color)
{
enum led_series_nb_e nb = led_nb;
enum led_bright_e b = bright;
enum led_color_e c = color;
struct led_frame_t led_f;
if (nb > LED_NB_MAX)
return -1;
if (c >= LED_CLR_MAX)
return -2;
if (b > LED_BR_MAX)
return -3;
led_f.bright = b;
led_f.color = led_color_list_g[c];
__led_color_set(nb, &led_f);
return 0;
}
int led_color_code_set(enum led_series_nb_e led_nb, enum led_bright_e bright, struct led_color_t *color)
{
enum led_series_nb_e nb = led_nb;
enum led_bright_e b = bright;
struct led_color_t *c = color;
struct led_frame_t led_f;
// valid the input values
if (nb > LED_NB_MAX)
return -1;
if (b > LED_BR_MAX)
return -2;
led_f.bright = b;
memcpy(&led_f.color, c, sizeof(struct led_color_t));
__led_color_set(nb, &led_f);
return 0;
}
int led_rainbow(enum led_bright_e bright)
{
enum led_bright_e b = bright;
int i;
if (b > LED_BR_MAX)
return -1;
for(i=0; i<LED_NB_MAX; i++) {
led_color_set((enum led_series_nb_e)i, b, (enum led_color_e)i);
}
return 0;
}
/*
* example -
* customize color:
* struct led_color_t led_c;
* uint8_t bri;
* // { ins, ins, num, r, g, b, bri};
* uint8_t ins[20] = {0x30, 0x00, LED_NB_4, 0xFF, 0x00, 0x44, 0x3};
* led_c.r = ins[3];
* led_c.g = ins[4];
* led_c.b = ins[5];
* bri = ins[6];
* led_color_code_set(LED_NB_4, bri, &led_c);
*
* single led:
* led_color_set(LED_NB_1, LED_BR_LV1, LED_CLR_WHITE);
*
* multiple led:
* led_color_set(LED_NB_MAX, LED_BR_LV1, LED_CLR_BLUE);
*
* rainbow led:
* led_rainbow(LED_BR_LV1);
*/
@@ -1,137 +0,0 @@
#ifndef AD5940
#define AD5940
#define NV2USC(_n) (n / 1e7 * 625 + 25000) // [5nV] / 1e6 * 5 * 12.5 + 25000
static void setEIS_EIS_cali(void)
{
AD5940_SPIWriteReg(LPDACCON0, 0x00000001); // Direct from LPDACDAT0 | Vzero(6bit) & Vbias(12bit) | LP 2.5v as ref
AD5940_SPIWriteReg(LPDACSW0, 0b111111); // orverride LPDACCON0[5] | LPDACSW0[0~5] close
AD5940_SPIWriteReg(HSRTIACON, 0x00000000); // CTIA=1pF | SW6 off(open) | RTIA=200R
AD5940_SPIWriteReg(HSTIACON, 0x00000001); // Vzero
AD5940_SPIWriteReg(ADCCON, 0x00000101); // PGA=1 | HSTIA neg input | HSTIA pos signal
AD5940_SPIWriteReg(DFTCON, 0x00000091); // DFTNUM=2048 | enable hanning window | SINC2
AD5940_SPIWriteReg(SWCON, 0x00026355); // D5 | P5 | N3 | T6 | T9 close
if (instru.gain_lv_hstia < HSRTIA_MAX) {
instru.HSTIAAutoGainEnable = 0;
HSTIAGainCtrl(instru.gain_lv_hstia);
} else {
instru.HSTIAAutoGainEnable = 1;
instru.gain_lv_hstia = HSRTIA_200R;
HSTIAGainCtrl(instru.gain_lv_hstia);
}
int32_t LPVolt = 0;
LPVolt = (instru.dcbias - 25000) * 4 * 4000;
DAC_outputV(LPVolt);
cali_SetWGAmp(instru.acamp);
AD5940_SPIWriteReg(AFECON, 0x0031CFC0); // en dc DAC buf | HSDAC ref disable | LDO buf current limit enable | en SINC2 |
// DFT hardware accelerator enable | waveform generator enable | HSTIA enable |
// intru amplifier enable | excitation buf enable | ADC conversions enable |
// ADC power enable | HSDAC enable | HP ref enable
//HIGH POWER MODE
AD5940_SPIWriteReg(PMBW, 0x0000000D); // HS mode | Set cutooff frequency to 250kHz, -3 dB bandwidth
AD5940_SPIWriteReg(CLKSEL, 0x0000);
AD5940_SPIWriteReg(CLKCON0KEY, 0xA815); // !!!Write 0xA815 to this register before accessing the CLKCON0 register
AD5940_SPIWriteReg(CLKCON0, 0x0442); //6bit system clock divider //set divider = 2
AD5940_SPIWriteReg(HSOSCCON, 0x00000000); // HP osc select 32MHz output
AD5940_SPIWriteReg(ADCFILTERCON, 0x00000311); // en DFT clk | en DAC wave clk | en SINC2 filter clk | 2 ADC samples used for average function |
// SINC3 filter oversampling rate is 800kSPS |
// SINC2 filter oversampling rate is 178 samples |
// disable average | SINC3 filter enable |
// Bypass 50/60Hz | ADC data rate 800kHz
AD5940_SPIWriteReg(HSDACCON, 0x0000000E); // HSDAC gain = 2, DAC update rate = ACLK/HSDACCON = 32Mhz/7
AD5940_SPIWriteReg(ADCBUFCON, 0x005F3D0F); //recommended
SetEISHIGHZ(0);
}
static void setEIS_CV (void)
{
//Clock and Ref
AD5940_SPIWriteReg(CLKSEL, 0x0);
AD5940_SPIWriteReg(HSOSCCON, 0x00000004); //16 MHz output
AD5940_SPIWriteReg(0x2180, 0x00000037); //0b110110
//Configure LPDAC LPTIA
AD5940_SPIWriteReg(LPREFBUFCON, 0x0); //enable lpref and lp 2.5V buffer
AD5940_SPIWriteReg(LPDACSW0, 0x00000034); // disconnect Vbias and Vzero
AD5940_SPIWriteReg(LPTIASW0, 0x00000034); // SW2 | SW4 | SW5
LPTIAGainCtrl(instru.gain_lv_lptia);
AD5940_SPIWriteReg(LPDACCON0, 0x00000001);
//Configure ADC | ADCDAT (0x2074)
AD5940_SPIWriteReg(ADCCON, 0x00010221); //PGA = 1.5 | LPTIA- | LPTIA_OUT
AD5940_SPIWriteReg(ADCFILTERCON, 0x00002011); // Sinc3 En | SINC3OSR2 | SINC2OSR22
AD5940_SPIWriteReg(DFTCON, 0x00000001); // Sinc2 to DFT | DFTNUM4
// mean function for calibration
AD5940_SPIWriteReg(RRR_AFE_STATSCON, 0x00000001); // don't use mean function // dev | 128 samples | enable statistics
//AFE and PWMB
AD5940_SPIWriteReg(AFECON, 0x00098780); //ADC on //0b10011000011110000000
AD5940_SPIWriteReg(PMBW, 0x00000005); //fc 50kHz, low power mode
}
static void set_hs_only(void)
{
AD5940_SPIWriteReg(LPDACCON0, 0x00000001); // Direct from LPDACDAT0 | Vzero(6bit) & Vbias(12bit) | LP 2.5v as ref
AD5940_SPIWriteReg(LPDACSW0, 0b111111); // orverride LPDACCON0[5] | LPDACSW0[0~5] close
AD5940_SPIWriteReg(HSRTIACON, 0x00000000); // CTIA=1pF | SW6 off(open) | RTIA=200R
AD5940_SPIWriteReg(HSTIACON, 0x00000001); // Vzero
AD5940_SPIWriteReg(ADCCON, 0x00000101); // PGA=1 | HSTIA neg input | HSTIA pos signal
AD5940_SPIWriteReg(DFTCON, 0x00000091); // DFTNUM=2048 | enable hanning window | SINC2
AD5940_SPIWriteReg(SWCON, 0x00026355); // D5 | P5 | N3 | T6 | T9 close
AD5940_SPIWriteReg(AFECON, 0x0031CFC0); // en dc DAC buf | HSDAC ref disable | LDO buf current limit enable | en SINC2 |
// DFT hardware accelerator enable | waveform generator enable | HSTIA enable |
// intru amplifier enable | excitation buf enable | ADC conversions enable |
// ADC power enable | HSDAC enable | HP ref enable
//HIGH POWER MODE
AD5940_SPIWriteReg(PMBW, 0x0000000D); // HS mode | Set cutooff frequency to 250kHz, -3 dB bandwidth
AD5940_SPIWriteReg(CLKSEL, 0x0000);
AD5940_SPIWriteReg(CLKCON0KEY, 0xA815); // !!!Write 0xA815 to this register before accessing the CLKCON0 register
AD5940_SPIWriteReg(CLKCON0, 0x0442); //6bit system clock divider //set divider = 2
AD5940_SPIWriteReg(HSOSCCON, 0x00000000); // HP osc select 32MHz output
AD5940_SPIWriteReg(ADCFILTERCON, 0x00000311); // en DFT clk | en DAC wave clk | en SINC2 filter clk | 2 ADC samples used for average function |
// SINC3 filter oversampling rate is 800kSPS |
// SINC2 filter oversampling rate is 178 samples |
// disable average | SINC3 filter enable |
// Bypass 50/60Hz | ADC data rate 800kHz
AD5940_SPIWriteReg(HSDACCON, 0x0000000E); // HSDAC gain = 2, DAC update rate = ACLK/HSDACCON = 32Mhz/7
AD5940_SPIWriteReg(ADCBUFCON, 0x005F3D0F); //recommended
SetEISHIGHZ(0);
return;
}
// static void AD5940_Initialize() {
// AD5940_SPIWriteReg(0x0908, 0x02C9);//initiation
// AD5940_SPIWriteReg(0x0C08, 0x206C);
// AD5940_SPIWriteReg(0x21F0, 0x0010);
// AD5940_SPIWriteReg(0x0410, 0x02C9);
// AD5940_SPIWriteReg(0x0A28, 0x0009);
// AD5940_SPIWriteReg(ADCBUFCON, 0x0104);
// AD5940_SPIWriteReg(0x0A04, 0x4859);
// AD5940_SPIWriteReg(0x0A04, 0xF27B);
// AD5940_SPIWriteReg(0x0A00, 0x8009);
// AD5940_SPIWriteReg(PMBW, 0x0000);
// }
// static void AD5940_sftreset(){
// AD5940_SPIWriteReg(0x0424, 0xA158);
// CPUdelay_us(200);
// }
#endif
@@ -1,903 +0,0 @@
#include <math.h>
#ifndef EliteADC
#define EliteADC
#include "board.h"
#include "EliteSPI.h"
#include "EliteNotify.h"
#include "eis_cali_table.h"
// Elite ADC macro
// ADC command, Elite will use these cmd to control ADC
#define CMD_CURRENT_MEASURE 0xC5 //0b11000101
#define CMD_VOLT_MEASURE 0xD5 //0b11010101
#define CMD_DAC_MEASURE 0xE5 //0b11100101
#define CMD_BATTERY_MEASURE 0xF1 //0b11110001
// controller command, these are command from control box
#define ADC_CH_CURRENT 0x00
#define ADC_CH_VOLT 0x01
#define ADC_CH_DAC 0x02
#define ADC_CH_BAT 0x03
/* Gain Control for Vin & Iin */
static void IinADCGainControl(uint8_t IinADCLevel){
// if(IinADCLevel == 0){
// // ADC gain level = 0, using 3M resister
// PIN_setOutputValue(pin_handle, Turnon_I_LARGE, 0);
// PIN_setOutputValue(pin_handle, Turnon_I_MID, 0);
// PIN_setOutputValue(pin_handle, Turnon_I_SMALL, 0);
// }
// else if(IinADCLevel == 1){
// // ADC gain level = 1, using 100K resister
// PIN_setOutputValue(pin_handle, Turnon_I_LARGE, 0);
// PIN_setOutputValue(pin_handle, Turnon_I_MID, 0);
// PIN_setOutputValue(pin_handle, Turnon_I_SMALL, 1);
// }
// else if(IinADCLevel == 2){
// // ADC gain level = 2, using 3K resister
// PIN_setOutputValue(pin_handle, Turnon_I_LARGE, 0);
// PIN_setOutputValue(pin_handle, Turnon_I_MID, 1);
// PIN_setOutputValue(pin_handle, Turnon_I_SMALL, 0);
// }
// else if(IinADCLevel == 3){
// // ADC gain level = 3, using 100R resistor
// PIN_setOutputValue(pin_handle, Turnon_I_LARGE, 1);
// PIN_setOutputValue(pin_handle, Turnon_I_MID, 0);
// PIN_setOutputValue(pin_handle, Turnon_I_SMALL, 0);
// }
// else if(IinADCLevel == 4){
// // ADC gain level = 3, auto gain (using 100R resister)
// PIN_setOutputValue(pin_handle, Turnon_I_LARGE, 1);
// PIN_setOutputValue(pin_handle, Turnon_I_MID, 0);
// PIN_setOutputValue(pin_handle, Turnon_I_SMALL, 0);
// }
// else{
// // default using 100R resister
// PIN_setOutputValue(pin_handle, Turnon_I_LARGE, 1);
// PIN_setOutputValue(pin_handle, Turnon_I_MID, 0);
// PIN_setOutputValue(pin_handle, Turnon_I_SMALL, 0);
// }
// if(IinADCLevel == 0 || IinADCLevel == 1 || IinADCLevel == 2 || IinADCLevel == 3){
// lastIinADCGainLevel = IinADCLevel;
// }else{
// lastIinADCGainLevel = 3;
// }
// record_flag = false;
}
static void VinADCGainCtrl(uint8_t VinADCLevel){
// if(VinADCLevel == 0){
// // Vin ADC gain level = 0, using 1M resister
// PIN_setOutputValue(pin_handle, Turnon_V_SMALL, 0);
// PIN_setOutputValue(pin_handle, Turnon_V_MID, 0);
// }
// else if(VinADCLevel == 1){
// // Vin ADC gain level = 1, using 30K resister
// PIN_setOutputValue(pin_handle, Turnon_V_SMALL, 0);
// PIN_setOutputValue(pin_handle, Turnon_V_MID, 1);
// }
// else if(VinADCLevel == 2){
// // Vin ADC gain level = 2, using 1K resister
// PIN_setOutputValue(pin_handle, Turnon_V_SMALL, 1);
// PIN_setOutputValue(pin_handle, Turnon_V_MID, 0);
// }
// else if(VinADCLevel == 3){
// // Vin ADC gain level = 3, auto gain (using 1K resister)
// PIN_setOutputValue(pin_handle, Turnon_V_SMALL, 1);
// PIN_setOutputValue(pin_handle, Turnon_V_MID, 0);
// }
// else{
// // default using 1K resister
// PIN_setOutputValue(pin_handle, Turnon_V_SMALL, 1);
// PIN_setOutputValue(pin_handle, Turnon_V_MID, 0);
// }
// if(VinADCLevel == 0 || VinADCLevel == 1 || VinADCLevel == 2){
// lastVinADCGainLv = VinADCLevel;
// }else{
// lastVinADCGainLv = 2;
// }
// record_flag = false;
}
#define RTIACON_200R 0b0000
#define RTIACON_1K 0b0001
#define RTIACON_5K 0b0010
#define RTIACON_10K 0b0011
#define RTIACON_20K 0b0100
#define RTIACON_40K 0b0101
#define RTIACON_80K 0b0110
#define RTIACON_160K 0b0111
#define RTIACON_OPEN 0b1111
static void HSTIAGainCtrl(uint8_t HSTIALevel)
{
/* HSRTIACON[12:5] = CTIACON, disconnect;
HSRTIACON[4] = TIASW6CON, diode not in parallel with RTIA;
HSRTIACON[3:0] = RTIA */
uint32_t reg;
uint8_t data;
uint8_t g = HSTIALevel;
if (g >= HSRTIA_MAX)
return;
reg = 0x00000000;
switch(g) {
case HSRTIA_160K:
data = RTIACON_160K;
break;
case HSRTIA_80K:
data = RTIACON_80K;
break;
case HSRTIA_40K:
data = RTIACON_40K;
break;
case HSRTIA_20K:
data = RTIACON_20K;
break;
case HSRTIA_10K:
data = RTIACON_10K;
break;
case HSRTIA_5K:
data = RTIACON_5K;
break;
case HSRTIA_1K:
data = RTIACON_1K;
break;
case HSRTIA_200R:
data = RTIACON_200R;
break;
default:
break;
}
AD5940_SPIWriteReg(HSRTIACON, reg | (uint32_t)data);
last_gain_hstia = g;
record_flag = false;
gainChange_flag = true;
return;
}
static void LPTIAGainCtrl(uint8_t LPTIALevel){
/* LPTIACON0[15:13] = RLPF, disconnect low pass filter;
LPTIACON0[12:10] = RLOAD, set at 0R;
LPTIACON0[9:5] = RTIA;
LPTIACON0[4:3] = IBOOST, High current mode; */
uint32_t code = 0x00000018; // disconnect LPF | RL 0R | RTIA = LPTIALevel | high I mode
uint8_t data = 1; // RTIA = 200R
if (LPTIALevel == LPRTIA_64K) {
data = 17; //64k
}
else if (LPTIALevel == LPRTIA_8K) {
data = 7; //8K
}
else if (LPTIALevel == LPRTIA_1K) {
data = 2; //1K
}
else if (LPTIALevel == LPRTIA_200R) {
data = 1; //200R
}
else if (LPTIALevel == LPRTIA_GAIN_AUTO) {
data = 1;
}
code = (code & ~(0b11111 << 5)) | (data << 5);
AD5940_SPIWriteReg(LPTIACON0, code); //LPTIACON0
if(LPTIALevel == 0 || LPTIALevel == 1 || LPTIALevel == 2 || LPTIALevel == 3){
last_gain_lptia = LPTIALevel;
}else{
last_gain_lptia = 3;
}
record_flag = false;
}
static void disconnect_rtia(){
/* LPTIACON0[15:13] = RLPF, disconnect low pass filter;
LPTIACON0[12:10] = RLOAD, set at 0R;
LPTIACON0[9:5] = RTIA;
LPTIACON0[4:3] = IBOOST, High current mode; */
uint32_t code = 0x00000018; // disconnect LPF | RL 0R | RTIA = LPTIALevel | high I mode
uint8_t data = 0; // RTIA = disconnect
code = (code & ~(0b11111 << 5)) | (data << 5);
AD5940_SPIWriteReg(LPTIACON0, code); //LPTIACON0
return;
}
// static void ADCChannelSelect(uint8_t ADCChannel){
// // set ADC parameter
// // 0xC1~F1 = reading AIN0~AIN3. Using FSR+-6V, resolution = 187.5uV
// // 0xC5~F5 = reading AIN0~AIN3. Using FSR+-2V, resolution = 62.5 uV
// switch(ADCChannel){
// // AINp is AIN0; AINn is GND
// // measure AIN0, which is a current measure
// case ADC_CH_CURRENT :{
// ADC_write(CMD_CURRENT_MEASURE);
// break;
// }
// // AINp is AIN1; AINn is GND
// // AIN1, which is a volt measure
// case ADC_CH_VOLT :{
// ADC_write(CMD_VOLT_MEASURE);
// break;
// }
// // AINp is AIN2; AINn is GND
// // AIN2, measure DAC voltage (Note that this is NOT DAC real output value!!)
// case ADC_CH_DAC :{
// ADC_write(CMD_DAC_MEASURE);
// break;
// }
// // measure battery volt
// case ADC_CH_BAT :{
// ADC_write(CMD_BATTERY_MEASURE);
// break;
// }
// default :{
// break;
// }
// }
// }
// static void ReadADCIin(uint8_t *buf){
// // Read data twice since the first data we get is previous data
// ADCChannelSelect(ADC_CH_CURRENT);
// ADC_read(buf);
// ADCChannelSelect(ADC_CH_CURRENT);
// ADC_read(buf);
// }
// static void ReadADCVin(uint8_t *buf){
// // Read data twice since the first data we get is previous data
// // VinADCGainControl(INSTRUCTION.VinADCGainLevel);
// ADCChannelSelect(ADC_CH_VOLT);
// ADC_read(buf);
// ADCChannelSelect(ADC_CH_VOLT);
// ADC_read(buf);
// }
// static void ReadADCVout(uint8_t *buf){
// // Read data twice since the first data we get is previous data
// ADCChannelSelect(ADC_CH_DAC);
// ADC_read(buf);
// ADCChannelSelect(ADC_CH_DAC);
// ADC_read(buf);
// }
// static void ReadADCBat(uint8_t *buf){
// // Read data twice since the first data we get is previous data
// ADCChannelSelect(ADC_CH_BAT);
// ADC_read(buf);
// ADCChannelSelect(ADC_CH_BAT);
// ADC_read(buf);
// }
static int32_t ReadRawADC() {
// select_REG_RRR(ADCDAT);
return AD5940_SPIReadReg(ADCDAT);
}
static int32_t ReadRealZ() {
// select_REG_RRR(DFTREAL);
return AD5940_SPIReadReg(DFTREAL);
}
static int32_t ReadImagZ() {
// select_REG_RRR(DFTIMAG);
return AD5940_SPIReadReg(DFTIMAG);
}
static uint32_t ReadSINC2() {
// select_REG_RRR(0x2080);
return AD5940_SPIReadReg(0x2080);
}
/* for Elite1.5-re */
// Iin theoretical boundary <2.67, 1.89~80, 63~2600, >1900 (uA)
#define I_GAIN_SMALL_BOUNDARY 4000 // 4 uA = 4,000,000 pA
#define I_GAIN_MID1_BOUNDARY1 2500 // 2.5 uA = 2,500,000 pA
#define I_GAIN_MID1_BOUNDARY2 100000 // 100 uA = 100,000,000 pA
#define I_GAIN_MID2_BOUNDARY1 85000 // 85 uA = 85,000,000 pA
#define I_GAIN_MID2_BOUNDARY2 2050000 // 2050 uA = 2,050,000 nA
#define I_GAIN_LARGE_BOUNDARY 1800000 // 1800 uA = 1,800,000 nA
// Vin theoretical boundary <7, 5~200, >100 (mV)
#define VIN_GAIN_SMALL_BOUNDARY 7000 // 7 mV = 7,000,000 nV
#define VIN_GAIN_MID1_BOUNDARY1 5000 // 5 mV = 5,000,000 nV
#define VIN_GAIN_MID1_BOUNDARY2 300000 // 300 mV = 300,000,000 nV
#define VIN_GAIN_LARGE_BOUNDARY 250000 // 250 mV = 250,000,000 nV
#define LPTIA_GAIN_SMALL_BOUNDARY 6000 // 6 uA = 1,500,000 pA
#define LPTIA_GAIN_MID1_BOUNDARY1 5000 // 5 uA = 1,000,000 pA
#define LPTIA_GAIN_MID1_BOUNDARY2 60000 // 60 uA = 60,000,000 pA
#define LPTIA_GAIN_MID2_BOUNDARY1 50000 // 50 uA = 40,000,000 pA
#define LPTIA_GAIN_MID2_BOUNDARY2 600000 // 600 uA = 175,000 nA
#define LPTIA_GAIN_LARGE_BOUNDARY 500000 // 500 uA = 120,000 nA
#define HSTIA_G0_MAX_BOUNDARY (3740*9/10)// = 3366 nA
#define HSTIA_G1_MIN_BOUNDARY (3740*8/10)// = 2992 nA
#define HSTIA_G1_MAX_BOUNDARY (9580*9/10)// = 8622 nA
#define HSTIA_G2_MIN_BOUNDARY (9580*8/10)// = 7664 nA
#define HSTIA_G2_MAX_BOUNDARY (19694*9/10)// = 17724 nA
#define HSTIA_G3_MIN_BOUNDARY (19694*8/10)// = 15755 nA
#define HSTIA_G3_MAX_BOUNDARY (38856*9/10)// = 34970 nA
#define HSTIA_G4_MIN_BOUNDARY (38856*8/10)// = 31084 nA
#define HSTIA_G4_MAX_BOUNDARY (76553*9/10)// = 68897 nA
#define HSTIA_G5_MIN_BOUNDARY (76553*8/10)// = 61242 nA
#define HSTIA_G5_MAX_BOUNDARY (155069*9/10)// = 139562 nA
#define HSTIA_G6_MIN_BOUNDARY (155069*8/10)// = 124055 nA
#define HSTIA_G6_MAX_BOUNDARY (396902*9/10)// = 357211 nA
#define HSTIA_G7_MIN_BOUNDARY (396902*8/10)// = 317521 nA
static int32_t Cali_LPTIA (uint32_t value, uint8_t gain_level)
{
/* res = a*x^2 + b*x + c */
int64_t res;
res = (CaliTable.lptia_current[gain_level].lptia_a * value * value +
CaliTable.lptia_current[gain_level].lptia_b * value +
CaliTable.lptia_current[gain_level].lptia_c * 1e4) / 1e8;
return (int32_t)res;
}
//EIS Function//
static int32_t read_LPTIA_Iin(){
static int32_t ADCraw, Iin;
// select_REG_RRR(ADCDAT);
ADCraw = AD5940_SPIReadReg(ADCDAT);
Iin = Cali_LPTIA(ADCraw, instru.gain_lv_lptia);
InputNotify(NOTIFY_CURRENT, Iin);
// InputNotify(NOTIFY_IMPEDANCE, instru.gain_lv_lptia);
return Iin;
}
static int32_t read_LPTIA_Vin(){
static int32_t ADCraw, Vin;
int64_t res, cali_a, cali_b;
ADCraw = AD5940_SPIReadReg(ADCDAT);
/* res = a*x + b */
if (instru.measure_vin_range == 0) { //measure +volt (zero = 0,bias = 0)
cali_a = 3724236303;
cali_b = -31038393762537;
} else if (instru.measure_vin_range == 1) { //measure +-1V (zero = 32,bias = 2048)
cali_a = 3722206919;
cali_b = -140964299129767;
} else if (instru.measure_vin_range == 2) { //measure -volt (zero = 62,bias = 3910)
cali_a = 3720451376;
cali_b = -240791817290944;
}
res = ((int64_t)cali_a * ADCraw + cali_b) / 1e8;
Vin = (int32_t)res;
InputNotify(NOTIFY_VOLT, Vin);
// InputNotify(NOTIFY_IMPEDANCE, ADCraw);
return (int32_t)Vin;
}
/* phase[4][4]; hstia_current[4][4] */
/* [Phase][HSTIA] */
static int32_t Cali_LPDAC (uint32_t value)
{
int64_t res;
if (value == 25000) { // if DC offset = 0V; force DC bias to OffsetZero
res = (22707 - 25000) * 4 * 4000;
} else {
res = (value * CaliTable.ac_dcbais.up_a + CaliTable.ac_dcbais.up_b) / 1e7;
}
return (int32_t)res;
}
static uint32_t Cali_HSAMP (uint16_t value, uint32_t freq)
{
int64_t res;
float temp;
long long m = CaliTable.ac_amp.amp_m;
long long w = CaliTable.ac_amp.amp_w;
float fr = freq / 100;
temp = 1 / (1 + fr / w * fr / w);
res = value * 1e7 / m / temp;
if (res > 2047)
res = 2047;
else if (res < 0)
res = 0;
return (uint32_t) res;
}
static int32_t Cali_HSTIA (uint64_t value, uint8_t gain_level)
{
/* res = a*x^2 + b*x + c */
int64_t res;
res = (CaliTable.hstia_current[gain_level][0].hstia_a * value * value +
CaliTable.hstia_current[gain_level][0].hstia_b * value ) / 1e8;//nA
return (int32_t)res;
}
static int32_t read_HSTIA_Iin(){
uint32_t originalDFT;
int64_t mag;
int32_t RealCurrent;
int64_t i;
int64_t r;
int64_t f;
int64_t rolloff_cali = CaliTable.hstia_current[instru.gain_lv_hstia][0].rolloff;
instru.real = neg_18bit(ReadRealZ());
instru.imag = neg_18bit(ReadImagZ());
i = (int64_t)instru.imag;
r = (int64_t)instru.real;
f = (int64_t)instru.fset;
originalDFT = sqrt(i * i + r * r);
mag = (int64_t)originalDFT * (1 + (f * f) / (rolloff_cali * rolloff_cali) / 1e4);
RealCurrent = Cali_HSTIA(mag, instru.gain_lv_hstia);
return RealCurrent;
}
static void AutoChangeLPTIAGain(int32_t RealCurrent){
if(instru.gain_lv_lptia == LPRTIA_200R){
if(RealCurrent < LPTIA_GAIN_LARGE_BOUNDARY && RealCurrent > -1*LPTIA_GAIN_LARGE_BOUNDARY){
// switch to 1 level current(small)
if (RealCurrent < LPTIA_GAIN_MID1_BOUNDARY1 && RealCurrent > -1*LPTIA_GAIN_MID1_BOUNDARY1){
I_GAIN_3M_counter++;
if(I_GAIN_3M_counter > 2){
instru.gain_lv_lptia = LPRTIA_64K;
LPTIAGainCtrl(instru.gain_lv_lptia);
I_GAIN_3M_counter = 0;
}
}
// switch to 2 level current
else if (RealCurrent < LPTIA_GAIN_MID2_BOUNDARY1 && RealCurrent > -1*LPTIA_GAIN_MID2_BOUNDARY1){
I_GAIN_100K_counter++;
if(I_GAIN_100K_counter > 2){
instru.gain_lv_lptia = LPRTIA_8K;
LPTIAGainCtrl(instru.gain_lv_lptia);
I_GAIN_100K_counter = 0;
}
}
// switch to 3 level current
else{
I_GAIN_3K_counter++;
if(I_GAIN_3K_counter > 2){
instru.gain_lv_lptia = LPRTIA_1K;
LPTIAGainCtrl(instru.gain_lv_lptia);
I_GAIN_3K_counter = 0;
}
}
}else{
if(I_GAIN_3K_counter > 0){
I_GAIN_3K_counter--;
}
if(I_GAIN_100K_counter > 0){
I_GAIN_100K_counter--;
}
if(I_GAIN_3M_counter > 0){
I_GAIN_3M_counter--;
}
}
}
else if(instru.gain_lv_lptia == LPRTIA_1K){
// switch to 4 level current(large)
if(RealCurrent > LPTIA_GAIN_MID2_BOUNDARY2 || RealCurrent < -1*LPTIA_GAIN_MID2_BOUNDARY2){
I_GAIN_100R_counter++;
if(I_GAIN_100R_counter > 2){
instru.gain_lv_lptia = LPRTIA_200R;
LPTIAGainCtrl(instru.gain_lv_lptia);
I_GAIN_100R_counter = 0;
}
}
else if (RealCurrent < LPTIA_GAIN_MID2_BOUNDARY1 && RealCurrent > -1*LPTIA_GAIN_MID2_BOUNDARY1){
// switch to 1 level current(small)
if(RealCurrent < LPTIA_GAIN_MID1_BOUNDARY1 && RealCurrent > -1*LPTIA_GAIN_MID1_BOUNDARY1){
I_GAIN_3M_counter++;
if(I_GAIN_3M_counter > 2){
instru.gain_lv_lptia = LPRTIA_64K;
LPTIAGainCtrl(instru.gain_lv_lptia);
I_GAIN_3M_counter = 0;
}
}
// switch to 2 level current
else{
I_GAIN_100K_counter++;
if(I_GAIN_100K_counter > 2){
instru.gain_lv_lptia = LPRTIA_8K;
LPTIAGainCtrl(instru.gain_lv_lptia);
I_GAIN_100K_counter = 0;
}
}
}else{
if(I_GAIN_100R_counter > 0){
I_GAIN_100R_counter--;
}
if(I_GAIN_100K_counter > 0){
I_GAIN_100K_counter--;
}
if(I_GAIN_3M_counter > 0){
I_GAIN_3M_counter--;
}
}
}
else if(instru.gain_lv_lptia == LPRTIA_8K){
// switch to 1 level current(small)
if(RealCurrent < LPTIA_GAIN_MID1_BOUNDARY1 && RealCurrent > -1*LPTIA_GAIN_MID1_BOUNDARY1){
I_GAIN_3M_counter++;
if(I_GAIN_3M_counter > 2){
instru.gain_lv_lptia = LPRTIA_64K;
LPTIAGainCtrl(instru.gain_lv_lptia);
I_GAIN_3M_counter = 0;
}
}
else if (RealCurrent > LPTIA_GAIN_MID1_BOUNDARY2 || RealCurrent < -1*LPTIA_GAIN_MID1_BOUNDARY2){
// switch to 4 level current(large)
if(RealCurrent > LPTIA_GAIN_MID2_BOUNDARY2 || RealCurrent < -1*LPTIA_GAIN_MID2_BOUNDARY2){
I_GAIN_100R_counter++;
if(I_GAIN_100R_counter > 2){
instru.gain_lv_lptia = LPRTIA_200R;
LPTIAGainCtrl(instru.gain_lv_lptia);
I_GAIN_100R_counter = 0;
}
}
// switch to 3 level current
else{
I_GAIN_3K_counter++;
if(I_GAIN_3K_counter > 2){
instru.gain_lv_lptia = LPRTIA_1K;
LPTIAGainCtrl(instru.gain_lv_lptia);
I_GAIN_3K_counter = 0;
}
}
}else{
if(I_GAIN_100R_counter > 0){
I_GAIN_100R_counter--;
}
if(I_GAIN_3K_counter > 0){
I_GAIN_3K_counter--;
}
if(I_GAIN_3M_counter > 0){
I_GAIN_3M_counter--;
}
}
}
else if(instru.gain_lv_lptia == LPRTIA_64K){
if(RealCurrent > LPTIA_GAIN_SMALL_BOUNDARY || RealCurrent < -1*LPTIA_GAIN_SMALL_BOUNDARY){
// switch to 4 level current(large)
if(RealCurrent > LPTIA_GAIN_MID2_BOUNDARY2 || RealCurrent < -1*LPTIA_GAIN_MID2_BOUNDARY2){
I_GAIN_100R_counter++;
if(I_GAIN_100R_counter > 2){
instru.gain_lv_lptia = LPRTIA_200R;
LPTIAGainCtrl(instru.gain_lv_lptia);
I_GAIN_100R_counter = 0;
}
}
// switch to 3 level current
else if(RealCurrent > LPTIA_GAIN_MID1_BOUNDARY2 || RealCurrent < -1*LPTIA_GAIN_MID1_BOUNDARY2){
I_GAIN_3K_counter++;
if(I_GAIN_3K_counter > 2){
instru.gain_lv_lptia = LPRTIA_1K;
LPTIAGainCtrl(instru.gain_lv_lptia);
I_GAIN_3K_counter = 0;
}
}
// switch to 2 level current
else{
I_GAIN_100K_counter++;
if(I_GAIN_100K_counter > 2){
instru.gain_lv_lptia = LPRTIA_8K;
LPTIAGainCtrl(instru.gain_lv_lptia);
I_GAIN_100K_counter = 0;
}
}
}else{
if(I_GAIN_100R_counter > 0){
I_GAIN_100R_counter--;
}
if(I_GAIN_3K_counter > 0){
I_GAIN_3K_counter--;
}
if(I_GAIN_100K_counter > 0){
I_GAIN_100K_counter--;
}
}
}
}
static void change_hstia_gain(uint8_t gain)
{
uint8_t g = gain;
static uint8_t gain_cnt = 0;
gain_cnt++;
if (gain_cnt > 2) {
instru.gain_lv_hstia = g;
HSTIAGainCtrl(g);
gain_cnt = 0;
}
return;
}
static void AutoChangeHSTIAGain(int32_t RealCurrent)
{
int64_t g0_max = HSTIA_G0_MAX_BOUNDARY;
int64_t g1_min = HSTIA_G1_MIN_BOUNDARY;
int64_t g1_max = HSTIA_G1_MAX_BOUNDARY;
int64_t g2_min = HSTIA_G2_MIN_BOUNDARY;
int64_t g2_max = HSTIA_G2_MAX_BOUNDARY;
int64_t g3_min = HSTIA_G3_MIN_BOUNDARY;
int64_t g3_max = HSTIA_G3_MAX_BOUNDARY;
int64_t g4_min = HSTIA_G4_MIN_BOUNDARY;
int64_t g4_max = HSTIA_G4_MAX_BOUNDARY;
int64_t g5_min = HSTIA_G5_MIN_BOUNDARY;
int64_t g5_max = HSTIA_G5_MAX_BOUNDARY;
int64_t g6_min = HSTIA_G6_MIN_BOUNDARY;
int64_t g6_max = HSTIA_G6_MAX_BOUNDARY;
int64_t g7_min = HSTIA_G7_MIN_BOUNDARY;
uint8_t gain = instru.gain_lv_hstia;
int32_t curr = RealCurrent;
if (gain == HSRTIA_200R) {
if (curr < g7_min && curr > -1 * g7_min)
change_hstia_gain(HSRTIA_1K);
return;
}
if (gain == HSRTIA_1K) {
if (curr > g6_max || curr < -1 * g6_max)
change_hstia_gain(HSRTIA_200R);
else if (curr < g6_min && curr > -1 * g6_min)
change_hstia_gain(HSRTIA_5K);
return;
}
if (gain == HSRTIA_5K) {
if (curr > g5_max || curr < -1 * g5_max)
change_hstia_gain(HSRTIA_1K);
else if (curr < g5_min && curr > -1 * g5_min)
change_hstia_gain(HSRTIA_10K);
return;
}
if (gain == HSRTIA_10K) {
if (curr > g4_max || curr < -1 * g4_max)
change_hstia_gain(HSRTIA_5K);
else if (curr < g4_min && curr > -1 * g4_min)
change_hstia_gain(HSRTIA_20K);
return;
}
if (gain == HSRTIA_20K) {
if (curr > g3_max || curr < -1 * g3_max)
change_hstia_gain(HSRTIA_10K);
else if (curr < g3_min && curr > -1 * g3_min)
change_hstia_gain(HSRTIA_40K);
return;
}
if (gain == HSRTIA_40K) {
if (curr > g2_max || curr < -1 * g2_max)
change_hstia_gain(HSRTIA_20K);
else if (curr < g2_min && curr > -1 * g2_min)
change_hstia_gain(HSRTIA_80K);
return;
}
if (gain == HSRTIA_80K) {
if (curr > g1_max || curr < -1 * g1_max)
change_hstia_gain(HSRTIA_40K);
else if (curr < g1_min && curr > -1 * g1_min)
change_hstia_gain(HSRTIA_160K);
return;
}
if (gain == HSRTIA_160K) {
if (curr > g0_max || curr < -1 * g1_max)
change_hstia_gain(HSRTIA_80K);
return;
}
return;
}
static void SetCTIA(uint8_t ret){
uint64_t code;
// select_REG_RRR(HSRTIACON);
code = AD5940_SPIReadReg(HSRTIACON);
code = (code & (~(0x7F << 5))) | (ret << 5);
AD5940_SPIWriteReg(HSRTIACON, code);
}
static void EnDFTnADC(uint8_t ret){
uint32_t code;
// select_REG_RRR(AFECON);
code = AD5940_SPIReadReg(AFECON);
code = (code & (~0x00008100)) | (ret << 15) | (ret << 8);
AD5940_SPIWriteReg(AFECON, code);
}
static void SetADCDataRate(uint8_t dataRate){ //1: 800k | 0: 1.6M
uint32_t code;
// select_REG_RRR(ADCFILTERCON); //0x2044
code = AD5940_SPIReadReg(ADCFILTERCON);
code = (code & (~1)) | (dataRate);
AD5940_SPIWriteReg(ADCFILTERCON, code);
}
static void SelDFTin(uint8_t ret){ // 1: SINC3 | 2: raw | 0 or 3: SINC2
uint32_t code;
// select_REG_RRR(DFTCON);
code = AD5940_SPIReadReg(DFTCON);
code = (code & (~(3 << 20))) | (ret << 20);
AD5940_SPIWriteReg(DFTCON, code);
}
static void BpNotch(uint8_t ret){ // 1: bypass notch
uint32_t code;
// select_REG_RRR(ADCFILTERCON);
code = AD5940_SPIReadReg(ADCFILTERCON);
code = (code & (~(1 << 4))) | (!ret << 4);
AD5940_SPIWriteReg(ADCFILTERCON, code);
}
static void BpSINC3(uint8_t ret){ // 1: bypass sinc3
uint32_t code;
// select_REG_RRR(ADCFILTERCON);
code = AD5940_SPIReadReg(ADCFILTERCON);
code = (code & (~(1 << 6))) | (ret << 6);
AD5940_SPIWriteReg(ADCFILTERCON, code);
}
static void EnNotch(uint8_t ret){
uint32_t code;
// select_REG_RRR(AFECON);
code = AD5940_SPIReadReg(AFECON);
code = (code & (~(1 << 16))) | (ret << 16);
AD5940_SPIWriteReg(AFECON, code);
}
static void SetSinc3OSR(uint8_t osr){ //0, 1, 2, 3
uint32_t code;
// select_REG_RRR(ADCFILTERCON); //0x2044
code = AD5940_SPIReadReg(ADCFILTERCON);
code = (code & (~(3 << 12))) | (osr << 12);
AD5940_SPIWriteReg(ADCFILTERCON, code);
}
static void SetSinc2OSR(uint8_t osr){ //0~11 2^i
uint32_t code;
// select_REG_RRR(ADCFILTERCON); //0x2044
code = AD5940_SPIReadReg(ADCFILTERCON);
code = (code & (~(15 << 8))) | (osr << 8);
AD5940_SPIWriteReg(ADCFILTERCON, code);
}
static void SetDFTNUM(uint8_t dft_num){
uint32_t code;
// select_REG_RRR(DFTCON); //20D0
code = AD5940_SPIReadReg(DFTCON);
code = (code & (~(15 << 4))) | (dft_num << 4);
AD5940_SPIWriteReg(DFTCON, code);
}
static void SetSamplingTime(uint32_t freq){ // freq [10mHz]
// freq > 10kHz
if (freq >= 1000000 && instru.settingIndex != 1) {
SelDFTin(1);
SetADCDataRate(ADC1M6sps);
BpSINC3(1);
SetDFTNUM(DFTNUM16384);
instru.settingIndex = 1;
}
// 10kHz > freq > 1kHz
else if (freq >= 100000 && freq < 1000000 && instru.settingIndex != 2) {
SelDFTin(1);
SetADCDataRate(ADC1M6sps);
BpSINC3(0);
SetSinc3OSR(Sinc3OSR4);
SetDFTNUM(DFTNUM8192);
instru.settingIndex = 2;
}
// 1kHz > freq > 100Hz
else if (freq >= 10000 && freq < 100000 && instru.settingIndex != 3) {
SelDFTin(1);
SetADCDataRate(ADC800Ksps);
BpSINC3(0);
SetSinc3OSR(Sinc3OSR5);
SetDFTNUM(DFTNUM16384);
instru.settingIndex = 3;
}
// 100Hz > freq > 10Hz
else if (freq >= 1000 && freq < 10000 && instru.settingIndex != 4) {
SelDFTin(0);
SetADCDataRate(ADC800Ksps);
BpSINC3(0);
SetSinc3OSR(Sinc3OSR5);
SetSinc2OSR(Sinc2OSR178);
SetDFTNUM(DFTNUM1024);
instru.settingIndex = 4;
}
// 10Hz > freq > 1Hz
else if (freq >= 100 && freq < 1000 && instru.settingIndex != 5) {
SelDFTin(0);
SetADCDataRate(ADC800Ksps);
BpSINC3(0);
SetSinc3OSR(Sinc3OSR5);
SetSinc2OSR(Sinc2OSR889);
SetDFTNUM(DFTNUM1024);
instru.settingIndex = 5;
}
// 1Hz > freq > 0.1Hz
else if (freq >= 10 && freq < 100 && instru.settingIndex != 6) {
SelDFTin(0);
SetADCDataRate(ADC800Ksps);
BpSINC3(0);
SetSinc3OSR(Sinc3OSR2);
SetSinc2OSR(Sinc2OSR1333);
SetDFTNUM(DFTNUM16384);
instru.settingIndex = 6;
}
// 0.015Hz | 136s
// 0.1Hz > freq > 0.01Hz
else if (freq >= 1 && freq < 10 && instru.settingIndex != 7) {
SelDFTin(0);
SetADCDataRate(ADC800Ksps);
BpSINC3(0);
SetSinc3OSR(Sinc3OSR5);
SetSinc2OSR(Sinc2OSR1333);
SetDFTNUM(DFTNUM16384);
instru.settingIndex = 7;
}
}
//EIS function//
#endif
@@ -1,259 +0,0 @@
#ifndef EliteDAC
#define EliteDAC
static bool DACReset;
#define VBIAS_LSB 107422 // 2200/4096 [mV] = 107422 [5nV]
#define VZERO_LSB 6875008 // VBIAS_LSB * 64
#define DAC12BIT_LSB 107422
#define VOLT_MV_TO_5NV(_v) (_v * 200000)
#define V_5nV(_v) VOLT_MV_TO_5NV(_v)
/* user code: 0 ~ 35000; LPDAC bias value: -1.5V ~ +1.5V */
static int32_t DAC_outputV(int32_t voltLVraw) { // LPDAC output, voltLV = Vbias-Vzero
/* new code*/
int32_t ret;
int32_t vscan;
int64_t v_z;
int64_t v_zero;
int64_t v_bias;
uint8_t n_zero;//6btit
uint16_t n_bias;//12bit
uint32_t DACOutCode;
vscan = voltLVraw * (-1);
v_z = (V_5nV(2200) - (int64_t)vscan) * 200000 / 431579 + V_5nV(200); // v_z = (V_5nV(2200) - vscan)/2.157895 + V_5nV(200);
n_zero = v_z * 100 / V_5nV(3438); // n_zero = v_z / V_5nV(34.38);
v_zero = (int64_t)n_zero * V_5nV(3438) / 100; // v_zero = n_zero * V_5nV(34.38);
//
if (vscan < 0) { //
v_zero -= V_5nV(5372) / 10000; // v_zero -= V_5nV(0.5372);
} //
//
v_bias = vscan + v_zero; // v_bias = vscan + v_zero;
n_bias = v_bias * 10000 / V_5nV(5372); // n_bias = v_bias / V_5nV(0.5372);
while (n_bias > 4095) {
n_zero--;
v_zero = (int64_t)n_zero * V_5nV(3438) / 100;
if (vscan < 0) {
v_zero -= V_5nV(5372) / 10000;
}
v_bias = vscan + v_zero;
n_bias = v_bias * 10000 / V_5nV(5372);
if ((n_bias <= 4095) || ( n_bias > 4095 && n_zero > 63))
break;
}
if(n_bias > 4095) n_bias = 4095;
if(n_zero > 63) n_zero = 63;
DACOutCode = (0x0003FFFF & ((n_zero << 12) + n_bias));
AD5940_SPIWriteReg(LPDACDAT0, DACOutCode);
ret = (int32_t)(v_bias - v_zero); //vscan
return ret;
}
/* user code: 0 ~ 50000: -2V ~ +2V */
static void HSDAC_outputV(int32_t voltLVraw)
{
uint8_t n_zero;//6btit
uint16_t n_bias;//12bit
uint32_t DACOutCode;
int64_t value = ((int64_t)voltLVraw * voltLVraw * CaliTable.ac_dcbais.up_a + voltLVraw * CaliTable.ac_dcbais.up_b + CaliTable.ac_dcbais.up_c + 5e11) / 1e12;
if ( value < 1920)
value = ((int64_t)voltLVraw * voltLVraw * CaliTable.ac_dcbais.down_a + voltLVraw * CaliTable.ac_dcbais.down_b + CaliTable.ac_dcbais.down_c + 5e11) / 1e12;
n_zero = 30;
n_bias = (uint16_t)value;
if(n_bias > 4095) n_bias = 4095;
if(n_zero > 63) n_zero = 63;
DACOutCode = (0x0003FFFF & ((n_zero << 12) + n_bias));
AD5940_SPIWriteReg(LPDACDAT0, DACOutCode);
return;
}
/* user code: 0 ~ 50000; LPDAC bias value: -2V ~ +2V */
static void set_lpdac_ce_1100mv(uint8_t z, uint16_t b) { // LPDAC output, voltLV = Vbias-Vzero
/* new code*/
uint8_t n_zero = z;//6btit
uint16_t n_bias = b;//12bit
uint32_t DACOutCode;
DACOutCode = (0x0003FFFF & ((n_zero << 12) + n_bias));
AD5940_SPIWriteReg(LPDACDAT0, DACOutCode);
return;
}
static uint32_t DAC_outputF(uint32_t freq) {
AD5940_SPIWriteReg(WGFCW, freq);
return freq;
}
static void VoutGainControl(uint8_t VOUTLevel){
// if(VOUTLevel == 0){
// // VOUT gain level = 0, using 240K resister
// PIN_setOutputValue(pin_handle, Turon_VOUT_SMALL, 0);
// }
// else if(VOUTLevel == 1){
// // VOUT gain level = 1, using 15K resister
// PIN_setOutputValue(pin_handle, Turon_VOUT_SMALL, 1);
// }
// else if(VOUTLevel == 2){
// // VOUT gain level = 2, using 15K resister
// PIN_setOutputValue(pin_handle, Turon_VOUT_SMALL, 1);
// }
// else{
// // default using 15K resister
// PIN_setOutputValue(pin_handle, Turon_VOUT_SMALL, 1);
// }
// record_flag = false;
}
static uint32_t CalcPeriod(uint32_t freq){ //One Second = 10000
uint32_t period;
if (freq == 1) {
period = 666667;
} else {
period = (1000000 + freq / 2) / freq; // [sec]
}
if (period < 20){
period = 20;
}
return period;
}
static uint32_t CalcDelayTime(uint32_t freq){ //freq[10mHz]
uint32_t delayTime, decadeSamplingTime;
delayTime = CalcPeriod(freq) * instru.delay; //get delay time
if (delayTime < 20) {
delayTime = 20;
} else {
delayTime = (delayTime + 5) / 10;
}
// 10kHz
if (freq >= 1000000) {
decadeSamplingTime = 1025;
}
// 1kHz
else if (freq >= 100000) {
decadeSamplingTime = 1025;
}
// 100Hz
else if (freq >= 10000) {
decadeSamplingTime = 1025;
}
// 10Hz
else if (freq >= 1000) {
decadeSamplingTime = 11395;
}
// 1Hz
else if (freq >= 100) {
decadeSamplingTime = 56900;
}
//0.1Hz
else if (freq >= 10) {
decadeSamplingTime = 546000;
}
// 0.015Hz | 136s
else if (freq >= 1) {
decadeSamplingTime = 1364995;
}
delayTime += decadeSamplingTime; //delay+reading time
return delayTime;
}
static uint32_t User2Freq(uint32_t UserCode){
uint32_t freq;
freq = UserCode * 15 / 10;
return freq; //[10mHz]
}
static uint32_t Freq2DAC(uint32_t freq){
uint32_t code;
code = freq * 10 / 15;
return code; //return code
}
// DAC Vout theoretical boundary <300, 100~ (mV)
#define DAC_VOUT_GAIN_SMALL_BOUNDARY 100000 // 25500(usercode) = 100 mV
#define DAC_VOUT_GAIN_LARGE_BOUNDARY 300000 // 26500(usercode) = 300 mV
#define DAC_VOUT_GAIN_LARGE_BOUNDARY_USERCODE 26500 // 26500(usercode) = 300 mV
#define DAC_VOUT_GAIN_LARGE_BOUNDARY1_USERCODE 23500 // 23500(usercode) = -300 mV
static void AutoGainChangeVout(int32_t userCode){
int32_t RealVolt = (userCode - 25000) * 200; // (userCode - 25000) / 5 * 1000 [1uV]
// switch to 1 level volt(small) 15K
// switch to 2 level volt(large) 240K
if(instru.VoutGainLevel == VOUT_GAIN_AUTO){
instru.VoutGainLevel = VOUT_GAIN_15K;
VoutGainControl(instru.VoutGainLevel);
}
if(instru.VoutGainLevel == VOUT_GAIN_15K){
if(RealVolt > DAC_VOUT_GAIN_LARGE_BOUNDARY || RealVolt < -1 * DAC_VOUT_GAIN_LARGE_BOUNDARY){
// switch to 2 level volt(large)
instru.VoutGainLevel = VOUT_GAIN_240K;
VoutGainControl(instru.VoutGainLevel);
}
}
else if(instru.VoutGainLevel == VOUT_GAIN_240K){
if(RealVolt < DAC_VOUT_GAIN_SMALL_BOUNDARY && RealVolt > -1 * DAC_VOUT_GAIN_SMALL_BOUNDARY ){
// switch to 1 level volt(small)
instru.VoutGainLevel = VOUT_GAIN_15K;
VoutGainControl(instru.VoutGainLevel);
}
}
}
static void cali_SetWGAmp(uint32_t ampcode){
AD5940_SPIWriteReg(WGCON, 0x0); // 0x0: DC disable ac first
AD5940_SPIWriteReg(WGAMPLITUDE, ampcode);
AD5940_SPIWriteReg(WGCON, 0x00000004); //0x4: Sinusoid
}
static void SetWGAmp(uint16_t ampcode, uint32_t freq){
uint32_t amplitude = 0;
amplitude = Cali_HSAMP(ampcode, freq);
cali_SetWGAmp(amplitude);
}
static void SetEISHIGHZ(uint8_t ret){
uint32_t code;
// select_REG_RRR(LPTIASW0); //LPTIASW0
code = AD5940_SPIReadReg(LPTIASW0);
code = (code & (~(1 << 2))) | (ret << 2); //ret = 0 HighZ on | ret = 1 HighZ off
AD5940_SPIWriteReg(LPTIASW0, code);
}
#endif
@@ -1,291 +0,0 @@
#ifndef __INSTR_H__
#define __INSTR_H__
#ifdef __cpulsplus
extern "C" {
#endif
/*==============================
==== headstage instruction ====
=============================*/
struct HEADSTAGE_INSTRUCTION {
uint8_t chip_id;
uint8_t eliteFxn;
/** DAC parameter **/
uint8_t VsetRateIndex;
uint32_t VsetRate;
int32_t Vset;
uint16_t VoltConstant;
uint8_t directionInit;
uint32_t step;
uint16_t Ve1;
uint16_t Ve2;
int32_t Vinit;
int32_t Vmax;
int32_t Vmin;
/** EIS **/
uint32_t f1;
uint32_t f2;
uint32_t fmax;
uint32_t fmin;
uint32_t fset;
uint16_t dcbias;
uint16_t delay;
uint16_t acamp;
uint8_t avgnum;
uint8_t rtia;
uint16_t ppd;
uint8_t scale;
int32_t real;
int32_t imag;
uint8_t periodIndex;
uint32_t delayTime;
uint8_t settingIndex;
/** ADC parameter **/
uint8_t notifyRateIndex;
uint32_t sampleRate;
uint8_t VoViSwitch;
uint8_t VinAutoGainEnable;
uint8_t VoutAutoGainEnable;
uint8_t ADCGainLv;
// voltage output gain
uint16_t VoutGainLevel;
uint8_t VinADCGainLv;
/** Notify parameter **/
uint32_t notifyRate;
/** mode parameter **/
uint16_t cycleNumber;
uint8_t charge;
int32_t constantCurrent;
int32_t Currentmax;
int32_t sti_v1;
int32_t sti_v2;
int32_t sti_v3;
int32_t sti_v4;
int32_t sti_v5;
int32_t sti_v6;
int32_t sti_v7;
int32_t sti_t1;
int32_t sti_t2;
int32_t sti_t3;
int32_t sti_t4;
int32_t sti_t5;
int32_t sti_t6;
int32_t sti_t7;
uint16_t sti_cy;
uint16_t sti_loop;
uint16_t StepTime;
uint8_t AdcChannel;
/* EIS DAC parameter */
uint8_t DAC_type;
uint16_t VAmpSet; // DAC Voltage Amplitude
/* EIS ADC parameter */
uint8_t gain_lv_hstia;
uint8_t HSTIAAutoGainEnable;
uint8_t gain_lv_lptia;
uint8_t LPTIAAutoGainEnable;
//VT mode
uint8_t measure_vin_range;
} instru = {0};
/** ADC Iin gain level **/
#define I_GAIN_3M 0x07 // largest gain
#define I_GAIN_100K 0x08
#define I_GAIN_3K 0x09
#define I_GAIN_100R 0x0A // the least gain
#define I_GAIN_AUTO 0x04
// EIS LPTIA Iin Gain Level //
//#define LPRTIA_512K 0x00
#define LPRTIA_64K 0x00
#define LPRTIA_8K 0x01
#define LPRTIA_1K 0x02
#define LPRTIA_200R 0x03
#define LPRTIA_GAIN_AUTO 0x04
#define DISCONNECT_RTIA 0x05
// EIS HSTIA Iin Gain Level
enum hsrtia_gain_e {
HSRTIA_160K = 0,
HSRTIA_80K,
HSRTIA_40K,
HSRTIA_20K,
HSRTIA_10K,
HSRTIA_5K,
HSRTIA_1K,
HSRTIA_200R,
HSRTIA_MAX,
};
/** ADC Vin gain level **/
#define VIN_GAIN_1M 0x00
#define VIN_GAIN_30K 0x01
#define VIN_GAIN_1K 0x02
#define VIN_GAIN_AUTO 0x03
/** Vout gain level **/
#define VOUT_GAIN_240K 0x00
#define VOUT_GAIN_15K 0x01
#define VOUT_GAIN_AUTO 0x02
/* DAC reset parameter */
#define DAC_ZERO 25000
#define EIS_HSDAC_ZERO 0x0800
// Step time macro
#define STEPTIME_HALF_SEC 5000
#define STEPTIME_ONE_SEC 10000
#define STEPTIME_TWO_SEC 20000
/* AVG Number */
#define AVG2 0
#define AVG4 1
#define AVG8 2
#define AVG16 3
#define ADC1M6sps 0
#define ADC800Ksps 1
#define Sinc3OSR5 0
#define Sinc3OSR4 1
#define Sinc3OSR2 2
#define Sinc2OSR22 0
#define Sinc2OSR44 1
#define Sinc2OSR89 2
#define Sinc2OSR178 3
#define Sinc2OSR267 4
#define Sinc2OSR533 5
#define Sinc2OSR640 6
#define Sinc2OSR667 7
#define Sinc2OSR800 8
#define Sinc2OSR889 9
#define Sinc2OSR1067 10
#define Sinc2OSR1333 11
#define DFTNUM4 0
#define DFTNUM8 1
#define DFTNUM16 2
#define DFTNUM32 3
#define DFTNUM64 4
#define DFTNUM128 5
#define DFTNUM256 6
#define DFTNUM512 7
#define DFTNUM1024 8
#define DFTNUM2048 9
#define DFTNUM4096 10
#define DFTNUM8192 11
#define DFTNUM16384 12
#define AD5940_SYS_CLOCK 16000000
#define Cutoff_Freq 37000000 // 210kHz
static uint32_t HSRTIATable[4] = {160000, 20000, 5000, 200};
/*********************************************************************
* @fn InitEliteInstruction
*
* @brief Init all INSTRUCTION variable.
*
* @param None.
*
* @return None.
*/
static void InitEliteInstruction(){
instru.chip_id = 0;
instru.eliteFxn = 0; //default is a null event
instru.VsetRateIndex = 0;
instru.VsetRate = 2;
instru.Vset = 0;
instru.VoltConstant = DAC_ZERO; //DAC_ZERO is about 0V
instru.directionInit = 1; //0:reverse 1:forward
instru.step = 0;
instru.Ve1 = DAC_ZERO;
instru.Ve2 = DAC_ZERO;
instru.Vinit = 0;
instru.Vmax = 0;
instru.Vmin = 0;
instru.notifyRateIndex = 100;
instru.sampleRate = 15;
instru.VoViSwitch = 0x01; //0:user see Vo 1: user see Vi
instru.VinAutoGainEnable = 1;
instru.VoutAutoGainEnable = 1;
instru.VoutGainLevel = VOUT_GAIN_AUTO;
instru.VinADCGainLv = VIN_GAIN_AUTO;
instru.notifyRate = STEPTIME_ONE_SEC;
instru.cycleNumber = 1;
instru.charge = 1; //0:discharge 1:charge
instru.constantCurrent = 0;
instru.Currentmax = 0;
instru.StepTime = STEPTIME_ONE_SEC;
instru.AdcChannel = 0;
//EIS
instru.f1 = 0;
instru.f2 = 0;
instru.fset = 0;
instru.fmax = 0;
instru.fmin = 0;
instru.delay = 0;
instru.scale = 0;
instru.avgnum = 0;
instru.dcbias = 0;
instru.acamp = 0;
instru.ppd = 1;
instru.periodIndex = 0;
instru.delayTime = 0;
instru.settingIndex = 0;
//pulse mode
instru.sti_t1 = 0;
instru.sti_t2 = 0;
instru.sti_t3 = 0;
instru.sti_t4 = 0;
instru.sti_t5 = 0;
instru.sti_t6 = 0;
instru.sti_t7 = 0;
instru.sti_v1 = DAC_ZERO;
instru.sti_v2 = DAC_ZERO;
instru.sti_v3 = DAC_ZERO;
instru.sti_v4 = DAC_ZERO;
instru.sti_v5 = DAC_ZERO;
instru.sti_v6 = DAC_ZERO;
instru.sti_v7 = DAC_ZERO;
instru.sti_loop = 1;
instru.sti_cy = 0;
//General
// EIS DAC
instru.VAmpSet = EIS_HSDAC_ZERO;
instru.DAC_type = 0;
// EIS ADC
instru.gain_lv_hstia = HSRTIA_200R;
instru.HSTIAAutoGainEnable = 1;
instru.gain_lv_lptia = LPRTIA_200R;
instru.LPTIAAutoGainEnable = 1;
// VT mode
instru.measure_vin_range = 0;
}
#ifdef __cpulsplus
}
#endif
#endif
@@ -1,84 +0,0 @@
#ifndef ELITELED
#define ELITELED
static bool btWaitLedFlag = 0;
static bool noEventLedFlag = 0;
static bool preWorkLedFlag = 0;
static bool workingLedFlag = 0;
static bool postWorkLedFlag = 0;
static void WorkModeLED();
static void ModeLED(uint16_t modeStatus) {
btWaitLedFlag = 0;
noEventLedFlag = 0;
preWorkLedFlag = 0;
workingLedFlag = 0;
postWorkLedFlag = 0;
switch (modeStatus) {
case BT_WAIT:
btWaitLedFlag = 1;
led_color_set(LED_NB_MAX, LED_BR_LV1, LED_CLR_YELLOWGREEN);
break;
case NO_EVENT:
noEventLedFlag = 1;
led_color_set(LED_NB_MAX, LED_BR_LV1, LED_CLR_GREEN);
break;
case PRE_WORK:
preWorkLedFlag = 1;
led_color_set(LED_NB_MAX, LED_BR_LV1, LED_CLR_BLUE);
break;
case WORKING:
workingLedFlag = 1;
WorkModeLED();
break;
case POST_WORK:
postWorkLedFlag = 1;
led_color_set(LED_NB_MAX, LED_BR_LV1, LED_CLR_BLUE);
break;
default:
break;
}
}
static void checkFlafLED()
{
if(btWaitLedFlag == 1) {
ModeLED(BT_WAIT);
} else if(noEventLedFlag == 1) {
ModeLED(NO_EVENT);
} else if(preWorkLedFlag == 1) {
ModeLED(PRE_WORK);
} else if(workingLedFlag == 1) {
ModeLED(WORKING);
} else if(postWorkLedFlag == 1) {
ModeLED(POST_WORK);
}
}
static void WorkModeLED()
{
switch (instru.eliteFxn) {
case CURVE_EIS:
case CURVE_CV:
case CURVE_CA:
case CURVE_VT:
case CURVE_RT:
case CURVE_CF:
led_color_set(LED_NB_MAX, LED_BR_LV1, LED_CLR_CYAN);
break;
default:
break;
}
}
#endif
@@ -1,202 +0,0 @@
/**
* notify data buffer.
* the length equals to the characteristic 4 which value is 20 bytes.
*
*/
#ifndef ELITENOTIFY
#define ELITENOTIFY
#include "headstage.h"
/*notify's input type*/
#define NOTIFY_CURRENT 0
#define NOTIFY_VOLT 1
#define NOTIFY_IMPEDANCE 2
#define NOTIFY_VOLT_BAT 3
static uint32_t not_time_stamp;
static uint8_t NotifyCh1[4] = {0};
static uint8_t NotifyCh2[4] = {0};
static uint8_t NotifyCh3[4] = {0};
static uint8_t NotifyVoltBat[4] = {0};
static uint16_t NotifyCycleNumber = 0;
static uint8_t finishMode = 0;
static uint8_t gain = 0;
static int32_t notify_one = 0;
static int32_t notify_two = 0;
static int32_t notify_three = 0;
static uint32_t NotifyCh4 = 0;
// ****************** New Notify Format ******************************** //
/*
* Notify format
*
*
| | 1 | 2 | 3 |
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2
-----------------------------------------------------------------
| header |
| current |
| voltage or impedance |
| mode & gain |
| time stamp |
| cycle number |
mode & gain
this byte include Elite working mode and ADC gain level
we use "(mode & 0xF0) | (gain & 0x0F)" to encode these two information
cycle number
for cyclic voltammetry use, we save it as channel number.
0xFF
* header = device ID
* I = current (0.001nA), V = voltage (mV),
* Z = impedance (k ohm), T = time (ms)
*
*
*/
// ********* End New Format Notify ***************************************** //
/*
* Notify format
*
*
| | 1 | 2 | 3 |
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2
-----------------------------------------------------------------
| header |
| current |
| voltage |
| impedance |
| time stamp |
| cycle number |
cycle number
for cyclic voltammetry use, we save it as channel number.
0xFF
* header = device ID
* I = current (nA), V = voltage (uV),
* Z = impedance (ohm), T = time (ms)
*
*
*/
static void initDATBuf(void)
{
memset(not_buf, 0, BLE_DAT_BUFF_SIZE);
return;
}
static void initINSBuf(void)
{
memset(ins_buf, 0, BLE_INS_BUFF_SIZE);
return;
}
static void initCISBuf(void)
{
memset(cis_buf, 0, BLE_CIS_BUFF_SIZE);
return;
}
static void SendNotify() {
initDATBuf();
not_buf[0] = instru.chip_id;
for (int i = 0; i < 4; i++) {
not_buf[i + 1] = NotifyCh1[i]; // 1 2 3 4
not_buf[i + 5] = NotifyCh2[i]; // 5 6 7 8
not_buf[i + 9] = NotifyCh3[i]; //9 10 11 12
}
// 1 Timestamp = 32 usec; 31 Timestamp ~= 1 msec
not_time_stamp = (Timestamp_get32()) / 31; // msec
not_buf[13] = not_time_stamp & 0xff;
not_buf[14] = (not_time_stamp >> 8) & 0xff;
not_buf[15] = (not_time_stamp >> 16) & 0xff;
not_buf[16] = (not_time_stamp >> 24) & 0xff;
not_buf[17] = (NotifyCycleNumber >> 8) & 0xff;
not_buf[18] = NotifyCycleNumber & 0xff;
not_buf[19] = (finishMode << 7) & 0x80;
not_buf[20] = gain;
memcpy(not_buf+21, (uint8_t *)&NotifyCh4, sizeof(NotifyCh4));
memcpy(not_buf+25, (uint8_t *)&notify_one, sizeof(notify_one));
memcpy(not_buf+29, (uint8_t *)&notify_two, sizeof(notify_two));
memcpy(not_buf+33, (uint8_t *)&notify_three, sizeof(notify_three));
for (int i = 37; i < BLE_DAT_BUFF_SIZE; i++){
not_buf[i] = 0;
}
SimpleProfile_SetParameter(BLE_DAT_BUFF_CHAR, BLE_DAT_BUFF_SIZE, not_buf);
}
static void initRawDataBuf(){
not_time_stamp = 0;
NotifyCycleNumber = 0;
finishMode = 0;
for (int i = 0; i < 4; i++){
NotifyCh1[i] = 0;
NotifyCh2[i] = 0;
NotifyCh3[i] = 0;
}
}
static void FlushNotify(){
initRawDataBuf();
initDATBuf();
not_buf[0] = instru.chip_id;
SimpleProfile_SetParameter(BLE_DAT_BUFF_CHAR, BLE_DAT_BUFF_SIZE, not_buf);
}
static void InputNotify(int NotifyType, int32_t Data){
switch (NotifyType) {
case NOTIFY_CURRENT:
NotifyCh1[0] = (uint8_t)((Data & 0xFF000000) >> 24);
NotifyCh1[1] = (uint8_t)((Data & 0x00FF0000) >> 16);
NotifyCh1[2] = (uint8_t)((Data & 0x0000FF00) >> 8);
NotifyCh1[3] = (uint8_t)(Data & 0x000000FF);
break;
case NOTIFY_IMPEDANCE:
NotifyCh3[0] = (uint8_t)((Data & 0xFF000000) >> 24);
NotifyCh3[1] = (uint8_t)((Data & 0x00FF0000) >> 16);
NotifyCh3[2] = (uint8_t)((Data & 0x0000FF00) >> 8);
NotifyCh3[3] = (uint8_t)(Data & 0x000000FF);
break;
case NOTIFY_VOLT :
NotifyCh2[0] = (uint8_t)((Data & 0xFF000000) >> 24);
NotifyCh2[1] = (uint8_t)((Data & 0x00FF0000) >> 16);
NotifyCh2[2] = (uint8_t)((Data & 0x0000FF00) >> 8);
NotifyCh2[3] = (uint8_t)(Data & 0x000000FF);
break;
case NOTIFY_VOLT_BAT :
NotifyVoltBat[0] = (uint8_t)((Data & 0xFF000000) >> 24);
NotifyVoltBat[1] = (uint8_t)((Data & 0x00FF0000) >> 16);
NotifyVoltBat[2] = (uint8_t)((Data & 0x0000FF00) >> 8);
NotifyVoltBat[3] = (uint8_t)(Data & 0x000000FF);
break;
}
}
#endif
@@ -1,22 +0,0 @@
#ifndef ELITERESET
#define ELITERESET
static void reset() {
mode_init = true;
megaStiEnable = false;
PeriodicEvent = false; // is there an PeriodicEvent?
Free_Work_Mode = true; // Free(WorkModeData)
InitPeriodicEvent = true; // need to create a WorkModeData?
initINSBuf();
initDATBuf();
AD5940_HWReset();
AD5940_Initialize();
ModeLED(NO_EVENT);
CPUdelay_us(500);
}
#endif
@@ -1,66 +0,0 @@
#ifndef ELITE_SPI
#define ELITE_SPI
/*
* Read SPI example in
* http://software-dl.ti.com/dsps/dsps_public_sw/sdo_sb/targetcontent/tirtos/2_14_02_22/
* exports/tirtos_full_2_14_02_22/docs/doxygen/html/_s_p_i_c_c26_x_x_d_m_a_8h.html
*/
#include "board.h"
#include <ti/drivers/SPI.h>
#include <ti/drivers/dma/UDMACC26XX.h>
#include <ti/drivers/spi/SPICC26XXDMA.h>
#define ELITE_VERSION_EIS
#ifdef ELITE_VERSION_EIS
/* define SPI command */
// datasheet page 98
//#define SPICMD_SETADDR 0x20
//#define SPICMD_WRITEREG 0x2D
//#define SPICMD_READREG 0x6D
//define REG
#define LPDACCON0 0x2128
#define LPDACSW0 0x2124
#define LPDACDAT0 0x2120
#define LPREFBUFCON 0x2050
#define SWMUX 0x235C
#define LPTIASW0 0x20E4
#define SWCON 0x200C
#define HSDACCON 0x2010
#define HSDACDAT 0x2048
#define LPTIACON0 0x20EC
#define HSTIACON 0x20FC
#define AFECON 0x2000
#define DSWFULLCON 0x2150
#define NSWFULLCON 0x2154
#define PSWFULLCON 0x2158
#define TSWFULLCON 0x215C
#define WGFCW 0x2030
#define WGPHASE 0x2034
#define WGOFFSET 0x2038
#define WGAMPLITUDE 0x203C
#define WGCON 0x2014
#define DE0RESCON 0x20F8
#define ADCCON 0x21A8
#define DFTCON 0x20D0
#define ADCFILTERCON 0x2044
#define PMBW 0x22F0
#define CLKSEL 0x0414
#define CLKCON0 0x0408
#define CLKCON0KEY 0x0420
#define HSOSCCON 0x20BC
#define ADCBUFCON 0x238C
#define HSRTIACON 0x20F0
#define DFTREAL 0x2078
#define DFTIMAG 0x207C
#define ADCDAT 0x2074
#define RRR_AFE_STATSCON 0x21C4 /* AFE Statistics Control */
#endif // ELITE_EIS
#endif // ELITE_SPI
@@ -1,478 +0,0 @@
/*=============================================================================
= wm.h =
=============================================================================*/
#ifndef ELITE_WORK_DATA
#define ELITE_WORK_DATA
#define CLOCK_ONE_SECOND 10000 // 1s
#include "EliteInstruction.h"
/***** Template of Measure and VoltOut parameter *****/
#define VOUT_PARA \
int32_t _Vinit; \
int32_t _Vmax; \
int32_t _Vmin; \
int32_t _Vset; \
uint32_t _Vstep; \
bool _direction_up; \
bool _current_direction_up; \
uint16_t _cycleNumber
/* member of mode */
struct wm_eis_ctx_t {
uint32_t _f1;
uint32_t _f2;
uint32_t _fd1;
uint32_t _fd2;
uint32_t _fmax;
uint32_t _fmin;
uint8_t _decades; //num of decades in whole
uint16_t _ppd;
int8_t _decadeIndex; //index of decade max is 8
int16_t _sweepIndex; //index of smaller decade max is 10
bool _direction_up;
bool _in_reset_flag;
uint16_t _amp;
};
struct wm_cf_ctx_t {
uint32_t _f1;
bool _in_reset_flag;
uint16_t _amp;
};
struct wm_vo_ctx_t {
/* WARNING: please keep MEASURE at first!! */
int32_t _Vset;
int32_t _Vinit;
};
struct wm_it_ctx_t {
/* WARNING: please keep MEASURE at first!! */
};
struct wm_vt_ctx_t {
/* WARNING: please keep MEASURE at first!! */
};
struct wm_rt_ctx_t {
/* WARNING: please keep MEASURE at first!! */
int32_t _Vset;
int32_t _Vinit;
};
struct wm_iv_ctx_t {
/* WARNING: please keep MEASURE at first!! */
VOUT_PARA;
};
struct wm_iv_cy_ctx_t {
/* WARNING: please keep MEASURE at first!! */
VOUT_PARA;
};
struct wm_cc_ctx_t {
/* WARNING: please keep MEASURE at first!! */
int32_t _Vmax;
int32_t _Vmin;
int32_t _Vset;
int32_t _Iset;
uint8_t _charge;
};
struct wm_cv_ctx_t {
/* WARNING: please keep MEASURE at first!! */
VOUT_PARA;
int32_t _LPRtia;
};
struct wm_lsv_ctx_t {
/* WARNING: please keep MEASURE at first!! */
VOUT_PARA;
};
struct wm_ca_ctx_t {
/* WARNING: please keep MEASURE at first!! */
int32_t _Vinit;
int32_t _Vset;
};
struct wm_pulse_ctx_t {
/* WARNING: please keep MEASURE at first!! */
int32_t _Vset;
int32_t _sti_v1;
int32_t _sti_v2;
int32_t _sti_v3;
int32_t _sti_v4;
int32_t _sti_v5;
int32_t _sti_v6;
int32_t _sti_v7;
int32_t _sti_t1;
int32_t _sti_t2;
int32_t _sti_t3;
int32_t _sti_t4;
int32_t _sti_t5;
int32_t _sti_t6;
int32_t _sti_t7;
int32_t _sti_t;
int32_t _sti_v; //output voltage now
int32_t _sti_t_flag; //Where's the time stage turn
uint16_t _sti_cy;
uint16_t _sti_lp;
};
struct wm_ocp_ctx_t {
/* WARNING: please keep MEASURE at first!! */
};
int wm_init(void); //(void *instr_ctx);
int wm_deinit(void);
void *wm_get(void);
/*=============================================================================
= wm.c =
=============================================================================*/
static void *workMode_p = NULL;
static bool Free_Work_Mode = false;
/* init mode func */
static int __eis_create(void)
{
struct wm_eis_ctx_t *p;
void **wm = &workMode_p;
p = malloc(sizeof(struct wm_eis_ctx_t));
if (!p) return -1;
p->_f1 = instru.f1;
p->_f2 = instru.f2;
p->_fmax = instru.fmax;
p->_fmin = instru.fmin;
p->_fd1 = 0; //decade freq 1
p->_fd2 = 0; //decade freq 2
p->_ppd = instru.ppd; //points per decade
p->_decades = 0;
p->_sweepIndex = 0;
p->_decadeIndex = 0;
p->_direction_up = true;
p->_in_reset_flag = false;
p->_amp = instru.acamp;
*wm = p;
return 0;
}
static int __cf_create(void)
{
struct wm_cf_ctx_t *p;
void **wm = &workMode_p;
p = malloc(sizeof(struct wm_cf_ctx_t));
if (!p) return -1;
p->_f1 = instru.f1; //[reg's value]
p->_in_reset_flag = false;
p->_amp = instru.acamp;
*wm = p;
return 0;
}
static int __ca_create(void)
{
struct wm_ca_ctx_t *p;
void **wm = &workMode_p;
p = malloc(sizeof(struct wm_ca_ctx_t));
if (!p) return -1;
p->_Vinit = (instru.Vinit - 25000) * 4 * 4000; //[5nV]
p->_Vset = 0;
*wm = p;
return 0;
}
static int __vo_create(void)
{
struct wm_vo_ctx_t *p;
void **wm = &workMode_p;
p = malloc(sizeof(struct wm_vo_ctx_t));
if (!p) return -1;
p->_Vinit = (instru.Vinit - 25000) * 4 * 10000; //[5nV]
p->_Vset = 0;
*wm = p;
return 0;
}
static int __it_create(void)
{
struct wm_it_ctx_t *p;
void **wm = &workMode_p;
p = malloc(sizeof(struct wm_it_ctx_t));
if (!p) return -1;
*wm = p;
return 0;
}
static int __vt_create(void)
{
struct wm_vt_ctx_t *p;
void **wm = &workMode_p;
p = malloc(sizeof(struct wm_vt_ctx_t));
if (!p) return -1;
*wm = p;
return 0;
}
static int __rt_create(void)
{
struct wm_rt_ctx_t *p;
void **wm = &workMode_p;
p = malloc(sizeof(struct wm_rt_ctx_t));
if (!p) return -1;
p->_Vinit = (instru.Vinit - 25000) * 4 * 4000; //[5nV]
p->_Vset = 0;
*wm = p;
return 0;
}
static int __iv_create(void)
{
struct wm_iv_ctx_t *p;
void **wm = &workMode_p;
p = malloc(sizeof(struct wm_iv_ctx_t));
if (!p) return -1;
p->_Vinit = instru.Vinit; //(instru.Vinit - 25000) * 4 * 10000; //[5nV]
p->_Vmax = instru.Vmax; //(instru.Vmax - 25000) * 4 * 10000; //[5nV]
p->_Vmin = instru.Vmin; //(instru.Vmin - 25000) * 4 * 10000; //[5nV]
p->_Vset = 0;
p->_Vstep = 0;
p->_direction_up = true;
p->_current_direction_up = true;
p->_cycleNumber = instru.cycleNumber;
*wm = p;
return 0;
}
static int __iv_cy_create(void)
{
struct wm_iv_cy_ctx_t *p;
void **wm = &workMode_p;
p = malloc(sizeof(struct wm_iv_cy_ctx_t));
if (!p) return -1;
p->_Vinit = (instru.Vinit - 25000) * 4 * 10000; //[5nV]
p->_Vmax = (instru.Vmax - 25000) * 4 * 10000; //[5nV]
p->_Vmin = (instru.Vmin - 25000) * 4 * 10000; //[5nV]
p->_Vset = 0;
p->_Vstep = 0;
p->_direction_up = true;
p->_current_direction_up = true;
p->_cycleNumber = instru.cycleNumber;
*wm = p;
return 0;
}
static int __cc_create(void)
{
struct wm_cc_ctx_t *p;
void **wm = &workMode_p;
p = malloc(sizeof(struct wm_cc_ctx_t));
if (!p) return -1;
p->_Vmax = (instru.Vmax - 25000) * 4 * 10000; //[5nV]
p->_Vmin = (instru.Vmin - 25000) * 4 * 10000; //[5nV]
p->_Vset = 0;
p->_charge = instru.charge;
p->_Iset = instru.constantCurrent * 200 ;
//[50pA] //controller UI 15000uA => Elite 1500000 => 1500000 * 10 * 1000 / 50 [50pA]
*wm = p;
return 0;
}
static int __cv_create(void)
{
struct wm_cv_ctx_t *p;
void **wm = &workMode_p;
p = malloc(sizeof(struct wm_cv_ctx_t));
if (!p) return -1;
p->_Vinit = (instru.Vinit - 25000) * 4 * 4000; //[5nV]
p->_Vmax = (instru.Vmax - 25000) * 4 * 4000; //[5nV]
p->_Vmin = (instru.Vmin - 25000) * 4 * 4000; //[5nV]
// p->_Vinit = (instru.Vinit - 25000) * 4 * 10000; //[5nV]
// p->_Vmax = (instru.Vmax - 25000) * 4 * 10000; //[5nV]
// p->_Vmin = (instru.Vmin - 25000) * 4 * 10000; //[5nV]
p->_Vset = 0;
p->_Vstep = 0;
p->_direction_up = true;
p->_current_direction_up = true;
p->_cycleNumber = instru.cycleNumber;
*wm = p;
return 0;
}
static int __lsv_create(void)
{
struct wm_lsv_ctx_t *p;
void **wm = &workMode_p;
p = malloc(sizeof(struct wm_lsv_ctx_t));
if (!p) return -1;
p->_Vinit = (instru.Vinit - 25000) * 4 * 10000; //[5nV]
p->_Vmax = (instru.Vmax - 25000) * 4 * 10000; //[5nV]
p->_Vmin = (instru.Vmin - 25000) * 4 * 10000; //[5nV]
p->_Vset = 0;
p->_Vstep = 0;
p->_direction_up = true;
p->_current_direction_up = true;
p->_cycleNumber = instru.cycleNumber;
*wm = p;
return 0;
}
static int __pulse_create(void)
{
struct wm_pulse_ctx_t *p;
void **wm = &workMode_p;
p = malloc(sizeof(struct wm_pulse_ctx_t));
if (!p) return -1;
p->_Vset = 0;
p->_sti_v1 = instru.sti_v1;
p->_sti_v2 = instru.sti_v2;
p->_sti_v3 = instru.sti_v3;
p->_sti_v4 = instru.sti_v4;
p->_sti_v5 = instru.sti_v5;
p->_sti_v6 = instru.sti_v6;
p->_sti_v7 = instru.sti_v7;
p->_sti_t1 = instru.sti_t1;
p->_sti_t2 = instru.sti_t2;
p->_sti_t3 = instru.sti_t3;
p->_sti_t4 = instru.sti_t4;
p->_sti_t5 = instru.sti_t5;
p->_sti_t6 = instru.sti_t6;
p->_sti_t7 = instru.sti_t7;
p->_sti_t = instru.sti_t1;
p->_sti_v = instru.sti_v1;
p->_sti_t_flag = 1;
p->_sti_cy = instru.sti_cy;
p->_sti_lp = instru.sti_loop;
*wm = p;
return 0;
}
static int __ocp_create(void)
{
struct wm_ocp_ctx_t *p;
void **wm = &workMode_p;
p = malloc(sizeof(struct wm_ocp_ctx_t));
if (!p) return -1;
*wm = p;
return 0;
}
int wm_init(void)
{
int mode = instru.eliteFxn;
void **wm = &workMode_p;
if (*wm) return -1;
switch (mode) {
case CURVE_EIS:
if (__eis_create()) return -2;
break;
case CURVE_CF:
if (__cf_create()) return -2;
break;
case CURVE_CV:
if (__cv_create()) return -2;
break;
case CURVE_CA:
if (__ca_create()) return -2;
break;
case CURVE_VT:
if (__vt_create()) return -2;
break;
case CURVE_RT:
if (__rt_create()) return -2;
break;
default:
// printf("DO NOT support!!");
return -3;
};
return 0;
}
int wm_deinit(void)
{
void **wm = &workMode_p;
if (*wm) {
free(*wm);
*wm = NULL;
} else {
return -1;
}
return 0;
}
void *wm_get(void)
{
void *wm = workMode_p;
return wm;
}
#endif
@@ -1,103 +0,0 @@
#ifndef ELITE_DEF
#define ELITE_DEF
// define BT instruction
#define INS_TYPE_RIS 0x30
#define INS_TYPE_VIS 0xC0
#define INS_TYPE_CIS 0x70
// VIS (virtual instruction)
#define VIS_RST 0xF0
#define VIS_ASK 0x30
#define VIS_STI 0xC0
#define VIS_INT 0x60
#define VIS_DEVICE_SHINY 0x10
#define VIS_SHINY_DIS 0x20
// RIS (real instruction)
enum all_mode_e {
CURVE_IV = 0x01, // I-V Curve
CURVE_IV_CY = 0x02, // Cycle I-V
CURVE_VO = 0x03, // Function Generator
CURVE_RT = 0x04, // R-T Graph
CURVE_VT = 0x05, // V-T Graph
CURVE_IT = 0x06, // I-T Graph
CURVE_CC = 0x07, // Constant Current (CC)
CURVE_OCP = 0x08, // Open Circuit Potential (OCP)
CURVE_CV = 0x09, // Cyclic Voltammetry (CV)
CURVE_LSV = 0x0A, // Linear Sweep Voltammetry (LSV)
CURVE_CA = 0x0B, // Chronoamperometric Graph (CA)
CURVE_CP = 0x0C, // Chronopotentiometry (CP)
CURVE_UNI_PULSE = 0x0D, // Pulse Sensing (universal pulse)
CURVE_DPV = 0x0E, // Differential Pulse Voltammetry (DPV)
CURVE_DPV_ADVANCE = 0x0F,
CURVE_DPV_SMPRATE = 0x10,
CURVE_DPV_ADVANCE_SMPRATE = 0x11,
CURVE_EIS = 0x12,
CURVE_CF = 0x13, // Constant Frequency(CF)
CURVE_CALI = 0xF1,
////
SET_SAMPLE_RATE = 0xE0,
};
// CIS (control instruction)
#define CIS_VERSION 0x40
#define CIS_VOLT 0x10
#define CIS_LED_TEST 0x70
#define CIS_CALI 0x30
#define CIS_CALI2 0x90
#define CTL_WRT 0x20
#define CTL_RD 0x21
#define CTL_RD_DFTR 0x78
#define CTL_RD_DFTI 0x7C
#define CTL_RD_ADC 0x7A
#define CTL_RESET 0x11
// mode parameter
#define VMAX(v1,v2) ((v1 >= v2) ? v1 : v2)
#define VMIN(v1,v2) ((v1 < v2) ? v1 : v2)
#define VDIRECTION(v1,v2) ((v1 > v2) ? 0 : 1)
#define AFTER_READ_I 0
#define AFTER_READ_V 1
#define PARA_1 0x01
#define PARA_2 0x02
#define PARA_3 0x03
#define PARA_4 0x04
#define PARA_5 0x05
#define PARA_6 0x06
#define PARA_7 0x07
#define PARA_8 0x08
#define PARA_9 0x09
#define PARA_10 0x0A
#define PARA_11 0x0B
#define PARA_12 0x0C
#define PARA_13 0x0D
#define PARA_14 0x0E
#define PARA_15 0x0F
#define PARA_16 0x10
#define PARA_17 0x11
//Elite LED
#define COLOR_BLACK 0x00
#define COLOR_RED 0x01
#define COLOR_ORANGE 0x02
#define COLOR_YELLOW 0x03
#define COLOR_GREEN 0x04
#define COLOR_BLUE 0x05
#define COLOR_CYAN 0x06
#define COLOR_MAGENTA 0x07
#define COLOR_PURPLE 0x08
#define COLOR_WHITE 0x09
#define COLOR_YELLOWGREEN 0x0A
#define BT_WAIT 0x01
#define NO_EVENT 0x02
#define PRE_WORK 0x03
#define WORKING 0x04
#define POST_WORK 0x05
#endif
@@ -1,151 +0,0 @@
#include <math.h>
#ifndef ELITE_MODE_ADC_DAC
#define ELITE_MODE_ADC_DAC
static void freq_out()
{
DAC_outputF(instru.fset);
return;
}
static void vscan_volt_out(void)
{
if (instru.eliteFxn == CURVE_CV) {
struct wm_cv_ctx_t *cv = (struct wm_cv_ctx_t *)wm_get();
void *wm = wm_get();
/* in [5nV] ver */
DAC_outputV(instru.Vset);
InputNotify(NOTIFY_VOLT, instru.Vset/200);
} else if (instru.eliteFxn == CURVE_CA) {
struct wm_ca_ctx_t *ca = (struct wm_ca_ctx_t *)wm_get();
void *wm = wm_get();
/* in [5nV] ver */
DAC_outputV(instru.Vset);
InputNotify(NOTIFY_VOLT, instru.Vset/200);
} else if (instru.eliteFxn == CURVE_RT) {
struct wm_rt_ctx_t *rt = (struct wm_rt_ctx_t *)wm_get();
void *wm = wm_get();
/* in [5nV] ver */
DAC_outputV(instru.Vset);
InputNotify(NOTIFY_VOLT, instru.Vset/200);
}
return;
}
static int32_t neg_18bit(int32_t ret)
{
// if (ret > 131072) {
// ret = ret - 262144;
// }
ret &= 0x3FFFF;
if (ret & (1 << 17)) {
ret |= 0xFFFC0000;
}
return ret;
}
//////EIS PLOT RELATED FUNCTION END//////
static void DACenable(uint8_t afterRead)
{
void *wm = wm_get();
if (afterRead == AFTER_READ_I) {
switch (instru.eliteFxn) {
default:
break;
}
} else if (afterRead == AFTER_READ_V) {
switch (instru.eliteFxn) {
case CURVE_EIS:
case CURVE_CF:
freq_out();
break;
case CURVE_CV:
case CURVE_CA:
break;
default:{
led_color_set(LED_NB_MAX, LED_BR_LV1, LED_CLR_MAGENTA);
break;
}
}
}
}
static void LPTIA_change_gain(void)
{
static uint8_t rec_cnt = 0;
void *wm = wm_get();
if (instru.LPTIAAutoGainEnable > 1)
return;
/* read Iin and do NOT record the Iin after changing gain twice */
int32_t i;
i = read_LPTIA_Iin();
if (instru.LPTIAAutoGainEnable) {
AutoChangeLPTIAGain(i);
} else {
if (last_gain_lptia != instru.gain_lv_lptia) {
LPTIAGainCtrl(instru.gain_lv_lptia);
}
}
if (record_flag == false) {
rec_cnt++;
}
if (rec_cnt == 2) {
record_flag = true;
rec_cnt = 0;
}
return;
}
static void HSTIA_change_gain(void)
{
// static uint8_t rec_cnt = 0;
void *wm = wm_get();
if (instru.HSTIAAutoGainEnable > 1)
return;
/* read Iin and do NOT record the Iin after changing gain twice */
int32_t i;
i = read_HSTIA_Iin();
if (instru.HSTIAAutoGainEnable) {
AutoChangeHSTIAGain(i);
} else {
if (last_gain_hstia != instru.gain_lv_hstia) {
HSTIAGainCtrl(instru.gain_lv_hstia);
}
}
return;
}
#endif
@@ -1,10 +0,0 @@
#ifndef VERSION_DATE
#define VERSION_DATE
#define VERSION_DATE_YEAR 23
#define VERSION_DATE_MONTH 4
#define VERSION_DATE_DAY 21
#define VERSION_DATE_HOUR 14
#define VERSION_DATE_MINUTE 33
#endif
@@ -1,712 +0,0 @@
#include "eis_cali_table.h"
#define CALI_SIZE BLE_CIS_BUFF_SIZE
uint8_t check_sum(uint8_t message[], int nBytes)
{
uint8_t sum = 0;
while (nBytes-- > 0) {
sum += *(message++);
}
return sum;
}
static void send_cali_version(void)
{
uint8_t len = CALI_SIZE;
uint8_t ctx[CALI_SIZE] = {0};
uint8_t index = 0;
ctx[index++] = len-1;
ctx[index++] = instru.chip_id;
ctx[index++] = (uint8_t)(CALI_VERSION >> 8);
ctx[index++] = (uint8_t)(CALI_VERSION);
ctx[len-1] = check_sum(ctx, len);
SimpleProfile_SetParameter(BLE_CIS_BUFF_CHAR, CALI_SIZE, ctx);
return;
}
static void send_cali_gain0_hstia(void)
{
uint8_t len = CALI_SIZE;
uint8_t ctx[CALI_SIZE] = {0};
uint8_t index = 0;
ctx[index++] = len - 1;
ctx[index++] = instru.chip_id;
ctx[index++] = (uint8_t)(CaliTable.hstia_current[0][0].hstia_a >> 24);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[0][0].hstia_a >> 16);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[0][0].hstia_a >> 8);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[0][0].hstia_a);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[0][0].hstia_b >> 56);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[0][0].hstia_b >> 48);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[0][0].hstia_b >> 40);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[0][0].hstia_b >> 32);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[0][0].hstia_b >> 24);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[0][0].hstia_b >> 16);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[0][0].hstia_b >> 8);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[0][0].hstia_b);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[0][0].rolloff >> 24);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[0][0].rolloff >> 16);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[0][0].rolloff >> 8);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[0][0].rolloff);
ctx[len-1] = check_sum(ctx, len);
SimpleProfile_SetParameter(BLE_CIS_BUFF_CHAR, CALI_SIZE, ctx);
return;
}
static void send_cali_gain0_phase_freq0_freq1(void)
{
uint8_t len = CALI_SIZE;
uint8_t ctx[CALI_SIZE] = {0};
uint8_t index = 0;
uint8_t freq_lv_from = 0;
uint8_t freq_lv_to = 1;
ctx[index++] = len - 1;
ctx[index++] = instru.chip_id;
for (int i=freq_lv_from; i<=freq_lv_to; i++) {
ctx[index++] = (uint8_t)(CaliTable.phase[0][i].coeff >> 24);
ctx[index++] = (uint8_t)(CaliTable.phase[0][i].coeff >> 16);
ctx[index++] = (uint8_t)(CaliTable.phase[0][i].coeff >> 8);
ctx[index++] = (uint8_t)(CaliTable.phase[0][i].coeff);
ctx[index++] = (uint8_t)(CaliTable.phase[0][i].offset >> 24);
ctx[index++] = (uint8_t)(CaliTable.phase[0][i].offset >> 16);
ctx[index++] = (uint8_t)(CaliTable.phase[0][i].offset >> 8);
ctx[index++] = (uint8_t)(CaliTable.phase[0][i].offset);
}
ctx[len-1] = check_sum(ctx, len);
SimpleProfile_SetParameter(BLE_CIS_BUFF_CHAR, CALI_SIZE, ctx);
return;
}
static void send_cali_gain0_phase_freq2_freq3(void)
{
uint8_t len = CALI_SIZE;
uint8_t ctx[CALI_SIZE] = {0};
uint8_t index = 0;
uint8_t freq_lv_from = 2;
uint8_t freq_lv_to = 3;
ctx[index++] = len - 1;
ctx[index++] = instru.chip_id;
for (int i=freq_lv_from; i<=freq_lv_to; i++) {
ctx[index++] = (uint8_t)(CaliTable.phase[0][i].coeff >> 24);
ctx[index++] = (uint8_t)(CaliTable.phase[0][i].coeff >> 16);
ctx[index++] = (uint8_t)(CaliTable.phase[0][i].coeff >> 8);
ctx[index++] = (uint8_t)(CaliTable.phase[0][i].coeff);
ctx[index++] = (uint8_t)(CaliTable.phase[0][i].offset >> 24);
ctx[index++] = (uint8_t)(CaliTable.phase[0][i].offset >> 16);
ctx[index++] = (uint8_t)(CaliTable.phase[0][i].offset >> 8);
ctx[index++] = (uint8_t)(CaliTable.phase[0][i].offset);
}
ctx[len-1] = check_sum(ctx, len);
SimpleProfile_SetParameter(BLE_CIS_BUFF_CHAR, CALI_SIZE, ctx);
return;
}
static void send_cali_gain1_hstia(void)
{
uint8_t len = CALI_SIZE;
uint8_t ctx[CALI_SIZE] = {0};
uint8_t index = 0;
ctx[index++] = len - 1;
ctx[index++] = instru.chip_id;
ctx[index++] = (uint8_t)(CaliTable.hstia_current[1][0].hstia_a >> 24);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[1][0].hstia_a >> 16);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[1][0].hstia_a >> 8);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[1][0].hstia_a);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[1][0].hstia_b >> 56);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[1][0].hstia_b >> 48);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[1][0].hstia_b >> 40);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[1][0].hstia_b >> 32);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[1][0].hstia_b >> 24);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[1][0].hstia_b >> 16);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[1][0].hstia_b >> 8);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[1][0].hstia_b);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[1][0].rolloff >> 24);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[1][0].rolloff >> 16);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[1][0].rolloff >> 8);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[1][0].rolloff);
ctx[len-1] = check_sum(ctx, len);
SimpleProfile_SetParameter(BLE_CIS_BUFF_CHAR, CALI_SIZE, ctx);
return;
}
static void send_cali_gain1_phase_freq0_freq1(void)
{
uint8_t len = CALI_SIZE;
uint8_t ctx[CALI_SIZE] = {0};
uint8_t index = 0;
uint8_t freq_lv_from = 0;
uint8_t freq_lv_to = 1;
ctx[index++] = len - 1;
ctx[index++] = instru.chip_id;
for (int i=freq_lv_from; i<=freq_lv_to; i++) {
ctx[index++] = (uint8_t)(CaliTable.phase[1][i].coeff >> 24);
ctx[index++] = (uint8_t)(CaliTable.phase[1][i].coeff >> 16);
ctx[index++] = (uint8_t)(CaliTable.phase[1][i].coeff >> 8);
ctx[index++] = (uint8_t)(CaliTable.phase[1][i].coeff);
ctx[index++] = (uint8_t)(CaliTable.phase[1][i].offset >> 24);
ctx[index++] = (uint8_t)(CaliTable.phase[1][i].offset >> 16);
ctx[index++] = (uint8_t)(CaliTable.phase[1][i].offset >> 8);
ctx[index++] = (uint8_t)(CaliTable.phase[1][i].offset);
}
ctx[len-1] = check_sum(ctx, len);
SimpleProfile_SetParameter(BLE_CIS_BUFF_CHAR, CALI_SIZE, ctx);
return;
}
static void send_cali_gain1_phase_freq2_freq3(void)
{
uint8_t len = CALI_SIZE;
uint8_t ctx[CALI_SIZE] = {0};
uint8_t index = 0;
uint8_t freq_lv_from = 2;
uint8_t freq_lv_to = 3;
ctx[index++] = len - 1;
ctx[index++] = instru.chip_id;
for (int i=freq_lv_from; i<=freq_lv_to; i++) {
ctx[index++] = (uint8_t)(CaliTable.phase[1][i].coeff >> 24);
ctx[index++] = (uint8_t)(CaliTable.phase[1][i].coeff >> 16);
ctx[index++] = (uint8_t)(CaliTable.phase[1][i].coeff >> 8);
ctx[index++] = (uint8_t)(CaliTable.phase[1][i].coeff);
ctx[index++] = (uint8_t)(CaliTable.phase[1][i].offset >> 24);
ctx[index++] = (uint8_t)(CaliTable.phase[1][i].offset >> 16);
ctx[index++] = (uint8_t)(CaliTable.phase[1][i].offset >> 8);
ctx[index++] = (uint8_t)(CaliTable.phase[1][i].offset);
}
ctx[len-1] = check_sum(ctx, len);
SimpleProfile_SetParameter(BLE_CIS_BUFF_CHAR, CALI_SIZE, ctx);
return;
}
static void send_cali_gain2_hstia(void)
{
uint8_t len = CALI_SIZE;
uint8_t ctx[CALI_SIZE] = {0};
uint8_t index = 0;
ctx[index++] = len - 1;
ctx[index++] = instru.chip_id;
ctx[index++] = (uint8_t)(CaliTable.hstia_current[2][0].hstia_a >> 24);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[2][0].hstia_a >> 16);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[2][0].hstia_a >> 8);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[2][0].hstia_a);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[2][0].hstia_b >> 56);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[2][0].hstia_b >> 48);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[2][0].hstia_b >> 40);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[2][0].hstia_b >> 32);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[2][0].hstia_b >> 24);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[2][0].hstia_b >> 16);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[2][0].hstia_b >> 8);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[2][0].hstia_b);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[2][0].rolloff >> 24);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[2][0].rolloff >> 16);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[2][0].rolloff >> 8);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[2][0].rolloff);
ctx[len-1] = check_sum(ctx, len);
SimpleProfile_SetParameter(BLE_CIS_BUFF_CHAR, CALI_SIZE, ctx);
return;
}
static void send_cali_gain2_phase_freq0_freq1(void)
{
uint8_t len = CALI_SIZE;
uint8_t ctx[CALI_SIZE] = {0};
uint8_t index = 0;
uint8_t freq_lv_from = 0;
uint8_t freq_lv_to = 1;
ctx[index++] = len - 1;
ctx[index++] = instru.chip_id;
for (int i=freq_lv_from; i<=freq_lv_to; i++) {
ctx[index++] = (uint8_t)(CaliTable.phase[2][i].coeff >> 24);
ctx[index++] = (uint8_t)(CaliTable.phase[2][i].coeff >> 16);
ctx[index++] = (uint8_t)(CaliTable.phase[2][i].coeff >> 8);
ctx[index++] = (uint8_t)(CaliTable.phase[2][i].coeff);
ctx[index++] = (uint8_t)(CaliTable.phase[2][i].offset >> 24);
ctx[index++] = (uint8_t)(CaliTable.phase[2][i].offset >> 16);
ctx[index++] = (uint8_t)(CaliTable.phase[2][i].offset >> 8);
ctx[index++] = (uint8_t)(CaliTable.phase[2][i].offset);
}
ctx[len-1] = check_sum(ctx, len);
SimpleProfile_SetParameter(BLE_CIS_BUFF_CHAR, CALI_SIZE, ctx);
return;
}
static void send_cali_gain2_phase_freq2_freq3(void)
{
uint8_t len = CALI_SIZE;
uint8_t ctx[CALI_SIZE] = {0};
uint8_t index = 0;
uint8_t freq_lv_from = 2;
uint8_t freq_lv_to = 3;
ctx[index++] = len - 1;
ctx[index++] = instru.chip_id;
for (int i=freq_lv_from; i<=freq_lv_to; i++) {
ctx[index++] = (uint8_t) (CaliTable.phase[2][i].coeff >> 24);
ctx[index++] = (uint8_t) (CaliTable.phase[2][i].coeff >> 16);
ctx[index++] = (uint8_t) (CaliTable.phase[2][i].coeff >> 8);
ctx[index++] = (uint8_t) (CaliTable.phase[2][i].coeff);
ctx[index++] = (uint8_t) (CaliTable.phase[2][i].offset >> 24);
ctx[index++] = (uint8_t) (CaliTable.phase[2][i].offset >> 16);
ctx[index++] = (uint8_t) (CaliTable.phase[2][i].offset >> 8);
ctx[index++] = (uint8_t) (CaliTable.phase[2][i].offset);
}
ctx[len-1] = check_sum(ctx, len);
SimpleProfile_SetParameter(BLE_CIS_BUFF_CHAR, CALI_SIZE, ctx);
return;
}
static void send_cali_gain3_hstia(void)
{
uint8_t len = CALI_SIZE;
uint8_t ctx[CALI_SIZE] = {0};
uint8_t index = 0;
ctx[index++] = len - 1;
ctx[index++] = instru.chip_id;
ctx[index++] = (uint8_t)(CaliTable.hstia_current[3][0].hstia_a >> 24);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[3][0].hstia_a >> 16);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[3][0].hstia_a >> 8);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[3][0].hstia_a);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[3][0].hstia_b >> 56);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[3][0].hstia_b >> 48);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[3][0].hstia_b >> 40);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[3][0].hstia_b >> 32);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[3][0].hstia_b >> 24);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[3][0].hstia_b >> 16);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[3][0].hstia_b >> 8);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[3][0].hstia_b);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[3][0].rolloff >> 24);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[3][0].rolloff >> 16);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[3][0].rolloff >> 8);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[3][0].rolloff);
ctx[len-1] = check_sum(ctx, len);
SimpleProfile_SetParameter(BLE_CIS_BUFF_CHAR, CALI_SIZE, ctx);
return;
}
static void send_cali_gain3_phase_freq0_freq1(void)
{
uint8_t len = CALI_SIZE;
uint8_t ctx[CALI_SIZE] = {0};
uint8_t index = 0;
uint8_t freq_lv_from = 0;
uint8_t freq_lv_to = 1;
ctx[index++] = len - 1;
ctx[index++] = instru.chip_id;
for (int i=freq_lv_from; i<=freq_lv_to; i++) {
ctx[index++] = (uint8_t)(CaliTable.phase[3][i].coeff >> 24);
ctx[index++] = (uint8_t)(CaliTable.phase[3][i].coeff >> 16);
ctx[index++] = (uint8_t)(CaliTable.phase[3][i].coeff >> 8);
ctx[index++] = (uint8_t)(CaliTable.phase[3][i].coeff);
ctx[index++] = (uint8_t)(CaliTable.phase[3][i].offset >> 24);
ctx[index++] = (uint8_t)(CaliTable.phase[3][i].offset >> 16);
ctx[index++] = (uint8_t)(CaliTable.phase[3][i].offset >> 8);
ctx[index++] = (uint8_t)(CaliTable.phase[3][i].offset);
}
ctx[len-1] = check_sum(ctx, len);
SimpleProfile_SetParameter(BLE_CIS_BUFF_CHAR, CALI_SIZE, ctx);
return;
}
static void send_cali_gain3_phase_freq2_freq3(void)
{
uint8_t len = CALI_SIZE;
uint8_t ctx[CALI_SIZE] = {0};
uint8_t index = 0;
uint8_t freq_lv_from = 2;
uint8_t freq_lv_to = 3;
ctx[index++] = len - 1;
ctx[index++] = instru.chip_id;
for (int i=freq_lv_from; i<=freq_lv_to; i++) {
ctx[index++] = (uint8_t)(CaliTable.phase[3][i].coeff >> 24);
ctx[index++] = (uint8_t)(CaliTable.phase[3][i].coeff >> 16);
ctx[index++] = (uint8_t)(CaliTable.phase[3][i].coeff >> 8);
ctx[index++] = (uint8_t)(CaliTable.phase[3][i].coeff);
ctx[index++] = (uint8_t)(CaliTable.phase[3][i].offset >> 24);
ctx[index++] = (uint8_t)(CaliTable.phase[3][i].offset >> 16);
ctx[index++] = (uint8_t)(CaliTable.phase[3][i].offset >> 8);
ctx[index++] = (uint8_t)(CaliTable.phase[3][i].offset);
}
ctx[len-1] = check_sum(ctx, len);
SimpleProfile_SetParameter(BLE_CIS_BUFF_CHAR, CALI_SIZE, ctx);
return;
}
static void send_cali_gain4_hstia(void)
{
uint8_t len = CALI_SIZE;
uint8_t ctx[CALI_SIZE] = {0};
uint8_t index = 0;
ctx[index++] = len - 1;
ctx[index++] = instru.chip_id;
ctx[index++] = (uint8_t)(CaliTable.hstia_current[4][0].hstia_a >> 24);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[4][0].hstia_a >> 16);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[4][0].hstia_a >> 8);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[4][0].hstia_a);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[4][0].hstia_b >> 56);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[4][0].hstia_b >> 48);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[4][0].hstia_b >> 40);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[4][0].hstia_b >> 32);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[4][0].hstia_b >> 24);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[4][0].hstia_b >> 16);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[4][0].hstia_b >> 8);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[4][0].hstia_b);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[4][0].rolloff >> 24);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[4][0].rolloff >> 16);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[4][0].rolloff >> 8);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[4][0].rolloff);
ctx[len-1] = check_sum(ctx, len);
SimpleProfile_SetParameter(BLE_CIS_BUFF_CHAR, CALI_SIZE, ctx);
return;
}
static void send_cali_gain4_phase_freq0_freq1(void)
{
uint8_t len = CALI_SIZE;
uint8_t ctx[CALI_SIZE] = {0};
uint8_t index = 0;
uint8_t freq_lv_from = 0;
uint8_t freq_lv_to = 1;
ctx[index++] = len - 1;
ctx[index++] = instru.chip_id;
for (int i=freq_lv_from; i<=freq_lv_to; i++) {
ctx[index++] = (uint8_t)(CaliTable.phase[4][i].coeff >> 24);
ctx[index++] = (uint8_t)(CaliTable.phase[4][i].coeff >> 16);
ctx[index++] = (uint8_t)(CaliTable.phase[4][i].coeff >> 8);
ctx[index++] = (uint8_t)(CaliTable.phase[4][i].coeff);
ctx[index++] = (uint8_t)(CaliTable.phase[4][i].offset >> 24);
ctx[index++] = (uint8_t)(CaliTable.phase[4][i].offset >> 16);
ctx[index++] = (uint8_t)(CaliTable.phase[4][i].offset >> 8);
ctx[index++] = (uint8_t)(CaliTable.phase[4][i].offset);
}
ctx[len-1] = check_sum(ctx, len);
SimpleProfile_SetParameter(BLE_CIS_BUFF_CHAR, CALI_SIZE, ctx);
return;
}
static void send_cali_gain4_phase_freq2_freq3(void)
{
uint8_t len = CALI_SIZE;
uint8_t ctx[CALI_SIZE] = {0};
uint8_t index = 0;
uint8_t freq_lv_from = 2;
uint8_t freq_lv_to = 3;
ctx[index++] = len - 1;
ctx[index++] = instru.chip_id;
for (int i=freq_lv_from; i<=freq_lv_to; i++) {
ctx[index++] = (uint8_t)(CaliTable.phase[4][i].coeff >> 24);
ctx[index++] = (uint8_t)(CaliTable.phase[4][i].coeff >> 16);
ctx[index++] = (uint8_t)(CaliTable.phase[4][i].coeff >> 8);
ctx[index++] = (uint8_t)(CaliTable.phase[4][i].coeff);
ctx[index++] = (uint8_t)(CaliTable.phase[4][i].offset >> 24);
ctx[index++] = (uint8_t)(CaliTable.phase[4][i].offset >> 16);
ctx[index++] = (uint8_t)(CaliTable.phase[4][i].offset >> 8);
ctx[index++] = (uint8_t)(CaliTable.phase[4][i].offset);
}
ctx[len-1] = check_sum(ctx, len);
SimpleProfile_SetParameter(BLE_CIS_BUFF_CHAR, CALI_SIZE, ctx);
return;
}
static void send_cali_gain5_hstia(void)
{
uint8_t len = CALI_SIZE;
uint8_t ctx[CALI_SIZE] = {0};
uint8_t index = 0;
ctx[index++] = len - 1;
ctx[index++] = instru.chip_id;
ctx[index++] = (uint8_t)(CaliTable.hstia_current[5][0].hstia_a >> 24);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[5][0].hstia_a >> 16);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[5][0].hstia_a >> 8);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[5][0].hstia_a);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[5][0].hstia_b >> 56);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[5][0].hstia_b >> 48);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[5][0].hstia_b >> 40);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[5][0].hstia_b >> 32);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[5][0].hstia_b >> 24);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[5][0].hstia_b >> 16);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[5][0].hstia_b >> 8);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[5][0].hstia_b);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[5][0].rolloff >> 24);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[5][0].rolloff >> 16);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[5][0].rolloff >> 8);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[5][0].rolloff);
ctx[len-1] = check_sum(ctx, len);
SimpleProfile_SetParameter(BLE_CIS_BUFF_CHAR, CALI_SIZE, ctx);
return;
}
static void send_cali_gain5_phase_freq0_freq1(void)
{
uint8_t len = CALI_SIZE;
uint8_t ctx[CALI_SIZE] = {0};
uint8_t index = 0;
uint8_t freq_lv_from = 0;
uint8_t freq_lv_to = 1;
ctx[index++] = len - 1;
ctx[index++] = instru.chip_id;
for (int i=freq_lv_from; i<=freq_lv_to; i++) {
ctx[index++] = (uint8_t)(CaliTable.phase[5][i].coeff >> 24);
ctx[index++] = (uint8_t)(CaliTable.phase[5][i].coeff >> 16);
ctx[index++] = (uint8_t)(CaliTable.phase[5][i].coeff >> 8);
ctx[index++] = (uint8_t)(CaliTable.phase[5][i].coeff);
ctx[index++] = (uint8_t)(CaliTable.phase[5][i].offset >> 24);
ctx[index++] = (uint8_t)(CaliTable.phase[5][i].offset >> 16);
ctx[index++] = (uint8_t)(CaliTable.phase[5][i].offset >> 8);
ctx[index++] = (uint8_t)(CaliTable.phase[5][i].offset);
}
ctx[len-1] = check_sum(ctx, len);
SimpleProfile_SetParameter(BLE_CIS_BUFF_CHAR, CALI_SIZE, ctx);
return;
}
static void send_cali_gain5_phase_freq2_freq3(void)
{
uint8_t len = CALI_SIZE;
uint8_t ctx[CALI_SIZE] = {0};
uint8_t index = 0;
uint8_t freq_lv_from = 2;
uint8_t freq_lv_to = 3;
ctx[index++] = len - 1;
ctx[index++] = instru.chip_id;
for (int i=freq_lv_from; i<=freq_lv_to; i++) {
ctx[index++] = (uint8_t)(CaliTable.phase[5][i].coeff >> 24);
ctx[index++] = (uint8_t)(CaliTable.phase[5][i].coeff >> 16);
ctx[index++] = (uint8_t)(CaliTable.phase[5][i].coeff >> 8);
ctx[index++] = (uint8_t)(CaliTable.phase[5][i].coeff);
ctx[index++] = (uint8_t)(CaliTable.phase[5][i].offset >> 24);
ctx[index++] = (uint8_t)(CaliTable.phase[5][i].offset >> 16);
ctx[index++] = (uint8_t)(CaliTable.phase[5][i].offset >> 8);
ctx[index++] = (uint8_t)(CaliTable.phase[5][i].offset);
}
ctx[len-1] = check_sum(ctx, len);
SimpleProfile_SetParameter(BLE_CIS_BUFF_CHAR, CALI_SIZE, ctx);
return;
}
static void send_cali_gain6_hstia(void)
{
uint8_t len = CALI_SIZE;
uint8_t ctx[CALI_SIZE] = {0};
uint8_t index = 0;
ctx[index++] = len - 1;
ctx[index++] = instru.chip_id;
ctx[index++] = (uint8_t)(CaliTable.hstia_current[6][0].hstia_a >> 24);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[6][0].hstia_a >> 16);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[6][0].hstia_a >> 8);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[6][0].hstia_a);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[6][0].hstia_b >> 56);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[6][0].hstia_b >> 48);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[6][0].hstia_b >> 40);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[6][0].hstia_b >> 32);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[6][0].hstia_b >> 24);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[6][0].hstia_b >> 16);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[6][0].hstia_b >> 8);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[6][0].hstia_b);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[6][0].rolloff >> 24);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[6][0].rolloff >> 16);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[6][0].rolloff >> 8);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[6][0].rolloff);
ctx[len-1] = check_sum(ctx, len);
SimpleProfile_SetParameter(BLE_CIS_BUFF_CHAR, CALI_SIZE, ctx);
return;
}
static void send_cali_gain6_phase_freq0_freq1(void)
{
uint8_t len = CALI_SIZE;
uint8_t ctx[CALI_SIZE] = {0};
uint8_t index = 0;
uint8_t freq_lv_from = 0;
uint8_t freq_lv_to = 1;
ctx[index++] = len - 1;
ctx[index++] = instru.chip_id;
for (int i=freq_lv_from; i<=freq_lv_to; i++) {
ctx[index++] = (uint8_t)(CaliTable.phase[6][i].coeff >> 24);
ctx[index++] = (uint8_t)(CaliTable.phase[6][i].coeff >> 16);
ctx[index++] = (uint8_t)(CaliTable.phase[6][i].coeff >> 8);
ctx[index++] = (uint8_t)(CaliTable.phase[6][i].coeff);
ctx[index++] = (uint8_t)(CaliTable.phase[6][i].offset >> 24);
ctx[index++] = (uint8_t)(CaliTable.phase[6][i].offset >> 16);
ctx[index++] = (uint8_t)(CaliTable.phase[6][i].offset >> 8);
ctx[index++] = (uint8_t)(CaliTable.phase[6][i].offset);
}
ctx[len-1] = check_sum(ctx, len);
SimpleProfile_SetParameter(BLE_CIS_BUFF_CHAR, CALI_SIZE, ctx);
return;
}
static void send_cali_gain6_phase_freq2_freq3(void)
{
uint8_t len = CALI_SIZE;
uint8_t ctx[CALI_SIZE] = {0};
uint8_t index = 0;
uint8_t freq_lv_from = 2;
uint8_t freq_lv_to = 3;
ctx[index++] = len - 1;
ctx[index++] = instru.chip_id;
for (int i=freq_lv_from; i<=freq_lv_to; i++) {
ctx[index++] = (uint8_t)(CaliTable.phase[6][i].coeff >> 24);
ctx[index++] = (uint8_t)(CaliTable.phase[6][i].coeff >> 16);
ctx[index++] = (uint8_t)(CaliTable.phase[6][i].coeff >> 8);
ctx[index++] = (uint8_t)(CaliTable.phase[6][i].coeff);
ctx[index++] = (uint8_t)(CaliTable.phase[6][i].offset >> 24);
ctx[index++] = (uint8_t)(CaliTable.phase[6][i].offset >> 16);
ctx[index++] = (uint8_t)(CaliTable.phase[6][i].offset >> 8);
ctx[index++] = (uint8_t)(CaliTable.phase[6][i].offset);
}
ctx[len-1] = check_sum(ctx, len);
SimpleProfile_SetParameter(BLE_CIS_BUFF_CHAR, CALI_SIZE, ctx);
return;
}
static void send_cali_gain7_hstia(void)
{
uint8_t len = CALI_SIZE;
uint8_t ctx[CALI_SIZE] = {0};
uint8_t index = 0;
ctx[index++] = len - 1;
ctx[index++] = instru.chip_id;
ctx[index++] = (uint8_t)(CaliTable.hstia_current[7][0].hstia_a >> 24);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[7][0].hstia_a >> 16);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[7][0].hstia_a >> 8);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[7][0].hstia_a);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[7][0].hstia_b >> 56);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[7][0].hstia_b >> 48);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[7][0].hstia_b >> 40);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[7][0].hstia_b >> 32);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[7][0].hstia_b >> 24);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[7][0].hstia_b >> 16);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[7][0].hstia_b >> 8);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[7][0].hstia_b);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[7][0].rolloff >> 24);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[7][0].rolloff >> 16);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[7][0].rolloff >> 8);
ctx[index++] = (uint8_t)(CaliTable.hstia_current[7][0].rolloff);
ctx[len-1] = check_sum(ctx, len);
SimpleProfile_SetParameter(BLE_CIS_BUFF_CHAR, CALI_SIZE, ctx);
return;
}
static void send_cali_gain7_phase_freq0_freq1(void)
{
uint8_t len = CALI_SIZE;
uint8_t ctx[CALI_SIZE] = {0};
uint8_t index = 0;
uint8_t freq_lv_from = 0;
uint8_t freq_lv_to = 1;
ctx[index++] = len - 1;
ctx[index++] = instru.chip_id;
for (int i=freq_lv_from; i<=freq_lv_to; i++) {
ctx[index++] = (uint8_t)(CaliTable.phase[7][i].coeff >> 24);
ctx[index++] = (uint8_t)(CaliTable.phase[7][i].coeff >> 16);
ctx[index++] = (uint8_t)(CaliTable.phase[7][i].coeff >> 8);
ctx[index++] = (uint8_t)(CaliTable.phase[7][i].coeff);
ctx[index++] = (uint8_t)(CaliTable.phase[7][i].offset >> 24);
ctx[index++] = (uint8_t)(CaliTable.phase[7][i].offset >> 16);
ctx[index++] = (uint8_t)(CaliTable.phase[7][i].offset >> 8);
ctx[index++] = (uint8_t)(CaliTable.phase[7][i].offset);
}
ctx[len-1] = check_sum(ctx, len);
SimpleProfile_SetParameter(BLE_CIS_BUFF_CHAR, CALI_SIZE, ctx);
return;
}
static void send_cali_gain7_phase_freq2_freq3(void)
{
uint8_t len = CALI_SIZE;
uint8_t ctx[CALI_SIZE] = {0};
uint8_t index = 0;
uint8_t freq_lv_from = 2;
uint8_t freq_lv_to = 3;
ctx[index++] = len - 1;
ctx[index++] = instru.chip_id;
for (int i=freq_lv_from; i<=freq_lv_to; i++) {
ctx[index++] = (uint8_t)(CaliTable.phase[7][i].coeff >> 24);
ctx[index++] = (uint8_t)(CaliTable.phase[7][i].coeff >> 16);
ctx[index++] = (uint8_t)(CaliTable.phase[7][i].coeff >> 8);
ctx[index++] = (uint8_t)(CaliTable.phase[7][i].coeff);
ctx[index++] = (uint8_t)(CaliTable.phase[7][i].offset >> 24);
ctx[index++] = (uint8_t)(CaliTable.phase[7][i].offset >> 16);
ctx[index++] = (uint8_t)(CaliTable.phase[7][i].offset >> 8);
ctx[index++] = (uint8_t)(CaliTable.phase[7][i].offset);
}
ctx[len-1] = check_sum(ctx, len);
SimpleProfile_SetParameter(BLE_CIS_BUFF_CHAR, CALI_SIZE, ctx);
return;
}
@@ -1,809 +0,0 @@
#ifndef HEADSTAGE_H
#define HEADSTAGE_H
#include <driverlib/timer.h>
#include <ti/drivers/SPI.h>
#include <ti/drivers/dma/UDMACC26XX.h>
#include <ti/drivers/spi/SPICC26XXDMA.h>
#include <ti/drivers/timer/GPTimerCC26XX.h>
#include <ti/sysbios/BIOS.h>
#include <ti/sysbios/knl/Semaphore.h>
#include <xdc/runtime/Timestamp.h>
#include <xdc/runtime/Types.h>
#include <stdbool.h>
#include <ti/sysbios/knl/Clock.h>
#include <ti/sysbios/hal/Hwi.h>
#include <ti/sysbios/knl/Queue.h>
#ifdef ICALL_EVENTS
#include <ti/sysbios/knl/Event.h>
#else //! ICALL_EVENTS
#include <ti/sysbios/knl/Semaphore.h>
#endif // ICALL_EVENTS
#ifdef USE_ICALL
#include <icall.h>
#else
#include <stdlib.h>
#endif
#include "bcomdef.h"
#include "simple_gatt_profile.h"
/*===================================
==== headstage general variable ====
==================================*/
enum send_ins_para_order_e {
PARA_1 = 0x01,
PARA_2 = 0x02,
PARA_3 = 0x03,
PARA_4 = 0x04,
PARA_5 = 0x05,
PARA_6 = 0x06,
PARA_7 = 0x07,
PARA_8 = 0x08,
PARA_9 = 0x09,
PARA_10 = 0x0A,
PARA_11 = 0x0B,
PARA_12 = 0x0C,
PARA_13 = 0x0D,
PARA_14 = 0x0E,
PARA_15 = 0x0F,
PARA_16 = 0x10,
PARA_17 = 0x11,
PARA_FINAL = 0xFF,
};
#define UC_TO_5NV(_v) (_v - 25000) * 4 * 10000; //userode to 5nv per unit
#include "Elite_def.h"
#include "EliteWorkData.h"
/**
* application use instruction receive buffer.
* the length equals to the characteristic 3 which value is 12 bytes.
*/
static uint8_t ins_buf[BLE_INS_BUFF_SIZE] = {0};
static uint8_t not_buf[BLE_DAT_BUFF_SIZE] = {0};
static uint8_t cis_buf[BLE_CIS_BUFF_SIZE] = {0};
static bool PeriodicEvent = false;
static bool InitPeriodicEvent = true;
static bool megaStiEnable = false;
/*=====================================
==== headstage function prototype ====
====================================*/
/**
* ZM function
*/
static uint32_t VsetRateTable[5] = {2, 10, 100, 1000, 10000}; //0.2ms
static bool batteryCheck_flag;
static bool batteryADC_flag;
static bool notify_flag;
static bool record_flag;
static bool vscanReset;
static bool mode_init;
static bool fout_flag;
static bool gainChange_flag;
static bool firstFreq_flag;
//pulse mode variable
static int16_t I_GAIN_100R_counter;
static int16_t I_GAIN_3K_counter;
static int16_t I_GAIN_100K_counter;
static int16_t I_GAIN_3M_counter;
static int16_t VIN_GAIN_1M_counter;
static int16_t VIN_GAIN_30K_counter;
static int16_t VIN_GAIN_1K_counter;
static int16_t VOUT_GAIN_240K_counter;
static int16_t VOUT_GAIN_15K_counter;
static uint8_t lastVinADCGainLv;
static uint8_t lastIinADCGainLevel;
static uint8_t last_gain_lptia;
static uint8_t last_gain_hstia;
static void VinADCGainCtrl(uint8_t VinADCLevel);
static void VoutGainControl(uint8_t VOUTLevel);
static void PIN15_setOutputValue (uint32_t latch_num, uint32_t pin_num, bool highlow);
// Elite key detection & turn on/ shutdown function (peripheral hardware control)
static void ModeLED(uint16_t modeStatus);
// periodic event control
static void EliteADCControl(void);
// static void cv_vscan(void);
// static void ca_vscan(void);
// static void rt_vscan(void);
static void mode_done(void);
//mode (DAC)
static void DACenable(uint8_t afterRead);
static void freq_out();
static void vscan_volt_out(void);
static uint32_t User2Freq(uint32_t UserCode);
static int32_t neg_18bit(int32_t ret);
//mode (notify)
// static void initDATBuf();
#include "EliteInstruction.h"
#include "EliteADC.h"
#include "EliteDAC.h"
#include "EliteSPI.h"
#include "board.h"
#include "EliteNotify.h"
#include "AD5940.h"
#include "EliteReset.h"
#include "EliteLED.h"
#include "Elite_mode_ADC_DAC.h"
#include "mode_ca.h"
#include "mode_vt.h"
#include "mode_rt.h"
#include "mode_cv.h"
#include "mode_eis.h"
#include "mode_cf.h"
#include "impedance_meter.h"
#include "Elite_version.h"
#include "eis_cali_cis.h"
static void decode_ris_ins(uint8 *ins)
{
switch (ins[2]) {
case CURVE_EIS:
decode_eis_mode(ins);
break;
case CURVE_CV:
decode_cv_mode(ins);
break;
case CURVE_CA:
decode_ca_mode(ins);
break;
case CURVE_VT:
decode_vt_mode(ins);
break;
case CURVE_RT:
decode_rt_mode(ins);
break;
case CURVE_CF:
decode_cf_mode(ins);
break;
case 0xE2:{ //SET_PARA: { 0xE2
if (ins[3] == 0x01) {
int32_t volt;
volt = (int32_t)ins[4] << 8 | (int32_t)ins[5];
set_rt_volt(volt);
} else if (ins[3] == 0x02) {
struct wm_cf_ctx_t *cf = (struct wm_cf_ctx_t *)wm_get();
cf->_amp = (uint16_t)ins[4] << 8 | (uint16_t)ins[5]; //0~2047
SetWGAmp(cf->_amp,instru.fset);
DAC_outputF(Freq2DAC(instru.fset)); //[10mHz->Reg's]
fset_flag = true;
}
break;
}
case SET_SAMPLE_RATE: {
instru.notifyRate = (uint32_t)ins[3] << 8 | (uint32_t)ins[4];
instru.notifyRate = 10000 / instru.notifyRate * 10;
break;
}
case 0xFF: { // 0x3000FF DEV_MODE
switch (ins[3]) {
case 0x01: {
uint8_t ctx[BLE_CIS_BUFF_SIZE] = {0};
uint8_t len = BLE_CIS_BUFF_SIZE;
ctx[0] = len-1;
ctx[1] = 0xFF;
ctx[2] = NotifyVoltBat[0];
ctx[3] = NotifyVoltBat[1];
ctx[4] = NotifyVoltBat[2];
ctx[5] = NotifyVoltBat[3];
ctx[6] = 0x00;
SimpleProfile_SetParameter(BLE_CIS_BUFF_CHAR, BLE_CIS_BUFF_SIZE, ctx);
break;
}
case 0x03: { // ble write: 0x3000FF 03
if (ins[4] == 1) {
led_color_set(LED_NB_MAX, LED_BR_LV1, LED_CLR_RED);
} else if (ins[4] == 2){
led_color_set(LED_NB_MAX, LED_BR_LV1, LED_CLR_ORANGE);
} else if (ins[4] == 3){
led_color_set(LED_NB_MAX, LED_BR_LV1, LED_CLR_YELLOW);
} else if (ins[4] == 4){
led_color_set(LED_NB_MAX, LED_BR_LV1, LED_CLR_GREEN);
} else if (ins[4] == 5){
led_color_set(LED_NB_MAX, LED_BR_LV1, LED_CLR_BLUE);
} else if (ins[4] == 6){
led_color_set(LED_NB_MAX, LED_BR_LV1, LED_CLR_MAGENTA);
} else if (ins[4] == 7){
led_color_set(LED_NB_MAX, LED_BR_LV1, LED_CLR_RED);
}
break;
}
case 0x70: { // SET_GENERAL_HS_RTIA
instru.gain_lv_hstia = ins[4];
if (instru.gain_lv_hstia < HSRTIA_MAX) {
instru.HSTIAAutoGainEnable = 0;
HSTIAGainCtrl(instru.gain_lv_hstia);
} else {
instru.HSTIAAutoGainEnable = 1;
instru.gain_lv_hstia = HSRTIA_200R;
HSTIAGainCtrl(instru.gain_lv_hstia);
}
break;
}
case 0x71: { // SET_GENERAL_LP_RTIA
instru.gain_lv_lptia = ins[4];
if (instru.gain_lv_lptia != I_GAIN_AUTO) {
instru.LPTIAAutoGainEnable = 0;
} else {
instru.LPTIAAutoGainEnable = 1;
instru.gain_lv_lptia = LPRTIA_200R;
LPTIAGainCtrl(instru.gain_lv_lptia);
}
break;
}
case 0x72 : { //HIGH_Z
SetEISHIGHZ(ins[4]); //0:open CE0, 1:close CE0
break;
}
case 0x73: { // to reset hstia gain when using error gain
instru.HSTIAAutoGainEnable = 1;
instru.gain_lv_hstia = HSRTIA_200R;
HSTIAGainCtrl(instru.gain_lv_hstia);
break;
}
case 0x74: { //roy test
set_ca_volt(ins);
break;
}
case 0x75: { //roy test
static uint16_t user_volt = 0;
user_volt = (uint16_t)ins[4] << 8 | (uint16_t)ins[5];
int32_t LPvolt = (user_volt - 25000) * 4 * 4000; //[5nV]
DAC_outputV(LPvolt);
break;
}
case 0x76: { //roy test
setEIS_EIS_cali();
break;
}
case 0x77: { //roy test
setEIS_CV();
break;
}
// 0xF0 ~ 0xF3 are cali mode function
case 0xF0: { //cali DAC, set AC dcbias & acamp & freq //no long use
uint8_t use_cali = ins[12];
instru.gain_lv_hstia = HSRTIA_200R;
instru.dcbias = (uint16_t)ins[4] << 8 | (uint16_t)ins[5];
instru.acamp = (uint16_t)ins[6] << 8 | (uint16_t)ins[7];
instru.fset = (uint32_t)ins[8] << 24 | (uint32_t)ins[9] << 16 | (uint32_t)ins[10] << 8 | (uint32_t)ins[11];
instru.fset = User2Freq(instru.fset);
if (use_cali == 0) {
setEIS_EIS_cali();
DAC_outputF(Freq2DAC(instru.fset)); //[10mHz->Reg's]
led_color_set(LED_NB_MAX, LED_BR_LV1, LED_CLR_PURPLE);
SetEISHIGHZ(1);
}
break;
}
case 0xF1: { //cali DAC, set DC offset //no long use
instru.gain_lv_hstia = HSRTIA_200R;
instru.dcbias = (uint16_t)ins[4] << 8 | (uint16_t)ins[5];
instru.acamp = 0x0000;
instru.fset = 0x0000;
uint8_t use_cali = ins[6];
if (use_cali == 0) {
setEIS_EIS_cali();
freq_out();
led_color_set(LED_NB_MAX, LED_BR_LV1, LED_CLR_PURPLE);
}
break;
}
case 0xF2: { //change LPTIA gain
instru.gain_lv_lptia = ins[4];
LPTIAGainCtrl(instru.gain_lv_lptia);
break;
}
case 0xF3: { //LPDAC volt output
static uint16_t user_volt = 0;
user_volt = (uint16_t)ins[4] << 8 | (uint16_t)ins[5];
int32_t LPvolt = (user_volt - 25000) * 4 * 4000; //[5nV]
led_color_set(LED_NB_MAX, LED_BR_LV1, LED_CLR_PURPLE);
setEIS_CV();
DAC_outputV(LPvolt);
break;
}
case 0xF4: { //read ADCDAT data
uint8_t ctx[BLE_CIS_BUFF_SIZE] = {0};
uint8_t len = BLE_CIS_BUFF_SIZE;
uint32_t rd;
rd = AD5940_SPIReadReg(ADCDAT);
ctx[0] = len-1;
ctx[1] = (uint8_t)((ADCDAT & 0xFF00) >> 8);
ctx[2] = (uint8_t)(ADCDAT & 0x00FF);
ctx[3] = (uint8_t)(rd >> 24);
ctx[4] = (uint8_t)(rd >> 16);
ctx[5] = (uint8_t)(rd >> 8);
ctx[6] = (uint8_t)rd;
SimpleProfile_SetParameter(BLE_CIS_BUFF_CHAR, BLE_CIS_BUFF_SIZE, ctx);
break;
}
case 0xF7: { //cali DAC: set nzero & nbias & acamp & freq
uint8_t ctx[BLE_CIS_BUFF_SIZE] = {0};
uint8_t len = BLE_CIS_BUFF_SIZE;
uint32_t DACOutCode;
uint16_t n_bias = (uint16_t)ins[4] << 8 | (uint16_t)ins[5];
uint16_t n_zero = (uint16_t)ins[6] << 8 | (uint16_t)ins[7];
instru.acamp = (uint16_t)ins[8] << 8 | (uint16_t)ins[9];
instru.fset = (uint32_t)ins[10] << 24 | (uint32_t)ins[11] << 16 | (uint32_t)ins[12] << 8 | (uint32_t)ins[13];
instru.gain_lv_hstia = HSRTIA_200R;
if(n_bias > 4095) n_bias = 4095;
if(n_zero > 63) n_zero = 63;
DACOutCode = (0x0003FFFF & ((n_zero << 12) + n_bias));
set_hs_only();
if (instru.gain_lv_hstia < HSRTIA_MAX) {
instru.HSTIAAutoGainEnable = 0;
HSTIAGainCtrl(instru.gain_lv_hstia);
} else {
instru.HSTIAAutoGainEnable = 1;
instru.gain_lv_hstia = HSRTIA_200R;
HSTIAGainCtrl(instru.gain_lv_hstia);
}
AD5940_SPIWriteReg(LPDACDAT0, DACOutCode);
AD5940_SPIWriteReg(WGFCW, instru.fset);
AD5940_SPIWriteReg(WGCON, 0x0); // 0x0: DC disable ac first
AD5940_SPIWriteReg(WGAMPLITUDE, instru.acamp);
AD5940_SPIWriteReg(WGCON, 0x00000004); //0x4: Sinusoid
led_color_set(LED_NB_MAX, LED_BR_LV1, LED_CLR_PURPLE);
SetEISHIGHZ(1);
ctx[0] = len-1;
ctx[1] = 0xF7;
ctx[2] = ins[4];
ctx[3] = ins[5];
ctx[4] = ins[6];
ctx[5] = ins[7];
SimpleProfile_SetParameter(BLE_CIS_BUFF_CHAR, BLE_CIS_BUFF_SIZE, ctx);
break;
}
case 0xF8: { //cali DAC: set dcbias & acamp & freq
uint8_t ctx[BLE_CIS_BUFF_SIZE] = {0};
uint8_t len = BLE_CIS_BUFF_SIZE;
uint8_t cali_amp;
instru.dcbias = (uint16_t)ins[4] << 8 | (uint16_t)ins[5];
instru.acamp = (uint16_t)ins[8] << 8 | (uint16_t)ins[9];
instru.fset = (uint32_t)ins[10] << 24 | (uint32_t)ins[11] << 16 | (uint32_t)ins[12] << 8 | (uint32_t)ins[13];
cali_amp = ins[14]; //cali_amp=0:after cali, cali_amp=1:before cali
instru.gain_lv_hstia = HSRTIA_200R;
set_hs_only();
//change gain
if (instru.gain_lv_hstia < HSRTIA_MAX) {
instru.HSTIAAutoGainEnable = 0;
HSTIAGainCtrl(instru.gain_lv_hstia);
} else {
instru.HSTIAAutoGainEnable = 1;
instru.gain_lv_hstia = HSRTIA_200R;
HSTIAGainCtrl(instru.gain_lv_hstia);
}
//set DCbias
HSDAC_outputV((int32_t)instru.dcbias);
//set freq
AD5940_SPIWriteReg(WGFCW, instru.fset);
//set amp
if (cali_amp == 0) {
SetWGAmp(instru.acamp,instru.fset);
} else {
AD5940_SPIWriteReg(WGCON, 0x0); // 0x0: DC disable ac first
AD5940_SPIWriteReg(WGAMPLITUDE, instru.acamp);
AD5940_SPIWriteReg(WGCON, 0x00000004); //0x4: Sinusoid
}
led_color_set(LED_NB_MAX, LED_BR_LV1, LED_CLR_PURPLE);
SetEISHIGHZ(1);
ctx[0] = 6;
ctx[1] = 0xF7;
ctx[2] = ins[4];
ctx[3] = ins[5];
ctx[4] = ins[6];
ctx[5] = ins[7];
SimpleProfile_SetParameter(BLE_CIS_BUFF_CHAR, BLE_CIS_BUFF_SIZE, ctx);
break;
}
case 0xFD: { // ble write: 0x3000FF 20FFFFFFFFFFFF CTL_WRT //0x20->0xfd
uint8_t ctx[BLE_CIS_BUFF_SIZE] = {0};
uint8_t len = BLE_CIS_BUFF_SIZE;
uint16_t address = (uint16_t)ins[4] << 8 | (uint16_t)ins[5];
uint32_t data = (uint32_t)ins[6] << 24 | (uint32_t)ins[7] << 16 |
(uint32_t)ins[8] << 8 | (uint32_t)ins[9];
AD5940_SPIWriteReg(address, data);
ctx[0] = 6;
ctx[1] = (uint8_t)(address >> 8);
ctx[2] = (uint8_t)(address);
ctx[3] = (uint8_t)(data >> 24);
ctx[4] = (uint8_t)(data >> 16);
ctx[5] = (uint8_t)(data >> 8);
ctx[6] = (uint8_t)(data);
SimpleProfile_SetParameter(BLE_CIS_BUFF_CHAR, BLE_CIS_BUFF_SIZE, ctx);
break;
}
case 0xFE: { // ble write: 0x3000FF 21FFFF CTL_RD //0x21->0xfe
uint8_t ctx[BLE_CIS_BUFF_SIZE] = {0};
uint8_t len = BLE_CIS_BUFF_SIZE;
uint16_t address = (uint16_t)ins[4] << 8 | (uint16_t)ins[5];
uint32_t rd;
rd = AD5940_SPIReadReg(address);
ctx[0] = 6;
ctx[1] = (uint8_t)(address >> 8);
ctx[2] = (uint8_t)(address);
ctx[3] = (uint8_t)(rd >> 24);
ctx[4] = (uint8_t)(rd >> 16);
ctx[5] = (uint8_t)(rd >> 8);
ctx[6] = (uint8_t)rd;
SimpleProfile_SetParameter(BLE_CIS_BUFF_CHAR, BLE_CIS_BUFF_SIZE, ctx);
break;
}
case 0xFF: { //UI write: 11 CTL_RESET //0x11->0xff
AD5940_HWReset();
AD5940_Initialize();
led_color_set(LED_NB_MAX, LED_BR_LV1, LED_CLR_GREEN);
break;
}
// case 0x13: { //HIGH_Z
// SetEISHIGHZ(ins[4]); //0:open highz, CE0 no output
// break;
// }
// case 0x18: {
// uint16_t b;
// uint8_t z;
// z = ins[4];
// b = (uint16_t)ins[5] << 8 | (uint16_t)ins[6];
// set_lpdac_ce_1100mv(z, b);
// break;
// }
// case 0xF4: { //debug function: fixed DC voltage
// instru.Vinit = (int32_t)ins[4] << 8 | (int32_t)ins[5];
// instru.Vinit = (instru.Vinit - 25000) * 4 * 4000; //[5nV]
// setEIS_CV();
// DAC_outputV(instru.Vinit);
// led_color_set(LED_NB_MAX, LED_BR_LV1, LED_CLR_BLUE);
// break;
// }
}
break;
}
default:
break;
}
}
static void decode_vis_ins(uint8 *ins)
{
uint8_t oper = ins[1] & 0xF0; // this is don't care in RISASD;//
switch (oper) {
// reset all variables ( Ins = 0xC0F0)
case VIS_RST: {
instru.eliteFxn = VIS_RST;
reset();
break;
}
case VIS_STI: {
for(int i = 0; i < 12; i++) {
FlushNotify();
}
PeriodicEvent = true;
InitPeriodicEvent = true; // need to create a WorkModeData?
mode_init = true;
break;
}
case VIS_INT: {
reset();
for (int i = 0; i < 12; i++) {
FlushNotify();
}
break;
}
case VIS_DEVICE_SHINY: { //detect
led_color_set(LED_NB_MAX, LED_BR_LV1, LED_CLR_MAGENTA);
// uint8_t deviceShinySwitch = (ins[2] & 0b11110000) >> 4;//1:open 0:close
// if(deviceShinySwitch == 1){
// led_color_set(LED_NB_MAX, LED_BR_LV1, LED_CLR_MAGENTA);
// }else if(deviceShinySwitch == 0){
// if(PeriodicEvent){
// led_color_set(LED_NB_MAX, LED_BR_LV1, LED_CLR_CYAN);
// }else if(!PeriodicEvent){
// led_color_set(LED_NB_MAX, LED_BR_LV1, LED_CLR_GREEN);
// }
// }
break;
}
case VIS_SHINY_DIS: {
if (PeriodicEvent) {
led_color_set(LED_NB_MAX, LED_BR_LV1, LED_CLR_CYAN);
} else if (!PeriodicEvent) {
led_color_set(LED_NB_MAX, LED_BR_LV1, LED_CLR_GREEN);
}
break;
}
default: {
break;
}
}
return;
}
static void decode_cis_ins(uint8 *ins)
{
uint8_t oper = ins[1] & 0xF0;
switch (oper) {
case CIS_VERSION: {
uint8_t ctx[BLE_CIS_BUFF_SIZE] = {0};
uint8_t len = BLE_CIS_BUFF_SIZE;
ctx[0] = 6;
ctx[1] = CIS_VERSION;
ctx[2] = VERSION_DATE_YEAR;
ctx[3] = VERSION_DATE_MONTH;
ctx[4] = VERSION_DATE_DAY;
ctx[5] = VERSION_DATE_HOUR;
ctx[6] = VERSION_DATE_MINUTE;
SimpleProfile_SetParameter(BLE_CIS_BUFF_CHAR, BLE_CIS_BUFF_SIZE, ctx);
break;
}
case CIS_VOLT: {
uint8_t ctx[BLE_CIS_BUFF_SIZE] = {0};
uint8_t len = BLE_CIS_BUFF_SIZE;
ctx[0] = 3;
ctx[1] = CIS_VOLT;
ctx[2] = NotifyVoltBat[3];
ctx[3] = NotifyVoltBat[2];
SimpleProfile_SetParameter(BLE_CIS_BUFF_CHAR, BLE_CIS_BUFF_SIZE, ctx);
break;
}
case CIS_CALI: {
if (ins[2] == 0) {
send_cali_version();
} else if (ins[2] == 1) {
send_cali_gain0_hstia();
} else if (ins[2] == 2) {
send_cali_gain0_phase_freq0_freq1();
} else if (ins[2] == 3) {
send_cali_gain0_phase_freq2_freq3();
} else if (ins[2] == 4) {
send_cali_gain1_hstia();
} else if (ins[2] == 5) {
send_cali_gain1_phase_freq0_freq1();
} else if (ins[2] == 6) {
send_cali_gain1_phase_freq2_freq3();
} else if (ins[2] == 7) {
send_cali_gain2_hstia();
} else if (ins[2] == 8) {
send_cali_gain2_phase_freq0_freq1();
} else if (ins[2] == 9) {
send_cali_gain2_phase_freq2_freq3();
} else if (ins[2] == 10) {
send_cali_gain3_hstia();
} else if (ins[2] == 11) {
send_cali_gain3_phase_freq0_freq1();
} else if (ins[2] == 12) {
send_cali_gain3_phase_freq2_freq3();
} else if (ins[2] == 13) {
send_cali_gain4_hstia();
} else if (ins[2] == 14) {
send_cali_gain4_phase_freq0_freq1();
} else if (ins[2] == 15) {
send_cali_gain4_phase_freq2_freq3();
} else if (ins[2] == 16) {
send_cali_gain5_hstia();
} else if (ins[2] == 17) {
send_cali_gain5_phase_freq0_freq1();
} else if (ins[2] == 18) {
send_cali_gain5_phase_freq2_freq3();
} else if (ins[2] == 19) {
send_cali_gain6_hstia();
} else if (ins[2] == 20) {
send_cali_gain6_phase_freq0_freq1();
} else if (ins[2] == 21) {
send_cali_gain6_phase_freq2_freq3();
} else if (ins[2] == 22) {
send_cali_gain7_hstia();
} else if (ins[2] == 23) {
send_cali_gain7_phase_freq0_freq1();
} else if (ins[2] == 24) {
send_cali_gain7_phase_freq2_freq3();
}
break;
}
}
}
// update instruction for Z meter
static void update_ZM_instruction(uint8 *ins) {
uint8_t ins_type = ins[0] & 0b11110000;
instru.chip_id = ins[0] & 0b00001111;
switch (ins_type) {
case INS_TYPE_RIS:
decode_ris_ins(ins);
break;
case INS_TYPE_VIS:
decode_vis_ins(ins);
break;
case INS_TYPE_CIS:
decode_cis_ins(ins);
break;
}
return;
}
static void ZM_instruction_update_handle(uint8_t characteristic) {
switch (characteristic) {
case BLE_INS_BUFF_CHAR:
SimpleProfile_GetParameter(SIMPLEPROFILE_CHAR3, ins_buf);
update_ZM_instruction(ins_buf);
break;
default:
break;
}
}
#include "devinfoservice.h"
#include "gapgattserver.h"
#include "gattservapp.h"
struct date_t {
uint8_t year;
uint8_t month;
uint8_t day;
};
struct device_info_t {
struct date_t date;
};
struct device_info_t device_info;
void get_date(struct date_t *date)
{
const char *months[12] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
"Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
struct date_t *d = date;
char year_s[5] = {0};
char month_s[4] = {0};
char day_s[3] = {0};
int i;
char date_now[] = __DATE__;
memcpy(year_s, date_now + 9, 2);
memcpy(month_s, date_now, 3);
memcpy(day_s, date_now + 4, 2);
d->year = atoi(year_s);
d->day = atoi(day_s);
for (i=0; i<12; i++) {
if (!strcmp(month_s, months[i])) {
d->month = i + 1;
break;
}
}
return;
}
static void headstage_init_device_info() {
uint8_t scanRspData[64] = {9};
uint8_t *p = scanRspData;
struct device_info_t *dev = &device_info;
int i;
get_date(&device_info.date);
*p++ = sizeof(DEVICE_NAME); // 10
*p++ = GAP_ADTYPE_LOCAL_NAME_COMPLETE; // 09
for (i=0; i<sizeof(DEVICE_NAME)-1; i++) {
*p++ = DEVICE_NAME[i];
} // 69 108 105 116 101 45 69 73 83
*p++ = 16; // 16
*p++ = GAP_ADTYPE_MANUFACTURER_SPECIFIC; // 255
*p++ = 'B'; // 66
*p++ = 'P'; // 80
*p++ = 'H'; // 72
*p++ = 'S'; // 83
*p++ = MAJOR_PRODUCT_NUMBER; // 0
*p++ = MINOR_PRODUCT_NUMBER; // 4
*p++ = MAJOR_VERSION_NUMBER; // 1
*p++ = MINOR_VERSION_NUMBER; // 0
*p++ = dev->date.year; // 22
*p++ = dev->date.month; // 07
*p++ = 'B'; // 66
*p++ = 'A'; // 65
*p++ = 'T'; // 84
*p++ = NotifyVoltBat[3]; // 44
*p++ = NotifyVoltBat[2]; // 33
GGS_SetParameter(GGS_DEVICE_NAME_ATT, sizeof(DEVICE_NAME), DEVICE_NAME);
GAPRole_SetParameter(GAPROLE_SCAN_RSP_DATA, p - scanRspData, scanRspData);
}
#endif // HEADSTAGE_H
@@ -1,307 +0,0 @@
/*
* impedance_meter.h
*
* Created on: 2019/01/15
* Author: benny
*/
#ifndef HEADSTAGE_H
#error "headstage.h not include"
#endif
#ifdef HEADSTAGE_H_H
#error "headstage_*.h has be included"
#endif
#ifndef IMPEDANCE_METER_H_
#define HEADSTAGE_H_H
#define IMPEDANCE_METER_H_
// header
#include "EliteWorkData.h"
static bool vscan_flag;
static bool ADC_flag;
static bool notifyFirst_flag;
static bool leadTimeReset;
static bool firstTimeReset;
static bool fset_flag;
static void vscan_ctrl(void);
#define IsPeriodicMode() ( \
instru.eliteFxn == CURVE_EIS || \
instru.eliteFxn == CURVE_CF || \
instru.eliteFxn == CURVE_CV || \
instru.eliteFxn == CURVE_CA || \
instru.eliteFxn == CURVE_VT || \
instru.eliteFxn == CURVE_RT \
)
#define Ve1MatchVe2Mode() ( \
(instru.eliteFxn == CURVE_EIS) || \
(instru.eliteFxn == CURVE_CF) || \
(instru.eliteFxn == CURVE_CV) \
)
/*********************************************************************
* @fn SimpleBLEPeripheral_performPeriodicTask
*
* @brief Control periodic event such as DAC out, ADC read, and send notify.
*
* @param None.
*
* @return None.
*/
static void elite_task()
{
if (IsPeriodicMode()) {
if((instru.eliteFxn == CURVE_EIS) || (instru.eliteFxn == CURVE_CF)){
if (mode_init){
GPT.cnt_adc_rate = 0;
mode_init = false;
gainChange_flag = false;
firstFreq_flag = true;
fset_flag = true;
fout_flag = true;
firstTimeReset = true;
notifyFirst_flag = true;
DACReset = true;
vscanReset = true;
leadTimeReset = true;
if ((instru.f1 == instru.f2) && (instru.eliteFxn == CURVE_EIS)) {
DAC_outputF(instru.f1);
PeriodicEvent = false;
ModeLED(NO_EVENT);
}
SetEISHIGHZ(1);
InitGPT();
}
//vscan counter //fset counter
if (fset_flag) {
vscan_ctrl(); //set
fset_flag = false;
fout_flag = true;
}
//ADC counter
GPT.cnt_adc_rate = GPT.cnt_adc_rate + GPT.cnt_gpt_delta;
if(GPT.cnt_adc_rate >= instru.sampleRate){
GPT.cnt_adc_rate = 0; //To get right data, ADC must be delay 1.5ms
ADC_flag = true;
if(ADC_flag){
EliteADCControl(); //read data
ADC_flag = false;
}
}
//Notify counter(Notify control, check if we need to send notify)
//please don't put Notify counter before ADC counter, maybe get wrong data
if(vscanReset){
notify_flag = false;
}
if(notify_flag){
SendNotify(); //send
notify_flag = false;
fset_flag = true;
}
mode_done(); //finishMode = 1, SendNotify(), reset()
} else {
/** Periodic Event **/
// Default working flow is vscan -> ADC read -> send notify
// We will need a flag to control vscan, ADC and notify
static bool first_highz_flag = false;
if (mode_init) {
GPT.cnt_adc_rate = instru.sampleRate - 10;
GPT.cnt_v_scan_rate = instru.VsetRate - 1;
mode_init = false;
batteryADC_flag = false;
record_flag = true;
fset_flag = true;
firstTimeReset = true;
notifyFirst_flag = true;
first_highz_flag = true;
I_GAIN_100R_counter = 0;
I_GAIN_3K_counter = 0;
I_GAIN_100K_counter = 0;
I_GAIN_3M_counter = 0;
VIN_GAIN_1M_counter = 0;
VIN_GAIN_30K_counter = 0;
VIN_GAIN_1K_counter = 0;
VOUT_GAIN_240K_counter = 0;
VOUT_GAIN_15K_counter = 0;
DACReset = true;
vscanReset = true;
leadTimeReset = true;
if (Ve1MatchVe2Mode()) {
if (instru.Ve1 == instru.Ve2) {
DAC_outputV(instru.Ve1);
PeriodicEvent = false;
SetEISHIGHZ(1);
ModeLED(NO_EVENT);
}
}
InitGPT();
}
GPT.cnt_lead_time = GPT.cnt_lead_time + GPT.cnt_gpt_delta;
if (leadTimeReset && GPT.cnt_lead_time <= 2000) {
vscanReset = true;
if (first_highz_flag && GPT.cnt_lead_time >= 1000) {
SetEISHIGHZ(1); // // High Z | 1 off | 0 on
first_highz_flag = false;
}
} else {
if (notifyFirst_flag) {
GPT.cnt_notify_rate = instru.notifyRate - 20;
notifyFirst_flag = false;
}
vscanReset = false;
leadTimeReset = false;
}
//vscan counter //fset counter
GPT.cnt_v_scan_rate = GPT.cnt_v_scan_rate + GPT.cnt_gpt_delta;
if (GPT.cnt_v_scan_rate >= instru.VsetRate) {
if (GPT.cnt_v_scan_rate >= instru.VsetRate * 2) {
GPT.GptimerMultiple = GPT.cnt_v_scan_rate / instru.VsetRate;
} else {
GPT.GptimerMultiple = 1;
}
GPT.cnt_v_scan_rate -= instru.VsetRate * GPT.GptimerMultiple; //To get right time
vscan_flag = true;
if (vscan_flag) {
vscan_ctrl(); //set
vscan_volt_out();
vscan_flag = false;
}
}
//ADC counter
GPT.cnt_adc_rate = GPT.cnt_adc_rate + GPT.cnt_gpt_delta;
if(GPT.cnt_adc_rate >= instru.sampleRate){
GPT.cnt_adc_rate = 0; //To get right data, ADC must be delay 1.5ms
ADC_flag = true;
if(ADC_flag){
EliteADCControl(); //read data
ADC_flag = false;
}
}
//Notify counter(Notify control, check if we need to send notify)
//please don't put Notify counter before ADC counter, maybe get wrong data
GPT.cnt_notify_rate = GPT.cnt_notify_rate + GPT.cnt_gpt_delta;
if(GPT.cnt_notify_rate >= instru.notifyRate){
GPT.cnt_notify_rate -= instru.notifyRate; //To get right time
notify_flag = true;
if(vscanReset){
notify_flag = false;
}
if(notify_flag){
SendNotify(); //send
notify_flag = false;
}
}
mode_done(); //finishMode = 1, SendNotify(), reset()
}
}
}
static void EliteADCControl(void) //CURVE_IV => CC_Plot() | CURVE_CV => Iin_Vin_Vout_Plot
{
void *wm = wm_get();
switch (instru.eliteFxn) {
case CURVE_EIS:
gain = instru.gain_lv_hstia;
EIS_Plot();
break;
case CURVE_CF:
gain = instru.gain_lv_hstia;
CF_Plot();
break;
case CURVE_CV:
gain = instru.gain_lv_lptia;
CV_Plot();
break;
case CURVE_CA:
gain = instru.gain_lv_lptia;
CA_Plot();
break;
case CURVE_VT:
gain = instru.gain_lv_lptia;
VT_Plot();
break;
case CURVE_RT:
gain = instru.gain_lv_lptia;
RT_Plot();
break;
default:
break;
}
}
static void mode_done(void) //finishMode = 1, SendNotify(), reset()
{
if (instru.eliteFxn == CURVE_CV) {
if (!PeriodicEvent) {
finishMode = 1;
SendNotify();
reset();
}
} else if ((instru.eliteFxn == CURVE_EIS) || (instru.eliteFxn == CURVE_CF)){
if (!PeriodicEvent) {
reset();
}
}
}
static void vscan_ctrl(void)
{
switch (instru.eliteFxn) {
case CURVE_EIS:
eis_fscan();
break;
case CURVE_CF:
cf_fscan();
break;
case CURVE_CV:
cv_vscan();
break;
case CURVE_CA:
ca_vscan();
break;
case CURVE_RT:
rt_vscan();
break;
default:{
break;
}
}
}
#endif /* IMPEDANCE_METER_H_ */
@@ -1,69 +0,0 @@
#ifndef MODE_CA_H
#define MODE_CA_H
#ifdef __cplusplus
extern "C" {
#endif
static void decode_ca_mode(uint8 *ins)
{
instru.eliteFxn = CURVE_CA;
instru.Vinit = (int32_t)ins[3] << 8 | (int32_t)ins[4]; //37500
instru.notifyRate = (uint32_t)ins[7] << 8 | (uint32_t)ins[8]; //1000
instru.notifyRate = 10000 / instru.notifyRate * 10; //100
instru.VsetRate = VsetRateTable[0]; //2
//instru.hign_z_en = ins[6] & 0x0F;
//instru.VoutGainLv = VOUT_GAIN_240K;
setEIS_CV();
ModeLED(WORKING);
return;
}
static void ca_vscan(void)
{
struct wm_ca_ctx_t *ca = (struct wm_ca_ctx_t *)wm_get();
if(vscanReset){
instru.Vset = ca->_Vinit;
}
if(!vscanReset){
instru.Vset = ca->_Vinit;
}
return;
}
static void CA_Plot(void)
{
struct wm_ca_ctx_t *ca = (struct wm_ca_ctx_t *)wm_get();
static uint8_t ADC_cnt = 0;
void *wm = wm_get();
if (ADC_cnt == 0) {
LPTIA_change_gain();
ADC_cnt++;
} else if (ADC_cnt == 1) {
read_LPTIA_Iin();
ADC_cnt = 0;
}
return;
}
static void set_ca_volt(uint8 *ins)
{
struct wm_ca_ctx_t *ca = (struct wm_ca_ctx_t *)wm_get();
instru.Vinit = (int32_t)ins[4] << 8 | (int32_t)ins[5]; //37500
ca->_Vinit = (instru.Vinit - 25000) * 4 * 4000; //[5nV]
}
#ifdef __cplusplus
}
#endif
#endif // TIMERS_H
@@ -1,156 +0,0 @@
/***
DC Volt 0 mv
AC Amp 100 mv
Freq 200000Hz~0.1Hz
Points per decades 10 points
Point spacing Logarithm
Delay 0 points
Average 2
Current range Auto
[CC2650] att_write 360CD10100CB7355000000070000
[CC2650] att_write 360BD10261A801000004000A00
***/
#define DECODE_INS_1 0x01
#define DECODE_INS_2 0x02
#define DECODE_INS_MODE 0xFF
static void decode_cf_mode(uint8_t *instruction)
{
uint8_t *ins = instruction;
uint8_t ins_step = ins[3];
if (ins_step == DECODE_INS_1) {
instru.f1 = (uint32_t)ins[4] << 24 | (uint32_t)ins[5] << 16 | (uint32_t)ins[6] << 8 | (uint32_t)ins[7]; //FREQ_START //13333333
instru.delay = (uint16_t)ins[12] << 8 | (uint16_t)ins[13]; //DELAY/10 how many periods //0
return;
}
if (ins_step == DECODE_INS_2) {
instru.dcbias = (uint16_t)ins[4] << 8 | (uint16_t)ins[5]; //25000
instru.acamp = (uint16_t)ins[6] << 8 | (uint16_t)ins[7]; //256
instru.avgnum = (uint8_t)ins[8]; //0
instru.gain_lv_hstia = (uint8_t)ins[9]; //4 = HSRTIA_200R //0
return;
}
if (ins_step == DECODE_INS_MODE) {
instru.eliteFxn = CURVE_CF;
set_hs_only();
if (instru.gain_lv_hstia < HSRTIA_MAX) {
instru.HSTIAAutoGainEnable = 0;
HSTIAGainCtrl(instru.gain_lv_hstia);
} else {
instru.HSTIAAutoGainEnable = 1;
instru.gain_lv_hstia = HSRTIA_200R;
HSTIAGainCtrl(instru.gain_lv_hstia);
}
HSDAC_outputV(instru.dcbias);
AD5940_SPIWriteReg(WGFCW, instru.fset);
AD5940_SPIWriteReg(WGCON, 0x0); // 0x0: DC disable ac first
AD5940_SPIWriteReg(WGAMPLITUDE, instru.acamp);
AD5940_SPIWriteReg(WGCON, 0x00000004); //0x4: Sinusoid
ModeLED(WORKING);
return;
}
return;
}
static void cf_fscan(void)
{
struct wm_cf_ctx_t *cf = (struct wm_cf_ctx_t *)wm_get();
if (vscanReset) {
cf->_in_reset_flag = true;
cf->_f1 = User2Freq(cf->_f1);
instru.fset = cf->_f1;
vscanReset = false;
SetWGAmp(instru.acamp,instru.fset);
DAC_outputF(Freq2DAC(instru.fset)); //[10mHz->Reg's]
}
if (!vscanReset) {
instru.fset = cf->_f1;
}
SetSamplingTime(instru.fset);
instru.sampleRate = 2000;
}
static void CF_Plot(void) //real and imag impedance plot
{
static uint8_t avgNumTable[4] = {2, 4, 6, 8};
struct wm_cf_ctx_t *cf = (struct wm_cf_ctx_t *)wm_get();
static uint8_t ADC_cnt = 0;
static int32_t realSum, imagSum = 0;
int32_t avg_real, avg_imag = 0;
static uint8_t avg_count = 0;
void *wm = wm_get();
if (fout_flag){
EnDFTnADC(1);
instru.sampleRate = CalcDelayTime(instru.fset);
fout_flag = false;
if (cf->_in_reset_flag) {
avg_count = 0;
realSum = 0;
imagSum = 0;
ADC_cnt = 0;
cf->_in_reset_flag = false;
}
} else {
if (ADC_cnt == 0){
HSTIA_change_gain(); // ADC measure
if (gainChange_flag) {
gainChange_flag = false;
instru.sampleRate = CalcDelayTime(instru.fset);
instru.real = 0;
instru.imag = 0;
ADC_cnt = 0;
} else {
instru.sampleRate = 15;
ADC_cnt ++;
}
}
else if (ADC_cnt == 1) {
realSum += instru.real;
imagSum += instru.imag;
avg_count++;
instru.sampleRate = 15;
if (avg_count == avgNumTable[instru.avgnum]){
avg_real = realSum / avg_count;
avg_imag = imagSum / avg_count;
InputNotify(NOTIFY_CURRENT, avg_imag);
InputNotify(NOTIFY_VOLT, avg_real);
InputNotify(NOTIFY_IMPEDANCE, instru.fset);
NotifyCh4 = (uint32_t)cf->_amp * 1000 * 800 / 2047; //[uV]
EnDFTnADC(0);
avg_count = 0;
realSum = 0;
imagSum = 0;
notify_flag = true;
}
ADC_cnt = 0;
}
}
return;
}
@@ -1,175 +0,0 @@
static void step2VsetRate(uint32_t step){
/*step = 100 mv, index = 0, n = 2
10 mv, index = 1, n = 10
1 mv, index = 2, n = 100
0.1 mv, index = 3, n = 1000
0.01mv, index = 4, n = 10000 */
if(step >= 10000){
instru.VsetRateIndex = 0;
}else if (step >= 1000){
instru.VsetRateIndex = 1;
}else if (step >= 100){
instru.VsetRateIndex = 2;
}else if (step >= 10){
instru.VsetRateIndex = 3;
}else if (step >= 1){
instru.VsetRateIndex = 4;
}
}
#define STEP_TO_VSETRATE(step) step2VsetRate(step)
static void decode_cv_mode(uint8 *ins)
{
if (ins[3] == PARA_1) {
instru.Vinit = (int32_t)ins[4] << 8 | (int32_t)ins[5];
instru.Ve1 = (uint16_t)ins[6] << 8 | (uint16_t)ins[7];
instru.Ve2 = (uint16_t)ins[8] << 8 | (uint16_t)ins[9];
instru.Vmax = (int32_t)VMAX(instru.Ve1,instru.Ve2);
instru.Vmin = (int32_t)VMIN(instru.Ve1,instru.Ve2);
if (instru.Vinit > instru.Ve1 || instru.Vinit == instru.Vmax){
instru.directionInit = 0;//0:reverse 1:forward
} else if (instru.Vinit <= instru.Ve1 || instru.Vinit == instru.Vmin){
instru.directionInit = 1;
}
} else if (ins[3] == PARA_2) {
instru.eliteFxn = CURVE_CV;
instru.notifyRate = (uint32_t)ins[8] << 8 | (uint32_t)ins[9];
instru.notifyRate = 10000 / instru.notifyRate * 10;
//controller UI 0.01~1000mv send to Elite 1~100000
instru.step = (uint32_t)ins[4] << 24 | (uint32_t)ins[5] << 16 | (uint32_t)ins[6] << 8 | (uint32_t)ins[7];
STEP_TO_VSETRATE(instru.step); //step2VsetRate
instru.VsetRate = VsetRateTable[instru.VsetRateIndex];//N
instru.cycleNumber = (uint16_t)ins[10] << 8 | (uint16_t)ins[11];
setEIS_CV();
ModeLED(WORKING);
}
return;
}
static void cv_vscan(void)
{
struct wm_cv_ctx_t *cv = (struct wm_cv_ctx_t *)wm_get();
static bool VminCounter;
static bool VmaxCounter;
NotifyCycleNumber = (instru.cycleNumber - cv->_cycleNumber + 1);
if (vscanReset) {
VmaxCounter = false;
VminCounter = false;
if (instru.directionInit == 1) {
cv->_direction_up = true;
cv->_current_direction_up = true;
} else {
cv->_direction_up = false;
cv->_current_direction_up = false;
}
// Vstep = x * 20 * N, x=xmV ; N=VscanRate Vstep unit [5nV]/[0.1ms]
if (instru.step <= 10) {
cv->_Vstep = instru.step * instru.VsetRate / 5;
} else {
cv->_Vstep = instru.step / 5 * instru.VsetRate;
}
if (cv->_Vmin == cv->_Vinit) {
VminCounter = true;
}
if (cv->_Vmax == cv->_Vinit) {
VmaxCounter = true;
}
instru.Vset = cv->_Vinit;
}
if (!vscanReset) {
if ((instru.Vinit < instru.Ve1 && instru.Vinit < instru.Ve2) ||
(instru.Vinit > instru.Ve1 && instru.Vinit > instru.Ve2)
) {
if (cv->_current_direction_up) {
instru.Vset += cv->_Vstep; //* GPT.GptimerMultiple;
} else {
instru.Vset -= cv->_Vstep; //* GPT.GptimerMultiple;
}
if (instru.Vinit < instru.Ve1 && instru.Vinit < instru.Ve2) {
if (instru.Vset == cv->_Vmin) {
VminCounter = true;
instru.Vinit = instru.Vmin;
cv->_Vinit = cv->_Vmin;
}
} else if (instru.Vinit > instru.Ve1 && instru.Vinit > instru.Ve2) {
if (instru.Vset == cv->_Vmax) {
VmaxCounter = true;
instru.Vinit = instru.Vmax;
cv->_Vinit = cv->_Vmax;
}
}
} else {
if (instru.Vset >= cv->_Vmax) {
VmaxCounter = true;
} else if (instru.Vset <= cv->_Vmin) {
VminCounter = true;
}
if (cv->_current_direction_up) {
instru.Vset += cv->_Vstep;// * GPT.GptimerMultiple;
} else {
instru.Vset -= cv->_Vstep;// * GPT.GptimerMultiple;
}
if (VmaxCounter && VminCounter) {
if (cv->_direction_up && cv->_current_direction_up) {
if (instru.Vset >= cv->_Vinit) {
cv->_cycleNumber--;
VminCounter = false;
VmaxCounter = false;
}
}
if (!cv->_direction_up && !cv->_current_direction_up) {
if (instru.Vset <= cv->_Vinit) {
cv->_cycleNumber--;
VminCounter = false;
VmaxCounter = false;
}
}
}
if (instru.Vset >= cv->_Vmax) {
cv->_current_direction_up = false;
} else if (instru.Vset <= cv->_Vmin) {
cv->_current_direction_up = true;
}
/*stop condition*/
if (cv->_cycleNumber == 0) {
PeriodicEvent = false;
}
}
}
}
static void CV_Plot(void)
{
struct wm_cv_ctx_t *cv = (struct wm_cv_ctx_t *)wm_get();
static uint8_t ADC_cnt = 0;
void *wm = wm_get();
if (ADC_cnt == 0) {
LPTIA_change_gain();
ADC_cnt++;
} else if (ADC_cnt == 1) {
read_LPTIA_Iin();
ADC_cnt = 0;
}
return;
}
@@ -1,314 +0,0 @@
/***
DC Volt 0 mv
AC Amp 100 mv
Freq 200000Hz~0.1Hz
Points per decades 10 points
Point spacing Logarithm
Delay 0 points
Average 2
Current range Auto
[CC2650] att_write 360CD10100CB7355000000070000
[CC2650] att_write 360BD10261A801000004000A00
***/
#define DECODE_INS_1 0x01
#define DECODE_INS_2 0x02
#define DECODE_INS_MODE 0xFF
static void decode_eis_mode(uint8_t *instruction)
{
uint8_t *ins = instruction;
uint8_t ins_step = ins[3];
if (ins_step == DECODE_INS_1) {
instru.f1 = (uint32_t)ins[4] << 24 | (uint32_t)ins[5] << 16 | (uint32_t)ins[6] << 8 | (uint32_t)ins[7]; //FREQ_START //13333333
instru.f2 = (uint32_t)ins[8] << 24 | (uint32_t)ins[9] << 16 | (uint32_t)ins[10] << 8 | (uint32_t)ins[11]; //FREQ_STOP //7
//instru.sampleRate = 15;//CalcDelayTime(User2Freq(instru.f1), true); //ms //read
instru.fmax = (uint32_t)VMAX(instru.f1, instru.f2); //13333333
instru.fmin = (uint32_t)VMIN(instru.f1, instru.f2); //7
instru.delay = (uint16_t)ins[12] << 8 | (uint16_t)ins[13]; //DELAY/10 how many periods //0
if (instru.f1 > instru.f2)
instru.directionInit = 0; //0:reverse 1:forward //instru.directionInit = 0
else if (instru.f1 <= instru.f2)
instru.directionInit = 1;
return;
}
if (ins_step == DECODE_INS_2) {
instru.dcbias = (uint16_t)ins[4] << 8 | (uint16_t)ins[5]; //25000
instru.acamp = (uint16_t)ins[6] << 8 | (uint16_t)ins[7]; //256
instru.avgnum = (uint8_t)ins[8]; //0
instru.gain_lv_hstia = (uint8_t)ins[9]; //4 = HSRTIA_200R
instru.ppd = (uint16_t)ins[10] << 8 | (uint16_t)ins[11]; //10
instru.scale = (uint8_t)ins[12]; //0
return;
}
if (ins_step == DECODE_INS_MODE) {
instru.eliteFxn = CURVE_EIS;
set_hs_only();
if (instru.gain_lv_hstia < HSRTIA_MAX) {
instru.HSTIAAutoGainEnable = 0;
HSTIAGainCtrl(instru.gain_lv_hstia);
} else {
instru.HSTIAAutoGainEnable = 1;
instru.gain_lv_hstia = HSRTIA_200R;
HSTIAGainCtrl(instru.gain_lv_hstia);
}
HSDAC_outputV(instru.dcbias);
AD5940_SPIWriteReg(WGFCW, instru.fset);
AD5940_SPIWriteReg(WGCON, 0x0); // 0x0: DC disable ac first
AD5940_SPIWriteReg(WGAMPLITUDE, instru.acamp);
AD5940_SPIWriteReg(WGCON, 0x00000004); //0x4: Sinusoid
ModeLED(WORKING);
return;
}
return;
}
//////EIS PLOT RELATED FUNCTION START//////
static uint8_t CalcDecade(uint32_t f1, uint32_t f2)
{
uint8_t decades; //max is 7
decades = log10(f2/f1);
return decades;
}
static void eis_fscan(void)
{
struct wm_eis_ctx_t *eis = (struct wm_eis_ctx_t *)wm_get();
static uint16_t LogSpacingTable10[10] = {1000, 1292, 1668, 2154, 2783, 3594, 4642, 5995, 7743, 10000};
static uint16_t LogSpacingTable9[9] = {1000, 1334, 1778, 2371, 3162, 4217, 5623, 7499, 10000};
static uint16_t LogSpacingTable8[8] = {1000, 1389, 1931, 2683, 3728, 5179, 7197, 10000};
static uint16_t LogSpacingTable7[7] = {1000, 1468, 2154, 3162, 4642, 6813, 10000};
static uint16_t LogSpacingTable6[6] = {1000, 1585, 2512, 3981, 6310, 10000};
static uint16_t LogSpacingTable5[5] = {1000, 1778, 3162, 5623, 10000};
static uint16_t LogSpacingTable4[4] = {1000, 2154, 4642, 10000};
static uint16_t LogSpacingTable3[3] = {1000, 3162, 10000};
static uint16_t LogSpacingTable2[2] = {1000, 10000};
static uint32_t TenPowerTable[9] = {1, 10, 100, 1000, 10000, 100000, 1000000, 10000000};
if (vscanReset) {
eis->_in_reset_flag = true;
eis->_f1 = User2Freq(eis->_f1);
eis->_f2 = User2Freq(eis->_f2);
eis->_fmax = User2Freq(eis->_fmax);
eis->_fmin = User2Freq(eis->_fmin);
if (instru.directionInit == 1) {
eis->_direction_up = true;
} else if (instru.directionInit == 0) {
eis->_direction_up = false;
}
eis->_decades = CalcDecade(instru.fmin, instru.fmax);
instru.fset = eis->_f1;
vscanReset = false;
}
if (!vscanReset) {
if(eis->_direction_up) {
if(eis->_sweepIndex == 0){
if(eis->_decadeIndex < eis->_decades) {
eis->_fd1 = eis->_f1 * TenPowerTable[eis->_decadeIndex];
eis->_fd2 = eis->_f1 * TenPowerTable[eis->_decadeIndex + 1];
} else if (eis->_decadeIndex == eis->_decades) {
eis->_fd1 = eis->_fd2;//eis->_f1 * TenPowerTable[decadeIndex];
eis->_fd2 = eis->_fmax;
}
}
if(eis->_decadeIndex != 0 && eis->_sweepIndex == 0){
eis->_sweepIndex++;
}
if(instru.scale == 0) { // logarithm
if (eis->_ppd == 10) {
instru.fset = ((uint64_t)eis->_fd1 * LogSpacingTable10[eis->_sweepIndex] + 500)/ 1000;
}
else if (eis->_ppd == 9){
instru.fset = ((uint64_t)eis->_fd1 * LogSpacingTable9[eis->_sweepIndex] + 500)/ 1000;
}
else if (eis->_ppd == 8) {
instru.fset = ((uint64_t)eis->_fd1 * LogSpacingTable8[eis->_sweepIndex] + 500)/ 1000;
}
else if (eis->_ppd == 7) {
instru.fset = ((uint64_t)eis->_fd1 * LogSpacingTable7[eis->_sweepIndex] + 500)/ 1000;
}
else if (eis->_ppd == 6) {
instru.fset = ((uint64_t)eis->_fd1 * LogSpacingTable6[eis->_sweepIndex] + 500)/ 1000;
}
else if (eis->_ppd == 5) {
instru.fset = ((uint64_t)eis->_fd1 * LogSpacingTable5[eis->_sweepIndex] + 500)/ 1000;
}
else if (eis->_ppd == 4) {
instru.fset = ((uint64_t)eis->_fd1 * LogSpacingTable4[eis->_sweepIndex] + 500)/ 1000;
}
else if (eis->_ppd == 3) {
instru.fset = ((uint64_t)eis->_fd1 * LogSpacingTable3[eis->_sweepIndex] + 500)/ 1000;
}
else if (eis->_ppd == 2) {
instru.fset = ((uint64_t)eis->_fd1 * LogSpacingTable2[eis->_sweepIndex] + 500)/ 1000;
}
}
else if (instru.scale == 1) { // linear
instru.fset = eis->_fd1 + eis->_sweepIndex * ((eis->_fd2 - eis->_fd1) / (eis->_ppd - 1));
}
if(instru.fset > eis->_fmax){
instru.fset = eis->_fmax;
}
} else { //reverse
if(eis->_sweepIndex == 0){
if(eis->_decadeIndex < eis->_decades){
eis->_fd1 = eis->_f1 / TenPowerTable[eis->_decadeIndex];
eis->_fd2 = eis->_f1 / TenPowerTable[eis->_decadeIndex + 1];
} else if (eis->_decadeIndex == eis->_decades){
eis->_fd1 = eis->_fd2; //eis->_f1 / TenPowerTable[eis->_decadeIndex];
eis->_fd2 = eis->_fmin;
}
}
if(eis->_decadeIndex != 0 && eis->_sweepIndex == 0){
eis->_sweepIndex++;
}
if(instru.scale == 0) { // logarithm
if (eis->_ppd == 10) {
instru.fset = ((uint64_t)eis->_fd1 * LogSpacingTable10[9 - eis->_sweepIndex] + 5000)/ 10000;
}
else if (eis->_ppd == 9) {
instru.fset = ((uint64_t)eis->_fd1 * LogSpacingTable9[8 - eis->_sweepIndex] + 5000)/ 10000;
}
else if (eis->_ppd == 8) {
instru.fset = ((uint64_t)eis->_fd1 * LogSpacingTable8[7 - eis->_sweepIndex] + 5000)/ 10000;
}
else if (eis->_ppd == 7) {
instru.fset = ((uint64_t)eis->_fd1 * LogSpacingTable7[6 - eis->_sweepIndex] + 5000)/ 10000;
}
else if (eis->_ppd == 6) {
instru.fset = ((uint64_t)eis->_fd1 * LogSpacingTable6[5 - eis->_sweepIndex] + 5000)/ 10000;
}
else if (eis->_ppd == 5) {
instru.fset = ((uint64_t)eis->_fd1 * LogSpacingTable5[4 - eis->_sweepIndex] + 5000)/ 10000;
}
else if (eis->_ppd == 4) {
instru.fset = ((uint64_t)eis->_fd1 * LogSpacingTable4[3 - eis->_sweepIndex] + 5000)/ 10000;
}
else if (eis->_ppd == 3) {
instru.fset = ((uint64_t)eis->_fd1 * LogSpacingTable3[2 - eis->_sweepIndex] + 5000)/ 10000;
}
else if (eis->_ppd == 2) {
instru.fset = ((uint64_t)eis->_fd1 * LogSpacingTable2[1 - eis->_sweepIndex] + 5000)/ 10000;
}
}
else if(instru.scale == 1) { // linear
instru.fset = eis->_fd1 - eis->_sweepIndex * ((eis->_fd1 - eis->_fd2) / (eis->_ppd - 1));
}
if(instru.fset < eis->_fmin){
instru.fset = eis->_fmin;
}
}
if (!gainChange_flag) {
if (++eis->_sweepIndex == eis->_ppd) {
eis->_sweepIndex = 0;
eis->_decadeIndex ++;
}
}
}
SetSamplingTime(instru.fset);
instru.sampleRate = 2000;
}
static void EIS_Plot(void) //real and imag impedance plot
{
static uint8_t avgNumTable[4] = {2, 4, 6, 8};
struct wm_eis_ctx_t *eis = (struct wm_eis_ctx_t *)wm_get();
static uint8_t ADC_cnt = 0;
static int32_t realSum, imagSum = 0;
int32_t avg_real, avg_imag = 0;
static uint8_t avg_count = 0;
void *wm = wm_get();
if (fout_flag){
SetWGAmp(instru.acamp,instru.fset);
DAC_outputF(Freq2DAC(instru.fset)); //[10mHz->Reg's]
EnDFTnADC(1);
instru.sampleRate = CalcDelayTime(instru.fset);
fout_flag = false;
if (eis->_in_reset_flag) {
avg_count = 0;
realSum = 0;
imagSum = 0;
ADC_cnt = 0;
eis->_in_reset_flag = false;
}
} else {
if (ADC_cnt == 0){
HSTIA_change_gain(); // ADC measure
if (gainChange_flag) {
gainChange_flag = false;
instru.sampleRate = CalcDelayTime(instru.fset);
instru.real = 0;
instru.imag = 0;
ADC_cnt = 0;
} else {
instru.sampleRate = 15;
ADC_cnt ++;
}
}
else if (ADC_cnt == 1) {
realSum += instru.real;
imagSum += instru.imag;
avg_count++;
instru.sampleRate = 15;
if (avg_count == avgNumTable[instru.avgnum]){
avg_real = realSum / avg_count;
avg_imag = imagSum / avg_count;
InputNotify(NOTIFY_CURRENT, avg_imag);
InputNotify(NOTIFY_VOLT, avg_real);
InputNotify(NOTIFY_IMPEDANCE, instru.fset);
NotifyCh4 = (uint32_t)eis->_amp * 1000 * 800 / 2047; //[uV]
if(eis->_direction_up){
if (instru.fset >= eis->_fmax) {
PeriodicEvent = false;
finishMode = 1;
}
} else {
if (instru.fset <= eis->_fmin) {
PeriodicEvent = false;
finishMode = 1;
}
}
EnDFTnADC(0);
avg_count = 0;
realSum = 0;
imagSum = 0;
notify_flag = true;
}
ADC_cnt = 0;
}
}
return;
}
@@ -1,78 +0,0 @@
static void decode_rt_mode(uint8 *ins)
{
instru.eliteFxn = CURVE_RT;
instru.notifyRate = (uint32_t)ins[7] << 8 | (uint32_t)ins[8];
instru.notifyRate = 10000 / instru.notifyRate * 10;
// instru.notifyRate = 100;
// instru.measure_vin_range = ins[7];
// instru.measure_vin_range = 0;
setEIS_CV();
instru.Vinit = (uint32_t)ins[3] << 8 | (uint32_t)ins[4];
ModeLED(WORKING);
return;
}
static void CalcuResistance(int32_t Iin)
{
/* Elite 100000 = 100R
Elite 1000000 = 1KR
Elite 10000000 = 10KR
Elite 100000000 = 100KR
Elite 1000000000 = 1MR
*/
struct wm_rt_ctx_t *rt = (struct wm_rt_ctx_t *)wm_get();
int64_t resist;
int64_t volt = instru.Vset / 200; // [uV]
int64_t current = Iin;
resist = volt * 1000000 / current; //R = V / Iin; [mOhm]
InputNotify(NOTIFY_IMPEDANCE, resist);
}
static void RT_Plot(void)
{
struct wm_rt_ctx_t *rt = (struct wm_rt_ctx_t *)wm_get();
static uint8_t ADC_cnt = 0;
void *wm = wm_get();
if (ADC_cnt == 0) {
LPTIA_change_gain();
ADC_cnt++;
} else if (ADC_cnt == 1) {
int32_t Iin = read_LPTIA_Iin();
CalcuResistance(Iin);
ADC_cnt = 0;
}
return;
}
static void rt_vscan(void)
{
struct wm_rt_ctx_t *rt = (struct wm_rt_ctx_t *)wm_get();
if(vscanReset){
instru.Vset = rt->_Vinit;
}
if(!vscanReset){
instru.Vset = rt->_Vinit;
}
return;
}
static void set_rt_volt(int32_t volt)
{
struct wm_rt_ctx_t *rt = (struct wm_rt_ctx_t *)wm_get();
volt = (volt - 25000) * 4 * 4000;
rt->_Vinit = volt;
return;
}
@@ -1,47 +0,0 @@
static void decode_vt_mode(uint8 *ins)
{
instru.eliteFxn = CURVE_VT;
instru.notifyRate = (uint32_t)ins[5] << 8 | (uint32_t)ins[6];
instru.notifyRate = 10000 / instru.notifyRate * 10;
instru.measure_vin_range = ins[7];
setEIS_CV();
AD5940_SPIWriteReg(ADCCON, 0x0001080E); //PGA = 1.5 //VT
uint8_t z;
uint16_t b;
if (instru.measure_vin_range == 0) { //measure +volt
z = 0;
b = 0;
} else if (instru.measure_vin_range == 1) { //measure +-1V
z = 32;
b = 2048;
} else if (instru.measure_vin_range == 2) { //measure -volt
z = 62;
b = 3910;
}
set_lpdac_ce_1100mv(z, b);
disconnect_rtia();
ModeLED(WORKING);
return;
}
static void VT_Plot(void)
{
struct wm_ca_ctx_t *ca = (struct wm_ca_ctx_t *)wm_get();
static uint8_t ADC_cnt = 0;
void *wm = wm_get();
if (ADC_cnt == 0) {
// LPTIA_change_gain();
ADC_cnt++;
} else if (ADC_cnt == 1) {
read_LPTIA_Vin();
ADC_cnt = 0;
}
return;
}
@@ -1,33 +0,0 @@
# $python .\simplelink\ble_sdk_2_02_02_25\src\examples\simple_peripheral\cc26xx\app\python\update_elite_version.py
import datetime
import os
print(datetime.datetime.now())
# print(datetime.datetime.now().year)
# print(datetime.datetime.now().month)
# print(datetime.datetime.now().day)
# print(datetime.datetime.now().hour)
# print(datetime.datetime.now().minute)
# print(datetime.datetime.now().strftime("%H:%M:%S"))
y = datetime.datetime.now().year % 100
m = datetime.datetime.now().month
d = datetime.datetime.now().day
hour = datetime.datetime.now().hour
minute = datetime.datetime.now().minute
path = os.getcwd()
path += '/simplelink/ble_sdk_2_02_02_25/src/examples/simple_peripheral/cc26xx/app/headstage/Elite_version.h'
print('save:', path)
with open(path, 'w') as f:
f.write('#ifndef VERSION_DATE\t\t' + '\n')
f.write('#define VERSION_DATE\t\t' + '\n\n')
f.write('#define VERSION_DATE_YEAR\t\t' + str(y) + '\n')
f.write('#define VERSION_DATE_MONTH\t\t' + str(m) + '\n')
f.write('#define VERSION_DATE_DAY\t\t' + str(d) + '\n')
f.write('#define VERSION_DATE_HOUR\t\t' + str(hour) + '\n')
f.write('#define VERSION_DATE_MINUTE\t\t' + str(minute) + '\n')
f.write('#endif' + '\n\n')
@@ -9,7 +9,7 @@
Target Device: CC2650, CC2640
******************************************************************************
Copyright (c) 2013-2018, Texas Instruments Incorporated
All rights reserved.
@@ -105,11 +105,11 @@
#ifndef FEATURE_OAD
// Minimum connection interval (units of 1.25ms, 80=100ms) if automatic
// parameter update request is enabled
#define DEFAULT_DESIRED_MIN_CONN_INTERVAL 6 //ori:80
#define DEFAULT_DESIRED_MIN_CONN_INTERVAL 80
// Maximum connection interval (units of 1.25ms, 800=1000ms) if automatic
// parameter update request is enabled
#define DEFAULT_DESIRED_MAX_CONN_INTERVAL 6 //ori:800
#define DEFAULT_DESIRED_MAX_CONN_INTERVAL 800
#else //!FEATURE_OAD
// Minimum connection interval (units of 1.25ms, 8=10ms) if automatic
// parameter update request is enabled
@@ -147,7 +147,7 @@
#ifndef SBP_TASK_STACK_SIZE
#define SBP_TASK_STACK_SIZE 844 //ori:644
#define SBP_TASK_STACK_SIZE 644
#endif
// Internal Events for RTOS application
@@ -155,7 +155,6 @@
#define SBP_CHAR_CHANGE_EVT 0x0002
#define SBP_PERIODIC_EVT 0x0004
#define SBP_CONN_EVT_END_EVT 0x0008
#define SBP_KEY_CHANGE_EVT 0x0010
/*********************************************************************
* TYPEDEFS
@@ -182,7 +181,7 @@ typedef struct
static ICall_EntityID selfEntity;
// Semaphore globally used to post events to the application thread
static ICall_Semaphore semaphore;
static ICall_Semaphore sem;
// Clock instances for internal periodic events.
static Clock_Struct periodicClock;
@@ -208,7 +207,6 @@ Char sbpTaskStack[SBP_TASK_STACK_SIZE];
//static gaprole_States_t gapProfileState = GAPROLE_INIT;
// GAP - SCAN RSP data (max size = 31 bytes)
/*
static uint8_t scanRspData[] =
{
// complete name
@@ -247,7 +245,6 @@ static uint8_t scanRspData[] =
GAP_ADTYPE_POWER_LEVEL,
0 // 0dBm
};
*/
// GAP - Advertisement data (max size = 31 bytes, though this is
// best kept short to conserve power while advertisting)
@@ -279,7 +276,7 @@ static uint8_t advertData[] =
};
// GAP GATT Attributes
// static uint8_t attDeviceName[GAP_DEVICE_NAME_LEN] = "Simple BLE Peripheral";
static uint8_t attDeviceName[GAP_DEVICE_NAME_LEN] = "Simple BLE Peripheral";
// Globals used for ATT Response retransmission
static gattMsgEvent_t *pAttRsp = NULL;
@@ -296,9 +293,9 @@ static uint8_t SimpleBLEPeripheral_processStackMsg(ICall_Hdr *pMsg);
static uint8_t SimpleBLEPeripheral_processGATTMsg(gattMsgEvent_t *pMsg);
static void SimpleBLEPeripheral_processAppMsg(sbpEvt_t *pMsg);
static void SimpleBLEPeripheral_processStateChangeEvt(gaprole_States_t newState);
// static void SimpleBLEPeripheral_processCharValueChangeEvt(uint8_t paramID);
static void SimpleBLEPeripheral_processCharValueChangeEvt(uint8_t paramID);
static void SimpleBLEPeripheral_performPeriodicTask(void);
// static void SimpleBLEPeripheral_clockHandler(UArg arg);
static void SimpleBLEPeripheral_clockHandler(UArg arg);
static void SimpleBLEPeripheral_sendAttRsp(void);
static void SimpleBLEPeripheral_freeAttRsp(uint8_t status);
@@ -396,7 +393,7 @@ static void SimpleBLEPeripheral_init(void)
// ******************************************************************
// Register the current thread as an ICall dispatcher application
// so that the application can send and receive messages.
ICall_registerApp(&selfEntity, &semaphore);
ICall_registerApp(&selfEntity, &sem);
#ifdef USE_RCOSC
RCOSC_enableCalibration();
@@ -424,8 +421,8 @@ static void SimpleBLEPeripheral_init(void)
appMsgQueue = Util_constructQueue(&appMsg);
// Create one-shot clocks for internal periodic events.
// Util_constructClock(&periodicClock, SimpleBLEPeripheral_clockHandler,
// SBP_PERIODIC_EVT_PERIOD, 0, false, SBP_PERIODIC_EVT);
Util_constructClock(&periodicClock, SimpleBLEPeripheral_clockHandler,
SBP_PERIODIC_EVT_PERIOD, 0, false, SBP_PERIODIC_EVT);
// dispHandle = Display_open(Display_Type_LCD, NULL);
@@ -454,8 +451,8 @@ static void SimpleBLEPeripheral_init(void)
GAPRole_SetParameter(GAPROLE_ADVERT_OFF_TIME, sizeof(uint16_t),
&advertOffTime);
// GAPRole_SetParameter(GAPROLE_SCAN_RSP_DATA, sizeof(scanRspData),
// scanRspData);
GAPRole_SetParameter(GAPROLE_SCAN_RSP_DATA, sizeof(scanRspData),
scanRspData);
GAPRole_SetParameter(GAPROLE_ADVERT_DATA, sizeof(advertData), advertData);
GAPRole_SetParameter(GAPROLE_PARAM_UPDATE_ENABLE, sizeof(uint8_t),
@@ -471,7 +468,7 @@ static void SimpleBLEPeripheral_init(void)
}
// Set the GAP Characteristics
// GGS_SetParameter(GGS_DEVICE_NAME_ATT, GAP_DEVICE_NAME_LEN, attDeviceName);
GGS_SetParameter(GGS_DEVICE_NAME_ATT, GAP_DEVICE_NAME_LEN, attDeviceName);
// Set advertising interval
{
@@ -524,18 +521,18 @@ static void SimpleBLEPeripheral_init(void)
{
uint8_t charValue1 = 1;
uint8_t charValue2 = 2;
uint8_t charValue3[SIMPLEPROFILE_CHAR3_LEN] = {0};
uint8_t charValue4[SIMPLEPROFILE_CHAR4_LEN] = {0};
uint8_t charValue3 = 3;
uint8_t charValue4 = 4;
uint8_t charValue5[SIMPLEPROFILE_CHAR5_LEN] = { 1, 2, 3, 4, 5 };
SimpleProfile_SetParameter(SIMPLEPROFILE_CHAR1, sizeof(uint8_t),
&charValue1);
SimpleProfile_SetParameter(SIMPLEPROFILE_CHAR2, sizeof(uint8_t),
&charValue2);
SimpleProfile_SetParameter(SIMPLEPROFILE_CHAR3, SIMPLEPROFILE_CHAR3_LEN,
charValue3);
SimpleProfile_SetParameter(SIMPLEPROFILE_CHAR4, SIMPLEPROFILE_CHAR4_LEN,
charValue4);
SimpleProfile_SetParameter(SIMPLEPROFILE_CHAR3, sizeof(uint8_t),
&charValue3);
SimpleProfile_SetParameter(SIMPLEPROFILE_CHAR4, sizeof(uint8_t),
&charValue4);
SimpleProfile_SetParameter(SIMPLEPROFILE_CHAR5, SIMPLEPROFILE_CHAR5_LEN,
charValue5);
}
@@ -557,7 +554,6 @@ static void SimpleBLEPeripheral_init(void)
GATT_RegisterForMsgs(selfEntity);
HCI_LE_ReadMaxDataLenCmd();
/*
#if defined FEATURE_OAD
#if defined (HAL_IMAGE_A)
@@ -571,130 +567,6 @@ static void SimpleBLEPeripheral_init(void)
*/
}
// buffer size
#define BLE_CIS_BUFF_CHAR SIMPLEPROFILE_CHAR2
#define BLE_INS_BUFF_CHAR SIMPLEPROFILE_CHAR3
#define BLE_DAT_BUFF_CHAR SIMPLEPROFILE_CHAR4
#define BLE_CIS_BUFF_SIZE SIMPLEPROFILE_CHAR2_LEN
#define BLE_INS_BUFF_SIZE SIMPLEPROFILE_CHAR3_LEN
#define BLE_DAT_BUFF_SIZE SIMPLEPROFILE_CHAR4_LEN
// define for futher convention usage
//
#define REVERT_2_BYTE(_b) ((_b) >> 8 | (((_b) & 0xFF) << 8))
#define ENABLE 1
#define DISABLE 0
//
#include "driver/spi_ctrl.h"
#include "hardware/led_APA_102.h"
#include "driver/timers.h"
#include "elite_task/elite_GPtimer.h"
#if (DEF_ELITE_MODEL == DEF_ELITE_EIS_11)
#include "driver/gpio_eis11.h"
#elif (DEF_ELITE_MODEL == DEF_ELITE_EIS_MINI_10)
#include "driver/gpio_eis_mini10.h"
#endif
#include "hardware/chip_ad5940.h"
struct gptimer0_t GPT;
void elite_gptimer_task(void)
{
events |= SBP_PERIODIC_EVT;
Semaphore_post(semaphore);
GPT.cnt_gpt++;
}
#include "headstage.h"
#include "EliteWorkData.h"
static bool power_on(uint32_t delta_time)
{
uint32_t t = delta_time;
bool elite_on = false;
static uint32_t keyTimer = 0;
keyTimer = keyTimer + t;
if (keyTimer >= 10000) {
pin_set(E_PIN_5V_ENABLE, 1);
CPUdelay_us(320); // need delay 320us to stablize power
ModeLED(BT_WAIT);
AD5940_Initialize();
// headstage_battery_volt();
headstage_init_device_info();
elite_on = true;
}
return elite_on;
}
/*return the button status*/
uint8_t pin_button_get(void)
{
/*
* if btn = 0: press key
* if btn = 1: release key
*/
uint8_t btn;
btn = PIN_getInputValue(E_PIN_SHUT_DOWN);
return btn;
}
/* manage the button control*/
static void key_manage(uint32_t delta_time)
{
uint32_t t = delta_time;
static uint32_t keyTimer = 0;
static bool byPass1sec = false;
if (pin_button_get()!=0) {
if (keyTimer > 0) {
checkFlafLED();
byPass1sec = false;
}
keyTimer = 0;
return;
}
keyTimer = keyTimer + t;
if (keyTimer >= 30000){
pin_set(E_PIN_5V_ENABLE, 0);
} else if (keyTimer >= 10000 && !byPass1sec) {
led_color_set(LED_NB_MAX, LED_BR_LV1, LED_CLR_ORANGE);
byPass1sec = true;
}
return;
}
static void device_init(void)
{
gpio_create();
InitEliteInstruction();
Board_initSPI();
spi0_open(SPI_CLK_1M, POL0, PHA1); //SPI 1M: LED
spi1_open(SPI_CLK_4M, POL0, PHA0); //SPI 4M: AD5941
elite_gptimer_open();
InitGPT();
return;
}
/*********************************************************************
* @fn SimpleBLEPeripheral_taskFxn
*
@@ -706,121 +578,101 @@ static void device_init(void)
*/
static void SimpleBLEPeripheral_taskFxn(UArg a0, UArg a1)
{
bool elite_on = false;
batteryADC_flag = false;
uint32_t check_key_time = 0;
// Initialize application
SimpleBLEPeripheral_init();
// Initialize application
SimpleBLEPeripheral_init();
// Application main loop
for (;;)
{
// Waits for a signal to the semaphore associated with the calling thread.
// Note that the semaphore associated with a thread is signaled when a
// message is queued to the message receive queue of the thread or when
// ICall_signal() function is called onto the semaphore.
ICall_Errno errno = ICall_wait(ICALL_TIMEOUT_FOREVER);
device_init();
if (errno == ICALL_ERRNO_SUCCESS)
{
ICall_EntityID dest;
ICall_ServiceEnum src;
ICall_HciExtEvt *pMsg = NULL;
while(1) {
if (events & SBP_PERIODIC_EVT) {
events &= ~SBP_PERIODIC_EVT;
GPT_timerIncrement();
elite_on = power_on(GPT.cnt_gpt_delta);
if (ICall_fetchServiceMsg(&src, &dest,
(void **)&pMsg) == ICALL_ERRNO_SUCCESS)
{
uint8 safeToDealloc = TRUE;
if ((src == ICALL_SERVICE_CLASS_BLE) && (dest == selfEntity))
{
ICall_Stack_Event *pEvt = (ICall_Stack_Event *)pMsg;
// Check for BLE stack events first
if (pEvt->signature == 0xffff)
{
if (pEvt->event_flag & SBP_CONN_EVT_END_EVT)
{
// Try to retransmit pending ATT Response (if any)
SimpleBLEPeripheral_sendAttRsp();
}
}
else
{
// Process inter-task message
safeToDealloc = SimpleBLEPeripheral_processStackMsg((ICall_Hdr *)pMsg);
}
}
if (elite_on)
break;
if (pMsg && safeToDealloc)
{
ICall_freeMsg(pMsg);
}
}
// If RTOS queue is not empty, process app message.
while (!Queue_empty(appMsgQueue))
{
sbpEvt_t *pMsg = (sbpEvt_t *)Util_dequeueMsg(appMsgQueue);
if (pMsg)
{
// Process message.
SimpleBLEPeripheral_processAppMsg(pMsg);
// Free the space from the message.
ICall_free(pMsg);
}
}
}
// Application main loop
for (;;) {
// Waits for a signal to the semaphore associated with the calling thread.
// Note that the semaphore associated with a thread is signaled when a
// message is queued to the message receive queue of the thread or when
// ICall_signal() function is called onto the semaphore.
if (events & SBP_PERIODIC_EVT)
{
events &= ~SBP_PERIODIC_EVT;
Util_startClock(&periodicClock);
ICall_Errno errno = ICall_wait(ICALL_TIMEOUT_FOREVER); // let errno wait for infinite time, if periodicClock time up then execute below code
if (errno == ICALL_ERRNO_SUCCESS) {
ICall_EntityID dest;
ICall_ServiceEnum src;
ICall_HciExtEvt *pMsg = NULL;
if (ICall_fetchServiceMsg(&src, &dest,
(void **)&pMsg) == ICALL_ERRNO_SUCCESS) {
uint8 safeToDealloc = TRUE;
if ((src == ICALL_SERVICE_CLASS_BLE) && (dest == selfEntity)) {
ICall_Stack_Event *pEvt = (ICall_Stack_Event *)pMsg;
// Check for BLE stack events first
if (pEvt->signature == 0xffff) {
if (pEvt->event_flag & SBP_CONN_EVT_END_EVT) {
// Try to retransmit pending ATT Response (if any)
SimpleBLEPeripheral_sendAttRsp();
}
} else {
// Process inter-task message
safeToDealloc = SimpleBLEPeripheral_processStackMsg((ICall_Hdr *)pMsg);
}
}
if (pMsg && safeToDealloc) {
ICall_freeMsg(pMsg);
}
}
// If RTOS queue is not empty, process app message.
while (!Queue_empty(appMsgQueue)) {
sbpEvt_t *pMsg = (sbpEvt_t *)Util_dequeueMsg(appMsgQueue);
if (pMsg) {
// Process message.
SimpleBLEPeripheral_processAppMsg(pMsg);
// Free the space from the message.
ICall_free(pMsg);
}
}
}
GPT_timerIncrement();
check_key_time = check_key_time + GPT.cnt_gpt_delta;
if (events & SBP_PERIODIC_EVT) {
events &= ~SBP_PERIODIC_EVT;
/* routinely check the button status*/
if (check_key_time >= 200) {
key_manage(check_key_time);
check_key_time = 0;
}
if (!PeriodicEvent) { // if there is no periodic event
if (Free_Work_Mode) {
wm_deinit();
InitEliteInstruction();
Free_Work_Mode = false;
}
} else { // if there is periodic event
if(InitPeriodicEvent){
wm_init();
InitPeriodicEvent = false;
}
// Perform periodic application task
SimpleBLEPeripheral_performPeriodicTask();
}
}
// Perform periodic application task
SimpleBLEPeripheral_performPeriodicTask();
}
#ifdef FEATURE_OAD
while (!Queue_empty(hOadQ)) {
oadTargetWrite_t *oadWriteEvt = Queue_get(hOadQ);
while (!Queue_empty(hOadQ))
{
oadTargetWrite_t *oadWriteEvt = Queue_get(hOadQ);
// Identify new image.
if (oadWriteEvt->event == OAD_WRITE_IDENTIFY_REQ) {
OAD_imgIdentifyWrite(oadWriteEvt->connHandle, oadWriteEvt->pData);
} else if (oadWriteEvt->event == OAD_WRITE_BLOCK_REQ) { // Write a next block request.
OAD_imgBlockWrite(oadWriteEvt->connHandle, oadWriteEvt->pData);
}
// Identify new image.
if (oadWriteEvt->event == OAD_WRITE_IDENTIFY_REQ)
{
OAD_imgIdentifyWrite(oadWriteEvt->connHandle, oadWriteEvt->pData);
}
// Write a next block request.
else if (oadWriteEvt->event == OAD_WRITE_BLOCK_REQ)
{
OAD_imgBlockWrite(oadWriteEvt->connHandle, oadWriteEvt->pData);
}
// Free buffer.
ICall_free(oadWriteEvt);
}
#endif //FEATURE_OAD
// Free buffer.
ICall_free(oadWriteEvt);
}
#endif //FEATURE_OAD
}
}
/*********************************************************************
@@ -857,7 +709,7 @@ static uint8_t SimpleBLEPeripheral_processStackMsg(ICall_Hdr *pMsg)
AssertHandler(HAL_ASSERT_CAUSE_HARDWARE_ERROR,0);
}
break;
default:
break;
}
@@ -1011,8 +863,7 @@ static void SimpleBLEPeripheral_processAppMsg(sbpEvt_t *pMsg) {
break;
case SBP_CHAR_CHANGE_EVT:
// SimpleBLEPeripheral_processCharValueChangeEvt(pMsg->hdr.state);
ZM_instruction_update_handle(pMsg->hdr.state);
SimpleBLEPeripheral_processCharValueChangeEvt(pMsg->hdr.state);
break;
default:
@@ -1075,10 +926,14 @@ static void SimpleBLEPeripheral_processStateChangeEvt(gaprole_States_t newState)
DevInfo_SetParameter(DEVINFO_SYSTEM_ID, DEVINFO_SYSTEM_ID_LEN, systemId);
// Display device address
// Display_print0(dispHandle, 1, 0, Util_convertBdAddr2Str(ownAddress));
// Display_print0(dispHandle, 2, 0, "Initialized");
}
break;
case GAPROLE_ADVERTISING:
// Display_print0(dispHandle, 2, 0, "Advertising");
break;
#ifdef PLUS_BROADCASTER
@@ -1089,7 +944,7 @@ static void SimpleBLEPeripheral_processStateChangeEvt(gaprole_States_t newState)
*/
case GAPROLE_ADVERTISING_NONCONN:
{
uint8_t advertEnabled = true; // do some change to experiment
uint8_t advertEnabled = FALSE;
// Disable non-connectable advertising.
GAPRole_SetParameter(GAPROLE_ADV_NONCONN_ENABLED, sizeof(uint8_t),
@@ -1114,7 +969,7 @@ static void SimpleBLEPeripheral_processStateChangeEvt(gaprole_States_t newState)
linkDBInfo_t linkInfo;
uint8_t numActive = 0;
// Util_startClock(&periodicClock);
Util_startClock(&periodicClock);
numActive = linkDB_NumActive();
@@ -1122,6 +977,8 @@ static void SimpleBLEPeripheral_processStateChangeEvt(gaprole_States_t newState)
// connection
if ( linkDB_GetInfo( numActive - 1, &linkInfo ) == SUCCESS )
{
// Display_print1(dispHandle, 2, 0, "Num Conns: %d", (uint16_t)numActive);
// Display_print0(dispHandle, 3, 0, Util_convertBdAddr2Str(linkInfo.addr));
}
else
{
@@ -1129,6 +986,8 @@ static void SimpleBLEPeripheral_processStateChangeEvt(gaprole_States_t newState)
GAPRole_GetParameter(GAPROLE_CONN_BD_ADDR, peerAddress);
// Display_print0(dispHandle, 2, 0, "Connected");
// Display_print0(dispHandle, 3, 0, Util_convertBdAddr2Str(peerAddress));
}
#ifdef PLUS_BROADCASTER
@@ -1156,16 +1015,26 @@ static void SimpleBLEPeripheral_processStateChangeEvt(gaprole_States_t newState)
break;
case GAPROLE_CONNECTED_ADV:
// Display_print0(dispHandle, 2, 0, "Connected Advertising");
break;
case GAPROLE_WAITING:
Util_stopClock(&periodicClock);
SimpleBLEPeripheral_freeAttRsp(bleNotConnected);
ModeLED(BT_WAIT);
// Display_print0(dispHandle, 2, 0, "Disconnected");
// Clear remaining lines
// Display_clearLines(dispHandle, 3, 5);
break;
case GAPROLE_WAITING_AFTER_TIMEOUT:
SimpleBLEPeripheral_freeAttRsp(bleNotConnected);
ModeLED(BT_WAIT);
// Display_print0(dispHandle, 2, 0, "Timed Out");
// Clear remaining lines
// Display_clearLines(dispHandle, 3, 5);
#ifdef PLUS_BROADCASTER
// Reset flag for next connection.
@@ -1174,9 +1043,11 @@ static void SimpleBLEPeripheral_processStateChangeEvt(gaprole_States_t newState)
break;
case GAPROLE_ERROR:
// Display_print0(dispHandle, 2, 0, "Error");
break;
default:
// Display_clearLine(dispHandle, 2);
break;
}
@@ -1211,7 +1082,6 @@ static void SimpleBLEPeripheral_charValueChangeCB(uint8_t paramID)
*
* @return None.
*/
/*
static void SimpleBLEPeripheral_processCharValueChangeEvt(uint8_t paramID)
{
#ifndef FEATURE_OAD_ONCHIP
@@ -1222,13 +1092,13 @@ static void SimpleBLEPeripheral_processCharValueChangeEvt(uint8_t paramID)
case SIMPLEPROFILE_CHAR1:
SimpleProfile_GetParameter(SIMPLEPROFILE_CHAR1, &newValue);
Display_print1(dispHandle, 4, 0, "Char 1: %d", (uint16_t)newValue);
// Display_print1(dispHandle, 4, 0, "Char 1: %d", (uint16_t)newValue);
break;
case SIMPLEPROFILE_CHAR3:
SimpleProfile_GetParameter(SIMPLEPROFILE_CHAR3, &newValue);
Display_print1(dispHandle, 4, 0, "Char 3: %d", (uint16_t)newValue);
// Display_print1(dispHandle, 4, 0, "Char 3: %d", (uint16_t)newValue);
break;
default:
@@ -1237,7 +1107,6 @@ static void SimpleBLEPeripheral_processCharValueChangeEvt(uint8_t paramID)
}
#endif //!FEATURE_OAD_ONCHIP
}
*/
/*********************************************************************
* @fn SimpleBLEPeripheral_performPeriodicTask
@@ -1254,9 +1123,6 @@ static void SimpleBLEPeripheral_processCharValueChangeEvt(uint8_t paramID)
*/
static void SimpleBLEPeripheral_performPeriodicTask(void)
{
elite_task();
/*
#ifndef FEATURE_OAD_ONCHIP
uint8_t valueToCopy;
@@ -1271,7 +1137,6 @@ static void SimpleBLEPeripheral_performPeriodicTask(void)
&valueToCopy);
}
#endif //!FEATURE_OAD_ONCHIP
*/
}
@@ -1306,7 +1171,7 @@ void SimpleBLEPeripheral_processOadWriteCB(uint8_t event, uint16_t connHandle,
Queue_put(hOadQ, (Queue_Elem *)oadWriteEvt);
// Post the application's semaphore.
Semaphore_post(semaphore);
Semaphore_post(sem);
}
else
{
@@ -1324,16 +1189,14 @@ void SimpleBLEPeripheral_processOadWriteCB(uint8_t event, uint16_t connHandle,
*
* @return None.
*/
/*
static void SimpleBLEPeripheral_clockHandler(UArg arg)
{
// Store the event.
events |= arg;
// Wake up the application.
Semaphore_post(semaphore);
Semaphore_post(sem);
}
*/
/*********************************************************************
* @fn SimpleBLEPeripheral_enqueueMsg
@@ -1356,21 +1219,9 @@ static void SimpleBLEPeripheral_enqueueMsg(uint8_t event, uint8_t state)
pMsg->hdr.state = state;
// Enqueue the message.
Util_enqueueMsg(appMsgQueue, semaphore, (uint8*)pMsg);
Util_enqueueMsg(appMsgQueue, sem, (uint8*)pMsg);
}
}
/*********************************************************************
*********************************************************************/
#include "hardware/led_APA_102_c.h"
#include "driver/spi_ctrl_c.h"
#include "driver/timers_c.h"
#include "elite_task/elite_GPtimer_c.h"
#if (DEF_ELITE_MODEL == DEF_ELITE_EIS_11)
#include "driver/gpio_eis11_c.h"
#elif (DEF_ELITE_MODEL == DEF_ELITE_EIS_MINI_10)
#include "driver/gpio_eis_mini10_c.h"
#endif
#include "hardware/chip_ad5940_c.h"
@@ -9,7 +9,7 @@
Target Device: CC2650, CC2640
******************************************************************************
Copyright (c) 2010-2018, Texas Instruments Incorporated
All rights reserved.
@@ -135,6 +135,7 @@ static simpleProfileCBs_t *simpleProfile_AppCBs = NULL;
// Simple Profile Service attribute
static CONST gattAttrType_t simpleProfileService = { ATT_BT_UUID_SIZE, simpleProfileServUUID };
// Simple Profile Characteristic 1 Properties
// static uint8 simpleProfileChar1Props = GATT_PROP_READ | GATT_PROP_WRITE;
/*user insert*/
@@ -143,12 +144,13 @@ static uint8 simpleProfileChar1Props = GATT_PROP_READ;
// Characteristic 1 Value
// static uint8 simpleProfileChar1 = 0;
/*user insert*/
#define SIMPLEPROFILE_CHAR1_LEN 20
static uint8 simpleProfileChar1[SIMPLEPROFILE_CHAR1_LEN] = {0};
// Simple Profile Characteristic 1 User Description
static uint8 simpleProfileChar1UserDesp[17] = "Characteristic 1";
// Simple Profile Characteristic 2 Properties
static uint8 simpleProfileChar2Props = GATT_PROP_READ;
@@ -157,9 +159,11 @@ static uint8 simpleProfileChar2Props = GATT_PROP_READ;
/*user insert*/
static uint8 simpleProfileChar2[SIMPLEPROFILE_CHAR2_LEN] = {0};
// Simple Profile Characteristic 2 User Description
static uint8 simpleProfileChar2UserDesp[17] = "Characteristic 2";
// Simple Profile Characteristic 3 Properties
static uint8 simpleProfileChar3Props = GATT_PROP_WRITE;
@@ -168,9 +172,11 @@ static uint8 simpleProfileChar3Props = GATT_PROP_WRITE;
/*user insert*/
static uint8 simpleProfileChar3[SIMPLEPROFILE_CHAR3_LEN] = {0};
// Simple Profile Characteristic 3 User Description
static uint8 simpleProfileChar3UserDesp[17] = "Characteristic 3";
// Simple Profile Characteristic 4 Properties
static uint8 simpleProfileChar4Props = GATT_PROP_NOTIFY;
@@ -179,6 +185,7 @@ static uint8 simpleProfileChar4Props = GATT_PROP_NOTIFY;
/*user insert*/
static uint8 simpleProfileChar4[SIMPLEPROFILE_CHAR4_LEN] = {0};
// Simple Profile Characteristic 4 Configuration Each client has its own
// instantiation of the Client Characteristic Configuration. Reads of the
// Client Characteristic Configuration only shows the configuration for
@@ -188,6 +195,7 @@ static gattCharCfg_t *simpleProfileChar4Config;
// Simple Profile Characteristic 4 User Description
static uint8 simpleProfileChar4UserDesp[17] = "Characteristic 4";
// Simple Profile Characteristic 5 Properties
static uint8 simpleProfileChar5Props = GATT_PROP_READ;
@@ -222,17 +230,17 @@ static gattAttribute_t simpleProfileAttrTbl[SERVAPP_NUM_ATTR_SUPPORTED] =
// Characteristic Value 1
{
{ ATT_BT_UUID_SIZE, simpleProfilechar1UUID },
GATT_PERMIT_READ,
0,
simpleProfileChar1
GATT_PERMIT_READ,
0,
simpleProfileChar1
},
// Characteristic 1 User Description
{
{ ATT_BT_UUID_SIZE, charUserDescUUID },
GATT_PERMIT_READ,
0,
simpleProfileChar1UserDesp
GATT_PERMIT_READ,
0,
simpleProfileChar1UserDesp
},
// Characteristic 2 Declaration
@@ -246,114 +254,112 @@ static gattAttribute_t simpleProfileAttrTbl[SERVAPP_NUM_ATTR_SUPPORTED] =
// Characteristic Value 2
{
{ ATT_BT_UUID_SIZE, simpleProfilechar2UUID },
GATT_PERMIT_READ,
0,
simpleProfileChar2
},
// Characteristic 2 User Description
{
{ ATT_BT_UUID_SIZE, charUserDescUUID },
GATT_PERMIT_READ,
0,
simpleProfileChar2UserDesp
},
GATT_PERMIT_READ,
0,
simpleProfileChar2
},
// Characteristic 2 User Description
{
{ ATT_BT_UUID_SIZE, charUserDescUUID },
GATT_PERMIT_READ,
0,
simpleProfileChar2UserDesp
},
// Characteristic 3 Declaration
{
{ ATT_BT_UUID_SIZE, characterUUID },
GATT_PERMIT_READ,
0,
{ ATT_BT_UUID_SIZE, characterUUID },
GATT_PERMIT_READ,
0,
&simpleProfileChar3Props
},
// Characteristic Value 3
{
{ ATT_BT_UUID_SIZE, simpleProfilechar3UUID },
GATT_PERMIT_WRITE,
0,
simpleProfileChar3
},
// Characteristic Value 3
{
{ ATT_BT_UUID_SIZE, simpleProfilechar3UUID },
GATT_PERMIT_WRITE,
0,
simpleProfileChar3
},
// Characteristic 3 User Description
{
{ ATT_BT_UUID_SIZE, charUserDescUUID },
GATT_PERMIT_READ,
0,
simpleProfileChar3UserDesp
},
// Characteristic 3 User Description
{
{ ATT_BT_UUID_SIZE, charUserDescUUID },
GATT_PERMIT_READ,
0,
simpleProfileChar3UserDesp
},
// Characteristic 4 Declaration
{
{ ATT_BT_UUID_SIZE, characterUUID },
GATT_PERMIT_READ,
{ ATT_BT_UUID_SIZE, characterUUID },
GATT_PERMIT_READ,
0,
&simpleProfileChar4Props
},
// Characteristic Value 4
{
{ ATT_BT_UUID_SIZE, simpleProfilechar4UUID },
0,
0,
simpleProfileChar4
},
// Characteristic Value 4
{
{ ATT_BT_UUID_SIZE, simpleProfilechar4UUID },
0,
0,
simpleProfileChar4
},
// Characteristic 4 configuration
{
{ ATT_BT_UUID_SIZE, clientCharCfgUUID },
GATT_PERMIT_READ | GATT_PERMIT_WRITE,
0,
(uint8 *)&simpleProfileChar4Config
},
// Characteristic 4 configuration
{
{ ATT_BT_UUID_SIZE, clientCharCfgUUID },
GATT_PERMIT_READ | GATT_PERMIT_WRITE,
0,
(uint8 *)&simpleProfileChar4Config
},
// Characteristic 4 User Description
{
{ ATT_BT_UUID_SIZE, charUserDescUUID },
GATT_PERMIT_READ,
0,
simpleProfileChar4UserDesp
},
// Characteristic 4 User Description
{
{ ATT_BT_UUID_SIZE, charUserDescUUID },
GATT_PERMIT_READ,
0,
simpleProfileChar4UserDesp
},
// Characteristic 5 Declaration
{
{ ATT_BT_UUID_SIZE, characterUUID },
GATT_PERMIT_READ,
0,
{ ATT_BT_UUID_SIZE, characterUUID },
GATT_PERMIT_READ,
0,
&simpleProfileChar5Props
},
// Characteristic Value 5
{
{ ATT_BT_UUID_SIZE, simpleProfilechar5UUID },
GATT_PERMIT_AUTHEN_READ,
0,
simpleProfileChar5
},
// Characteristic Value 5
{
{ ATT_BT_UUID_SIZE, simpleProfilechar5UUID },
GATT_PERMIT_AUTHEN_READ,
0,
simpleProfileChar5
},
// Characteristic 5 User Description
{
{ ATT_BT_UUID_SIZE, charUserDescUUID },
GATT_PERMIT_READ,
0,
simpleProfileChar5UserDesp
},
// Characteristic 5 User Description
{
{ ATT_BT_UUID_SIZE, charUserDescUUID },
GATT_PERMIT_READ,
0,
simpleProfileChar5UserDesp
},
};
/*********************************************************************
* LOCAL FUNCTIONS
*/
static bStatus_t simpleProfile_ReadAttrCB(uint16_t connHandle,
gattAttribute_t *pAttr,
uint8_t *pValue, uint16_t *pLen,
uint16_t offset, uint16_t maxLen,
uint8_t method);
gattAttribute_t *pAttr,
uint8_t *pValue, uint16_t *pLen,
uint16_t offset, uint16_t maxLen,
uint8_t method);
static bStatus_t simpleProfile_WriteAttrCB(uint16_t connHandle,
gattAttribute_t *pAttr,
uint8_t *pValue, uint16_t len,
uint16_t offset, uint8_t method);
gattAttribute_t *pAttr,
uint8_t *pValue, uint16_t len,
uint16_t offset, uint8_t method);
/*********************************************************************
* PROFILE CALLBACKS
@@ -395,7 +401,7 @@ bStatus_t SimpleProfile_AddService( uint32 services )
// Allocate Client Characteristic Configuration table
simpleProfileChar4Config = (gattCharCfg_t *)ICall_malloc( sizeof(gattCharCfg_t) *
linkDBNumConns );
linkDBNumConns );
if ( simpleProfileChar4Config == NULL )
{
return ( bleMemAllocError );
@@ -408,9 +414,9 @@ bStatus_t SimpleProfile_AddService( uint32 services )
{
// Register GATT attribute list and CBs with GATT Server App
status = GATTServApp_RegisterService( simpleProfileAttrTbl,
GATT_NUM_ATTRS( simpleProfileAttrTbl ),
GATT_MAX_ENCRYPT_KEY_SIZE,
&simpleProfileCBs );
GATT_NUM_ATTRS( simpleProfileAttrTbl ),
GATT_MAX_ENCRYPT_KEY_SIZE,
&simpleProfileCBs );
}
else
{
@@ -468,7 +474,7 @@ bStatus_t SimpleProfile_SetParameter( uint8 param, uint8 len, void *value )
{
memcpy(simpleProfileChar1, value, len);
// simpleProfileChar1 = *((uint8*)value);
}
}
else
{
ret = bleInvalidRange;
@@ -482,7 +488,7 @@ bStatus_t SimpleProfile_SetParameter( uint8 param, uint8 len, void *value )
// simpleProfileChar2 = *((uint8*)value);
}
else
{
{
ret = bleInvalidRange;
}
break;
@@ -491,7 +497,8 @@ bStatus_t SimpleProfile_SetParameter( uint8 param, uint8 len, void *value )
if (len <= SIMPLEPROFILE_CHAR3_LEN)
{
memcpy(simpleProfileChar3, value, len);
}
// simpleProfileChar3 = *((uint8*)value);
}
else
{
ret = bleInvalidRange;
@@ -502,9 +509,12 @@ bStatus_t SimpleProfile_SetParameter( uint8 param, uint8 len, void *value )
if (len <= SIMPLEPROFILE_CHAR4_LEN)
{
memcpy(simpleProfileChar4, value, len);
// simpleProfileChar4 = *((uint8*)value);
// See if Notification has been enabled
GATTServApp_ProcessCharCfg(simpleProfileChar4Config, simpleProfileChar4, FALSE, simpleProfileAttrTbl, GATT_NUM_ATTRS(simpleProfileAttrTbl), INVALID_TASK_ID, simpleProfile_ReadAttrCB);
GATTServApp_ProcessCharCfg( simpleProfileChar4Config, simpleProfileChar4, FALSE,
simpleProfileAttrTbl, GATT_NUM_ATTRS( simpleProfileAttrTbl ),
INVALID_TASK_ID, simpleProfile_ReadAttrCB );
}
else
{
@@ -513,8 +523,9 @@ bStatus_t SimpleProfile_SetParameter( uint8 param, uint8 len, void *value )
break;
case SIMPLEPROFILE_CHAR5:
if (len == SIMPLEPROFILE_CHAR5_LEN) {
VOID memcpy(simpleProfileChar5, value, SIMPLEPROFILE_CHAR5_LEN);
if ( len == SIMPLEPROFILE_CHAR5_LEN )
{
VOID memcpy( simpleProfileChar5, value, SIMPLEPROFILE_CHAR5_LEN );
}
else
{
@@ -543,37 +554,41 @@ bStatus_t SimpleProfile_SetParameter( uint8 param, uint8 len, void *value )
*
* @return bStatus_t
*/
bStatus_t SimpleProfile_GetParameter(uint8 param, void *value) {
bStatus_t ret = SUCCESS;
switch (param) {
bStatus_t SimpleProfile_GetParameter( uint8 param, void *value )
{
bStatus_t ret = SUCCESS;
switch ( param )
{
case SIMPLEPROFILE_CHAR1:
memcpy(value, simpleProfileChar1, SIMPLEPROFILE_CHAR1_LEN);
// *((uint8*)value) = simpleProfileChar1;
break;
memcpy(value, simpleProfileChar1, SIMPLEPROFILE_CHAR1_LEN);
// *((uint8*)value) = simpleProfileChar1;
break;
case SIMPLEPROFILE_CHAR2:
memcpy(value, simpleProfileChar2, SIMPLEPROFILE_CHAR2_LEN);
// *((uint8*)value) = simpleProfileChar2;
break;
memcpy(value, simpleProfileChar2, SIMPLEPROFILE_CHAR2_LEN);
// *((uint8*)value) = simpleProfileChar2;
break;
case SIMPLEPROFILE_CHAR3:
memcpy(value, simpleProfileChar3, SIMPLEPROFILE_CHAR3_LEN);
break;
memcpy(value, simpleProfileChar3, SIMPLEPROFILE_CHAR3_LEN);
// *((uint8*)value) = simpleProfileChar3;
break;
case SIMPLEPROFILE_CHAR4:
memcpy(value, simpleProfileChar4, SIMPLEPROFILE_CHAR4_LEN);
break;
memcpy(value, simpleProfileChar4, SIMPLEPROFILE_CHAR4_LEN);
// *((uint8*)value) = simpleProfileChar4;
break;
case SIMPLEPROFILE_CHAR5:
VOID memcpy(value, simpleProfileChar5, SIMPLEPROFILE_CHAR5_LEN);
break;
VOID memcpy( value, simpleProfileChar5, SIMPLEPROFILE_CHAR5_LEN );
break;
default:
ret = INVALIDPARAMETER;
break;
}
ret = INVALIDPARAMETER;
break;
}
return (ret);
return ( ret );
}
/*********************************************************************
@@ -591,62 +606,65 @@ bStatus_t SimpleProfile_GetParameter(uint8 param, void *value) {
*
* @return SUCCESS, blePending or Failure
*/
static bStatus_t simpleProfile_ReadAttrCB(uint16_t connHandle, gattAttribute_t *pAttr, uint8_t *pValue, uint16_t *pLen, uint16_t offset, uint16_t maxLen, uint8_t method) {
bStatus_t status = SUCCESS;
static bStatus_t simpleProfile_ReadAttrCB(uint16_t connHandle,
gattAttribute_t *pAttr,
uint8_t *pValue, uint16_t *pLen,
uint16_t offset, uint16_t maxLen,
uint8_t method)
{
bStatus_t status = SUCCESS;
// Make sure it's not a blob operation (no attributes in the profile are long)
if (offset > 0) {
return (ATT_ERR_ATTR_NOT_LONG);
// Make sure it's not a blob operation (no attributes in the profile are long)
if ( offset > 0 )
{
return ( ATT_ERR_ATTR_NOT_LONG );
}
if ( pAttr->type.len == ATT_BT_UUID_SIZE )
{
// 16-bit UUID
uint16 uuid = BUILD_UINT16( pAttr->type.uuid[0], pAttr->type.uuid[1]);
switch ( uuid )
{
// No need for "GATT_SERVICE_UUID" or "GATT_CLIENT_CHAR_CFG_UUID" cases;
// gattserverapp handles those reads
// characteristics 1 and 2 have read permissions
// characteritisc 3 does not have read permissions; therefore it is not
// included here
// characteristic 4 does not have read permissions, but because it
// can be sent as a notification, it is included here
case SIMPLEPROFILE_CHAR1_UUID:
*pLen = SIMPLEPROFILE_CHAR1_LEN;
VOID memcpy( pValue, pAttr->pValue, SIMPLEPROFILE_CHAR1_LEN );
case SIMPLEPROFILE_CHAR2_UUID:
*pLen = SIMPLEPROFILE_CHAR2_LEN;
VOID memcpy( pValue, pAttr->pValue, SIMPLEPROFILE_CHAR2_LEN );
case SIMPLEPROFILE_CHAR4_UUID:
*pLen = SIMPLEPROFILE_CHAR4_LEN;
VOID memcpy( pValue, pAttr->pValue, SIMPLEPROFILE_CHAR4_LEN );
break;
case SIMPLEPROFILE_CHAR5_UUID:
*pLen = SIMPLEPROFILE_CHAR5_LEN;
VOID memcpy( pValue, pAttr->pValue, SIMPLEPROFILE_CHAR5_LEN );
break;
default:
// Should never get here! (characteristics 3 and 4 do not have read permissions)
*pLen = 0;
status = ATT_ERR_ATTR_NOT_FOUND;
break;
}
}
else
{
// 128-bit UUID
*pLen = 0;
status = ATT_ERR_INVALID_HANDLE;
}
if (pAttr->type.len == ATT_BT_UUID_SIZE) {
// 16-bit UUID
uint16 uuid = BUILD_UINT16(pAttr->type.uuid[0], pAttr->type.uuid[1]);
switch (uuid) {
// No need for "GATT_SERVICE_UUID" or "GATT_CLIENT_CHAR_CFG_UUID" cases;
// gattserverapp handles those reads
// characteristics 1 and 2 have read permissions
// characteritisc 3 does not have read permissions; therefore it is not
// included here
// characteristic 4 does not have read permissions, but because it
// can be sent as a notification, it is included here
case SIMPLEPROFILE_CHAR1_UUID:
*pLen = SIMPLEPROFILE_CHAR1_LEN;
VOID memcpy(pValue, pAttr->pValue, SIMPLEPROFILE_CHAR1_LEN);
break;
case SIMPLEPROFILE_CHAR2_UUID:
// *pLen = 1;
// pValue[0] = *pAttr->pValue;
*pLen = SIMPLEPROFILE_CHAR2_LEN;
VOID memcpy(pValue, pAttr->pValue, SIMPLEPROFILE_CHAR2_LEN);
break;
case SIMPLEPROFILE_CHAR4_UUID:
*pLen = SIMPLEPROFILE_CHAR4_LEN;
VOID memcpy(pValue, pAttr->pValue, SIMPLEPROFILE_CHAR4_LEN);
break;
// case SIMPLEPROFILE_CHAR5_UUID:
// *pLen = SIMPLEPROFILE_CHAR5_LEN;
// VOID memcpy( pValue, pAttr->pValue, SIMPLEPROFILE_CHAR5_LEN );
// break;
default:
// Should never get here! (characteristics 3 and 4 do not have read permissions)
*pLen = 0;
status = ATT_ERR_ATTR_NOT_FOUND;
break;
}
} else {
// 128-bit UUID
*pLen = 0;
status = ATT_ERR_INVALID_HANDLE;
}
return (status);
return ( status );
}
/*********************************************************************
@@ -663,83 +681,83 @@ static bStatus_t simpleProfile_ReadAttrCB(uint16_t connHandle, gattAttribute_t *
*
* @return SUCCESS, blePending or Failure
*/
static bStatus_t simpleProfile_WriteAttrCB(uint16_t connHandle, gattAttribute_t *pAttr, uint8_t *pValue, uint16_t len, uint16_t offset, uint8_t method) {
bStatus_t status = SUCCESS;
uint8 notifyApp = 0xFF;
static bStatus_t simpleProfile_WriteAttrCB(uint16_t connHandle,
gattAttribute_t *pAttr,
uint8_t *pValue, uint16_t len,
uint16_t offset, uint8_t method)
{
bStatus_t status = SUCCESS;
uint8 notifyApp = 0xFF;
if (pAttr->type.len == ATT_BT_UUID_SIZE) {
// 16-bit UUID
uint16 uuid = BUILD_UINT16(pAttr->type.uuid[0], pAttr->type.uuid[1]);
switch (uuid) {
// Validate the value
// Make sure it's not a blob oper
/*
if ( offset == 0 )
{
if ( len != 1 )
{
status = ATT_ERR_INVALID_VALUE_SIZE;
}
}
else
{
status = ATT_ERR_ATTR_NOT_LONG;
}
if ( pAttr->type.len == ATT_BT_UUID_SIZE )
{
// 16-bit UUID
uint16 uuid = BUILD_UINT16( pAttr->type.uuid[0], pAttr->type.uuid[1]);
switch ( uuid )
{
case SIMPLEPROFILE_CHAR1_UUID:
case SIMPLEPROFILE_CHAR3_UUID:
//Write the value
if ( status == SUCCESS )
{
uint8 *pCurValue = (uint8 *)pAttr->pValue;
*pCurValue = pValue[0];
if( pAttr->pValue == &simpleProfileChar1 )
{
notifyApp = SIMPLEPROFILE_CHAR1;
}
}
break;
*/
case SIMPLEPROFILE_CHAR3_UUID:
if (offset == 0) {
if (len > SIMPLEPROFILE_CHAR3_LEN) {
status = ATT_ERR_INVALID_VALUE_SIZE;
}
} else {
status = ATT_ERR_ATTR_NOT_LONG;
}
// Write the value
if (status == SUCCESS) {
// Copy pValue into the variable we point to from the attribute table.
memcpy(pAttr->pValue + offset, pValue, len);
memset(pAttr->pValue + len, 0, SIMPLEPROFILE_CHAR3_LEN - len);
if (pAttr->pValue == simpleProfileChar3) {
notifyApp = SIMPLEPROFILE_CHAR3;
}
}
break;
case GATT_CLIENT_CHAR_CFG_UUID:
status = GATTServApp_ProcessCCCWriteReq(connHandle, pAttr, pValue, len, offset, GATT_CLIENT_CFG_NOTIFY);
break;
default:
// Should never get here! (characteristics 2 and 4 do not have write permissions)
status = ATT_ERR_ATTR_NOT_FOUND;
break;
//Validate the value
// Make sure it's not a blob oper
if ( offset == 0 )
{
if ( len > SIMPLEPROFILE_CHAR3_LEN )
{
status = ATT_ERR_INVALID_VALUE_SIZE;
}
}
else
{
status = ATT_ERR_ATTR_NOT_LONG;
}
} else {
// 128-bit UUID
status = ATT_ERR_INVALID_HANDLE;
}
// If a characteristic value changed then callback function to notify application of change
if ((notifyApp != 0xFF) && simpleProfile_AppCBs && simpleProfile_AppCBs->pfnSimpleProfileChange) {
simpleProfile_AppCBs->pfnSimpleProfileChange(notifyApp);
}
//Write the value
if ( status == SUCCESS )
{
uint8 *pCurValue = (uint8 *)pAttr->pValue;
*pCurValue = pValue[0];
return (status);
// Copy pValue into the variable we point to from the attribute table.
memcpy(pAttr->pValue + offset, pValue, len);
memset(pAttr->pValue + len, 0, SIMPLEPROFILE_CHAR3_LEN - len);
if( pAttr->pValue == simpleProfileChar1 )
{
notifyApp = SIMPLEPROFILE_CHAR1;
}
else
{
notifyApp = SIMPLEPROFILE_CHAR3;
}
}
break;
case GATT_CLIENT_CHAR_CFG_UUID:
status = GATTServApp_ProcessCCCWriteReq( connHandle, pAttr, pValue, len,
offset, GATT_CLIENT_CFG_NOTIFY );
break;
default:
// Should never get here! (characteristics 2 and 4 do not have write permissions)
status = ATT_ERR_ATTR_NOT_FOUND;
break;
}
}
else
{
// 128-bit UUID
status = ATT_ERR_INVALID_HANDLE;
}
// If a characteristic value changed then callback function to notify application of change
if ( (notifyApp != 0xFF ) && simpleProfile_AppCBs && simpleProfile_AppCBs->pfnSimpleProfileChange )
{
simpleProfile_AppCBs->pfnSimpleProfileChange( notifyApp );
}
return ( status );
}
/*********************************************************************
@@ -56,7 +56,7 @@ extern "C"
/*********************************************************************
* INCLUDES
*/
// #include "application_config/application_config.h"
/*********************************************************************
* CONSTANTS
*/
@@ -81,12 +81,24 @@ extern "C"
// Simple Keys Profile Services bit fields
#define SIMPLEPROFILE_SERVICE 0x00000001
#ifndef CUSTOM_GATT_LENGTH
// Length of Characteristic 5 in bytes
#define SIMPLEPROFILE_CHAR5_LEN 5
/*user insert*/
#define SIMPLEPROFILE_CHAR4_LEN 40
#define SIMPLEPROFILE_CHAR4_LEN 20
#define SIMPLEPROFILE_CHAR3_LEN 20
#define SIMPLEPROFILE_CHAR2_LEN 20
#define SIMPLEPROFILE_CHAR1_LEN 20
#else
/*user insert*/
#define SIMPLEPROFILE_CHAR5_LEN 5
#define SIMPLEPROFILE_CHAR4_LEN BLE_DAT_BUFF_SIZE
#define SIMPLEPROFILE_CHAR3_LEN BLE_INS_BUFF_SIZE
#define SIMPLEPROFILE_CHAR2_LEN BLE_CIS_BUFF_SIZE
#define SIMPLEPROFILE_CHAR1_LEN 20
#define BLE_CIS_BUFF_CHAR SIMPLEPROFILE_CHAR2
#define BLE_INS_BUFF_CHAR SIMPLEPROFILE_CHAR3
#define BLE_DAT_BUFF_CHAR SIMPLEPROFILE_CHAR4
#endif
/*********************************************************************
* TYPEDEFS
*/