Compare commits
64 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
| 986350ef5e | |||
| d2e37ce574 | |||
| cdf50c6c48 | |||
| 47f4fd49e5 | |||
| 9e623f46da | |||
| 42d803e739 | |||
| e4bef28ead | |||
| ae61ec610f | |||
| f3a8943c1e | |||
| 3990c4db8f | |||
| ead65c3c94 | |||
| b41e757e44 | |||
| bfcf716b94 | |||
| ba1aeb4670 | |||
| 6541fd1386 | |||
| b95ebc697e | |||
| dbb85e508a | |||
| 39dd62b0a0 | |||
| 2a24c65ad6 | |||
| 2908c595d1 | |||
| f9aa353292 | |||
| df0f87c281 | |||
| 82ca5435f5 | |||
| 18c25c1e62 | |||
| ce47324003 | |||
| 390822f893 | |||
| fa06908a08 | |||
| bb425dd5bd | |||
| 607702ae23 | |||
| 09c3a67657 | |||
| 05e8dc5982 | |||
| 62d28c4054 | |||
| 84339ea967 | |||
| b5da45124d | |||
| 8d9e4eab63 | |||
| 41d20603d1 | |||
| 10a9a617ab | |||
| 7fb3bd976f | |||
| d2a3a9a712 | |||
| ee75ad8341 | |||
| 552569d985 | |||
| d0fe825a7b | |||
| 07e31e42ab | |||
| 508b257e35 | |||
| 45ecdf8835 | |||
| 3e8ab75923 | |||
| 925183496c | |||
| 9977a323b2 | |||
| 33ea52104f | |||
| cc8ac71bda | |||
| 09e8cbbc89 | |||
| cca7cf7b5d | |||
| eb5366c3c2 | |||
| 14fcd46d4b | |||
| 26f412f1b0 | |||
| 31874d41d7 | |||
| efd9656a0f | |||
| cbd5099942 | |||
| 2778dd245b | |||
| e9a366450b | |||
| 86eec48e68 | |||
| 3b1fe9d4cd | |||
| 7003cbaa7a | |||
| 868bf3ab5b |
@@ -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
|
||||
* ==========================================================================*/
|
||||
|
||||
-143
@@ -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
|
||||
-81
@@ -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
|
||||
-98
@@ -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
|
||||
-14
@@ -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
|
||||
-58
@@ -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;
|
||||
}
|
||||
|
||||
-14
@@ -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
|
||||
-57
@@ -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;
|
||||
}
|
||||
|
||||
-27
@@ -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
|
||||
-208
@@ -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;
|
||||
}
|
||||
*/
|
||||
-40
@@ -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
|
||||
-90
@@ -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(¶ms);
|
||||
params.width = GPT_CONFIG_16BIT;
|
||||
params.mode = GPT_MODE_PERIODIC_UP;
|
||||
params.debugStallMode = GPTimerCC26XX_DEBUG_STALL_OFF;
|
||||
gptimer_handle = GPTimerCC26XX_open(Board_GPTIMER0A, ¶ms);
|
||||
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;
|
||||
}
|
||||
-26
@@ -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
|
||||
-16
@@ -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;
|
||||
}
|
||||
-4943
File diff suppressed because it is too large
Load Diff
-4416
File diff suppressed because it is too large
Load Diff
-97
@@ -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
|
||||
-189
@@ -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);
|
||||
*/
|
||||
-137
@@ -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
|
||||
-903
@@ -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
|
||||
|
||||
-259
@@ -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
|
||||
-291
@@ -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
|
||||
|
||||
|
||||
-84
@@ -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
|
||||
-202
@@ -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 *)¬ify_one, sizeof(notify_one));
|
||||
memcpy(not_buf+29, (uint8_t *)¬ify_two, sizeof(notify_two));
|
||||
memcpy(not_buf+33, (uint8_t *)¬ify_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
|
||||
-22
@@ -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
|
||||
-66
@@ -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
|
||||
-478
@@ -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
|
||||
-103
@@ -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
|
||||
-151
@@ -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
|
||||
|
||||
-10
@@ -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
|
||||
|
||||
-712
@@ -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;
|
||||
}
|
||||
-8813
File diff suppressed because it is too large
Load Diff
-809
@@ -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
|
||||
-307
@@ -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_ */
|
||||
-69
@@ -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
|
||||
-156
@@ -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;
|
||||
}
|
||||
-175
@@ -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;
|
||||
}
|
||||
-314
@@ -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;
|
||||
}
|
||||
-78
@@ -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;
|
||||
}
|
||||
-47
@@ -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;
|
||||
}
|
||||
|
||||
-33
@@ -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')
|
||||
+133
-282
@@ -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"
|
||||
|
||||
+257
-239
@@ -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
|
||||
*/
|
||||
|
||||
Reference in New Issue
Block a user