jh.chun/VesiScan-Basic-firmware-test
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix: BLE TX 먹통 해결 및 메모리 안전성 개선

Browse Source 
- binary_tx_handler를 dr_binary_tx_safe로 전체 교체 (APP_ERROR_CHECK 제거)
- data_tx_handler APP_ERROR_CHECK → DBG_PRINTF 교체
- memset/memcpy 하드코딩 크기를 define 상수로 교체 (버퍼 오버런 수정)
- SERIAL_NO_LENGTH, HW_NO_LENGTH, PASSKEY_LENGTH를 main.h로 통합
- 미사용 HW 드라이버/EEPROM 코드 삭제, TWI를 i2c_manager.c로 통합
- EEPROM → FDS 전환, 코드 리뷰 현황 문서 추가

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
This commit is contained in:
jhchun
2026-03-16 16:39:26 +09:00
parent 836ebe5878
commit a1ad2a4b5b
76 changed files with 43253 additions and 16370 deletions
Download Patch File Download Diff File Expand all files Collapse all files

158
project/ble_peripheral/ble_app_bladder_patch/LED_Parse.c
View File

@@ -1,158 +0,0 @@
#include "sdk_common.h"
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include "nrf.h"
#include "nrf_drv_gpiote.h"
#include "nrf_drv_spi.h"
#include "nrf_drv_saadc.h"
#include "nrf_drv_ppi.h"
#include "nrf_drv_timer.h"
#include "boards.h"
#include "nrf_log.h"
#include "LED_Parse.h"
#include "app_timer.h"
#include "measurements.h"
#include "main.h"
//#include "fstorage.h"
#include "mcp4725_i2c.h" //VGA
#include "ir_i2c.h" //IR
#include "debug_print.h"
//#define LED_S1 0x50 //VGA LED1~5
//#define LED_S2 0x50
//#define LED_S3 0x51
//#define LED_S4 0x52
//#define LED_S5 0x53
//#define LED_S6 0x51 //VGA
//#define LED_S7 0x54
//#define LED_S8 0x55
//#define LED_S9 0x56
//#define LED_S10 0x57 //LED 46~50
#define LED_S0 0x50
#define LED_S1 0x51
#define LED_S2 0x52
#define LED_S3 0x53
#define LED_S4 0x54
#define LED_S5 0x55
#define LED_S6 0x56
#define LED_S7 0x57
uint8_t LED_READ_ROM(uint8_t led_index)
{
// uint32_t err_code = NRF_SUCCESS;
uint8_t addr=0xf0;
uint8_t r_index;
r_index = (led_index)%6;
uint8_t r_data[10];
uint8_t r_value=0;
switch(led_index) {
case 0: case 1: case 2: case 3: case 4: case 5:
r_value = ir_command_read(LED_S0, addr + r_index, r_data);
break;
case 6: case 7: case 8: case 9: case 10: case 11:
r_value = ir_command_read(LED_S1, addr + r_index, r_data);
break;
case 12: case 13: case 14: case 15: case 16: case 17:
r_value = ir_command_read(LED_S2, addr + r_index, r_data);
break;
case 18: case 19: case 20: case 21: case 22: case 23:
r_value = ir_command_read(LED_S3, addr + r_index, r_data);
break;
case 24: case 25: case 26: case 27: case 28: case 29:
r_value = ir_command_read(LED_S4, addr + r_index, r_data);
break;
case 30: case 31: case 32: case 33: case 34: case 35:
r_value = ir_command_read(LED_S5, addr + r_index, r_data);
break;
case 36: case 37: case 38: case 39: case 40: case 41:
r_value = ir_command_read(LED_S6, addr + r_index, r_data);
break;
case 42: case 43: case 44: case 45: case 46: case 47:
r_value = ir_command_read(LED_S7, addr + r_index, r_data);
break;
default:
DBG_PRINTF("Invalid LED index\r\n");
// err_code = NRF_ERROR_NOT_FOUND;
break;
}
return r_value;
}
ret_code_t LED_WRITE_ROM(uint8_t led_index, int16_t led_power)
{
uint32_t err_code = NRF_SUCCESS;
uint8_t addr=0xf0;
uint8_t r_index;
r_index = (led_index)%6;
switch(led_index) {
case 0: case 1: case 2: case 3: case 4: case 5:
ir_command_write(LED_S0, addr + r_index, led_power);
break;
case 6: case 7: case 8: case 9: case 10: case 11:
ir_command_write(LED_S1, addr + r_index, led_power);
break;
case 12: case 13: case 14: case 15: case 16: case 17:
ir_command_write(LED_S2, addr + r_index, led_power);
break;
case 18: case 19: case 20: case 21: case 22: case 23:
ir_command_write(LED_S3, addr + r_index, led_power);
break;
case 24: case 25: case 26: case 27: case 28: case 29:
ir_command_write(LED_S4, addr + r_index, led_power);
break;
case 30: case 31: case 32: case 33: case 34: case 35:
ir_command_write(LED_S5, addr + r_index, led_power);
break;
case 36: case 37: case 38: case 39: case 40: case 41:
ir_command_write(LED_S6, addr + r_index, led_power);
break;
case 42: case 43: case 44: case 45: case 46: case 47:
ir_command_write(LED_S7, addr + r_index, led_power);
break;
default:
DBG_PRINTF("Invalid LED index\r\n");
err_code = NRF_ERROR_NOT_FOUND;
break;
}
DBG_PRINTF("write\r\n");
return err_code;
}

26
project/ble_peripheral/ble_app_bladder_patch/LED_Parse.h
View File

@@ -1,26 +0,0 @@
#ifndef _LED_Parse_H_
#define _LED_Parse_H_
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include "app_timer.h"
#include "measurements.h"
#include "main.h"
//#include "fstorage.h"
#include "mcp4725_i2c.h" //VGA
#include "ir_i2c.h" //IR
uint8_t LED_READ_ROM(uint8_t led_index);
ret_code_t LED_WRITE_ROM(uint8_t led_index, int16_t led_power);
#endif /* PARSE */

299
project/ble_peripheral/ble_app_bladder_patch/ad5272_i2c.c
View File

@@ -1,299 +0,0 @@
/*******************************************************************************
* @file ad5272_i2c.c
* @author CandyPops Co.
* @version V1.0.0
* @date 2022-09-05
* @brief
******************************************************************************/
/* board driver */
#include <stdio.h>
#include <string.h>
#include <stdarg.h>
#include <stdbool.h>
#include "nrf.h"
#include "app_error.h"
#include "boards.h"
#include "nrfx_gpiote.h"
#include "nrfx_twi.h"
#include "nrf_delay.h"
#include "ad5272_i2c.h"
#include "debug_print.h"
/* I2C number and slave address for AD5272 */
#define AD5272_I2C_ADDR 0x2F /* Default I2C address if ADDR = GND */
#define AD5272_MAX_SERIAL_WRITE 16
int16_t read_from_ad5272 = 0;
uint16_t data_16_to_write = 0;
/* TWI instance. */
const nrfx_twi_t m_twi_ad5272 = NRFX_TWI_INSTANCE(AD5272_I2C_INSTANCE);
void ad5272_i2c_uninit(void){
nrfx_twi_disable(&m_twi_ad5272);
nrfx_twi_uninit(&m_twi_ad5272);
}
void ad5272_i2c_init(void){
ret_code_t err_code;
const nrfx_twi_config_t twi_ad5272_config = {
.scl = AD5272_I2C_SCL_PIN,
.sda = AD5272_I2C_SDA_PIN,
.frequency = NRF_TWI_FREQ_400K,
.interrupt_priority = APP_IRQ_PRIORITY_HIGH,
};
err_code = nrfx_twi_init(&m_twi_ad5272, &twi_ad5272_config, NULL, NULL);
APP_ERROR_CHECK(err_code);
nrfx_twi_enable(&m_twi_ad5272);
}
ret_code_t ad5272_twi_tx( uint8_t device_id,
uint8_t const * p_data,
uint8_t length,
bool no_stop)
{
ret_code_t ret;
ret = nrfx_twi_tx(&m_twi_ad5272, device_id, p_data, length, no_stop);
return ret;
}
ret_code_t ad5272_twi_rx( uint8_t device_id,
uint8_t * p_data,
uint8_t length)
{
ret_code_t ret;
ret = nrfx_twi_rx(&m_twi_ad5272, device_id, p_data, length);
return ret;
}
int16_t ad5272_command_read(uint8_t command, uint8_t write_data)
{
uint8_t error_count = 0;
uint8_t data_buff[1+AD5272_MAX_SERIAL_WRITE];
uint16_t data_to_write = 0;
int16_t read_data = 0;
ret_code_t ret;
if (AD5272_50TP_WIPER_READ == command)
{
// shift the command over into bits 13:10
data_to_write = command<<10;
// also need to send 6-bit 50-TP location
data_to_write |= write_data;
}
else if ( (AD5272_RDAC_READ == command) || (AD5272_50TP_LAST_USED == command) || (AD5272_CONTROL_READ == command) )
{
// command is in range and something possible to read
// shift the command over into bits 13:10
data_to_write = command<<10;
}
else
{
// It's either a bad command (out of range, > AD5272_SHUTDOWN), or its not a readable command
// Bad command, we can't reasonably proceed
error_count = 100;
}
/**
* At this point, if error_count == 0 we have a valid read command
*/
if (0 == error_count)
{
memset(data_buff, 0, 1+AD5272_MAX_SERIAL_WRITE);
data_buff[0] = (data_to_write >> 8); // ms byte to write
data_buff[1] = data_to_write & 0x0FF; // ls byte to write
#if FEATURE_PRINTF
DBG_PRINTF("ad5272_rx_1_buff[0]=0x%x, [1]=0x%x\r\n", data_buff[0], data_buff[1]);
#endif
ret = ad5272_twi_tx(AD5272_I2C_ADDR, data_buff, 2, true);
if(ret != NRF_SUCCESS) {
ret = ad5272_twi_tx(AD5272_I2C_ADDR, data_buff, 2, true);
if(ret != NRF_SUCCESS) {
#if FEATURE_PRINTF
DBG_PRINTF("ad5272_ERR! i2c read-1\r\n");
#endif
//APP_ERROR_CHECK(ret);
}
}
memset(data_buff, 0, 1+AD5272_MAX_SERIAL_WRITE);
ret = ad5272_twi_rx(AD5272_I2C_ADDR, data_buff, 2);
if(ret != NRF_SUCCESS) {
ret = ad5272_twi_rx(AD5272_I2C_ADDR, data_buff, 2);
if(ret != NRF_SUCCESS) {
#if FEATURE_PRINTF
DBG_PRINTF("ad5272_ERR! i2c read-2\r\n");
#endif
//APP_ERROR_CHECK(ret);
}
}
read_data = data_buff[0] << 8; // ms byte
read_data |= data_buff[1]; // ls byte
#if FEATURE_PRINTF
DBG_PRINTF("ad5272_read_data = 0x%x\r\n",read_data);
#endif
}else{
#if FEATURE_PRINTF
DBG_PRINTF("ad5272_read_data USELESS!!!\r\n");
#endif
}
return read_data;
}
int8_t ad5272_command_write(uint8_t command, uint16_t write_data)
{
uint8_t error_count = 0;
uint8_t data_buff[1+AD5272_MAX_SERIAL_WRITE];
ret_code_t ret;
int8_t return_val = 0;
uint16_t data_to_write = 0;
if (write_data > 0x3FF)
{
// data in bits 13:10 will clobber the command when we OR in write_datum16
write_data &= 0x3FF; // clip off any bad high bits even though we are going to error out and not use them
#if FEATURE_PRINTF
DBG_PRINTF("ad5272_ERR! Input Value wrong!\r\n");
#endif
}
if ( (AD5272_RDAC_WRITE == command) || (AD5272_CONTROL_WRITE == command) || (AD5272_SHUTDOWN == command) )
{
// these commands need to use data we send over
// shift the command over into bits 13:10
data_to_write = command<<10;
// also need to send 10-bit or 8-bit wiper value, or 3 control bits, or shutdown bit
data_to_write |= write_data;
}
else if ( (AD5272_50TP_WRITE == command) || (AD5272_RDAC_REFRESH == command) )
{
// shift the command over into bits 13:10
data_to_write = command<<10;
// no data needed
}
else
{
// It's either a bad command (out of range, > AD5272_SHUTDOWN), or its not a writeable command
// Bad command, we can't reasonably proceed
error_count = 100;
}
// if no errors so far, command is valid and datum is too
if (0 == error_count)
{
data_buff[0] = (data_to_write >> 8); // ms byte to write
data_buff[1] = data_to_write & 0x0FF; // ls byte to write
ret = ad5272_twi_tx(AD5272_I2C_ADDR, data_buff, 2, false);
if(ret != NRF_SUCCESS) {
ret = ad5272_twi_tx(AD5272_I2C_ADDR, data_buff, 2, false);
if(ret != NRF_SUCCESS) {
#if FEATURE_PRINTF
DBG_PRINTF("ad5272_ERR! i2c write\r\n");
#endif
//APP_ERROR_CHECK(ret);
return_val = NRF_ERROR_INTERNAL;
}
}
}
return return_val;
}
void ad5272_i2c_is_busy(void)
{
uint8_t buffer[3]; /* Addr + data */
buffer[0] = AD5272_COMMAND_NOP;
buffer[1] = 0x00;
while(NRF_SUCCESS != ad5272_twi_tx(AD5272_I2C_ADDR, buffer, 1, false))
{
#if FEATURE_PRINTF
DBG_PRINTF("ad5272_BUSY : is Busy\r\n");
#endif
}
}
/**
*
*/
int8_t ad5272_write_and_read_rdac (uint16_t data_16_to_write)
{
ret_code_t ret;
ret = ad5272_command_write(AD5272_CONTROL_WRITE, AD5272_RDAC_WIPER_WRITE_ENABLE); /* Write Enable */
ret |= ad5272_command_write(AD5272_RDAC_WRITE, data_16_to_write); /* Write Data */
ret |= ad5272_command_write(AD5272_CONTROL_WRITE, 0x00); /* Write Disable & Use 50tp value */
read_from_ad5272 = ad5272_command_read(AD5272_RDAC_READ, 0x00);
return ret;
}
int16_t ad5272_read_rdac (void)
{
read_from_ad5272 = ad5272_command_read(AD5272_RDAC_READ, 0x00);
return read_from_ad5272;
}
int8_t ad5272_write_rdac (uint16_t data_16_to_write)
{
ret_code_t ret;
ret = ad5272_command_write(AD5272_CONTROL_WRITE, AD5272_RDAC_WIPER_WRITE_ENABLE); /* Write Enable */
ret |= ad5272_command_write(AD5272_RDAC_WRITE, data_16_to_write); /* Write Data */
ret |= ad5272_command_write(AD5272_CONTROL_WRITE, 0x00); /* Write Disable & Use 50tp value */
return ret;
}
void ad5272_RDAC_refresh(void)
{
ad5272_command_write(AD5272_RDAC_REFRESH, 0x00);
ad5272_i2c_is_busy();
}
void ad5272_shutdown_mode(void)
{
ad5272_command_write(AD5272_SHUTDOWN, 0x01);
ad5272_i2c_is_busy();
}
void ad5272_normal_mode(void)
{
ad5272_command_write(AD5272_SHUTDOWN, 0x00);
ad5272_i2c_is_busy();
}

102
project/ble_peripheral/ble_app_bladder_patch/ad5272_i2c.h
View File

@@ -1,102 +0,0 @@
/*******************************************************************************
* @file ad5272_i2c.h
* @author CandyPops Co.
* @version V1.0.0
* @date 2022-09-05
* @brief
******************************************************************************/
#ifndef _ADA5272_I2C_H_
#define _ADA5272_I2C_H_
#include "sdk_common.h"
#include <stdbool.h>
#include "nrf.h"
#include "nrf_drv_gpiote.h"
#define AD5272_I2C_INSTANCE 1 /**< I2C instance index. */
#define AD5272_I2C_SDA_PIN NRF_GPIO_PIN_MAP(0,10)
#define AD5272_I2C_SCL_PIN NRF_GPIO_PIN_MAP(0,9)
/**
* COMMAND CONSTANTS
* Commands are 16-bit writes: bits 15:14 are 0s
* Bits 13:10 are the command value below
* Bits 9:0 are data for the command, but not all bits are used with all commands
*/
// The NOP command is included for completeness. It is a valid I2C operation.
#define AD5272_COMMAND_NOP 0x00 // Do nothing. Why you would want to do this I don't know
// write the 10 or 8 data bits to the RDAC wiper register (it must be unlocked first)
#define AD5272_RDAC_WRITE 0x01
#define AD5272_RDAC_READ 0x02 // read the RDAC wiper register
#define AD5272_50TP_WRITE 0x03 // store RDAC setting to 50-TP
// SW reset: refresh RDAC with last 50-TP stored value
// If not 50-TP value, reset to 50% I think???
// data bits are all dont cares
#define AD5272_RDAC_REFRESH 0x04 // TODO refactor this to AD5272_SOFT_RESET
// read contents of 50-TP in next frame, at location in data bits 5:0,
// see Table 16 page 22 Rev D datasheet
// location 0x0 is reserved, 0x01 is first programmed wiper location, 0x32 is 50th programmed wiper location
#define AD5272_50TP_WIPER_READ 0x05
/**
* Read contents of last-programmed 50-TP location
* This is the location used in SW Reset command 4 or on POR
*/
#define AD5272_50TP_LAST_USED 0x06
#define AD5272_CONTROL_WRITE 0x07 // data bits 2:0 are the control bits
#define AD5272_CONTROL_READ 0x08 // data bits all dont cares
#define AD5272_SHUTDOWN 0x09 // data bit 0 set = shutdown, cleared = normal mode
/**
* Control bits are three bits written with command 7
*/
// enable writing to the 50-TP memory by setting this control bit C0
// default is cleared so 50-TP writing is disabled
// only 50 total writes are possible!
#define AD5272_50TP_WRITE_ENABLE 0x01
// enable writing to volatile RADC wiper by setting this control bit C1
// otherwise it is frozen to the value in the 50-TP memory
// default is cleared, can't write to the wiper
#define AD5272_RDAC_WIPER_WRITE_ENABLE 0x02
// enable high precision calibration by clearing this control bit C2
// set this bit to disable high accuracy mode (dunno why you would want to)
// default is 0 = emabled
#define AD5272_RDAC_CALIB_DISABLE 0x04
// 50TP memory has been successfully programmed if this bit is set
#define AD5272_50TP_WRITE_SUCCESS 0x08
#define AD5272_NORMAL_MODE 0x01
#define AD5272_SHUTDOWN_MODE 0x01
void ad5272_i2c_uninit(void);
void ad5272_i2c_init(void);
int16_t ad5272_command_read(uint8_t command, uint8_t write_data);
int8_t ad5272_command_write(uint8_t command, uint16_t write_data);
void ad5272_i2c_is_busy(void);
int8_t ad5272_write_and_read_rdac (uint16_t data_16_to_write);
int16_t ad5272_read_rdac (void);
int8_t ad5272_write_rdac (uint16_t data_16_to_write);
void read_all_50tp (void);
void ad5272_RDAC_refresh(void);
void ad5272_shutdown_mode(void);
void ad5272_normal_mode(void);
#endif /* !_ADA5272_I2C_H_ */

112
project/ble_peripheral/ble_app_bladder_patch/ada2200_spi.c
View File

@@ -1,112 +0,0 @@
/*******************************************************************************
* @file ada2200_spi.c
* @author CandyPops Co.
* @version V1.0.0
* @date 2022-09-05
* @brief
******************************************************************************/
#include "sdk_common.h"
#include <stdbool.h>
#include "nrf.h"
#include "nrf_drv_gpiote.h"
#include "app_error.h"
#include "boards.h"
#include "nrf_drv_spi.h"
#include "nrf_delay.h"
#include "nrf_log.h"
#include "ada2200_spi.h"
static const nrf_drv_spi_t spi_ada2200 = NRF_DRV_SPI_INSTANCE(SPI_INSTANCE); /**< SPI instance. */
//static uint8_t ada2200_startR[] ={ 0x00, 0x00, 0x81 }; /* {addr 16bit, data}, Reset for Defaults */
static uint8_t ada2200_start0[] ={ 0x00, 0x00, 0x18 }; /* {addr 16bit, data}, Set SDIO input only, Activate SDO */
static uint8_t ada2200_start1[] ={ 0x00, 0x2B, 0x06 }; /* {addr 16bit, data}, Clock Configuration */
static uint8_t ada2200_start2[] ={ 0x00, 0x2A, 0x18 }; /* {addr 16bit, data}, Enable Mixer, Select SDO output for Pin 13, OFF RCLK. */
static uint8_t ada2200_start3[] ={ 0x00, 0x29, 0x23 }; /* 0x27 {addr 16bit, data}, Disable SYNCO output, Select SYNCO edge location (Sync timing adjustment) */
static uint8_t ada2200_start4[] ={ 0x00, 0x2C, 0x01 }; /* {addr 16bit, data}, Enable RCLK output */
static uint8_t ada2200_stop0[] ={ 0x00, 0x00, 0x18 }; /* {addr 16bit, data}, Set SDIO input only, Activate SDO */
static uint8_t ada2200_stop1[] ={ 0x00, 0x2B, 0x06 }; /* {addr 16bit, data}, Clock Configuration */
static uint8_t ada2200_stop2[] ={ 0x00, 0x2A, 0x10 }; /* {addr 16bit, data}, Enable Mixer, Select SDO output for Pin 13, OFF RCLK. */
static uint8_t ada2200_stop3[] ={ 0x00, 0x29, 0x01 }; /* 0x07 {addr 16bit, data}, Disable SYNCO output, Select SYNCO edge location (Sync timing adjustment) */
static uint8_t ada2200_stop4[] ={ 0x00, 0x2C, 0x00 }; /* {addr 16bit, data}, Enable RCLK output */
static uint8_t m_tx_buf[3]; /**< TX buffer. */
static uint8_t m_length = sizeof(m_tx_buf); /**< Transfer length. */
void ada2200_spi_write(const void * data, size_t size)
{
memcpy(m_tx_buf, data, size);
APP_ERROR_CHECK(nrf_drv_spi_transfer(&spi_ada2200, m_tx_buf, size, NULL, 0));
}
extern void ada2200_start(void)
{
//ada2200_spi_write(ada2200_startR, m_length);
ada2200_spi_write(ada2200_start0, m_length);
nrf_delay_us(2);
ada2200_spi_write(ada2200_start1, m_length);
nrf_delay_us(2);
ada2200_spi_write(ada2200_start2, m_length);
nrf_delay_us(2);
ada2200_spi_write(ada2200_start3, m_length);
nrf_delay_us(2);
ada2200_spi_write(ada2200_start4, m_length);
nrf_delay_us(2);
}
extern void ada2200_stop(void)
{
ada2200_spi_write(ada2200_stop0, m_length);
nrf_delay_us(2);
ada2200_spi_write(ada2200_stop1, m_length);
nrf_delay_us(2);
ada2200_spi_write(ada2200_stop2, m_length);
nrf_delay_us(2);
ada2200_spi_write(ada2200_stop3, m_length);
nrf_delay_us(2);
ada2200_spi_write(ada2200_stop4, m_length);
nrf_delay_us(2);
}
extern void ada2200_init(void)
{
nrf_drv_spi_config_t spi_config = NRF_DRV_SPI_DEFAULT_CONFIG;
spi_config.ss_pin = SPI_CS_PIN;
spi_config.miso_pin = SPI_MISO_PIN; /* Not USed */
spi_config.mosi_pin = SPI_MOSI_PIN;
spi_config.sck_pin = SPI_SCLK_PIN;
spi_config.frequency = NRF_DRV_SPI_FREQ_1M;
spi_config.mode = NRF_DRV_SPI_MODE_0;
spi_config.bit_order = NRF_DRV_SPI_BIT_ORDER_MSB_FIRST;
APP_ERROR_CHECK(nrf_drv_spi_init(&spi_ada2200, &spi_config, NULL, NULL));
}
extern void ada2200_uninit(void)
{
nrf_drv_spi_uninit(&spi_ada2200);
/* If SPIM2 is used: */
*(volatile uint32_t *)0x40023FFC = 0;
*(volatile uint32_t *)0x40023FFC;
*(volatile uint32_t *)0x40023FFC = 1;
nrf_gpio_cfg_default(SPI_CS_PIN);
nrf_gpio_cfg_default(SPI_MISO_PIN);
nrf_gpio_cfg_default(SPI_MOSI_PIN);
nrf_gpio_cfg_default(SPI_SCLK_PIN);
}

25
project/ble_peripheral/ble_app_bladder_patch/ada2200_spi.h
View File

@@ -1,25 +0,0 @@
/*******************************************************************************
* @file ada2200_spi.h
* @author CandyPops Co.
* @version V1.0.0
* @date 2022-09-05
* @brief
******************************************************************************/
#ifndef _ADA2200_SPI_H_
#define _ADA2200_SPI_H_
#define SPI_INSTANCE 2 /**< SPI instance index. */
#define SPI_MOSI_PIN 16
#define SPI_MISO_PIN 15 /* Not Used */
#define SPI_SCLK_PIN 14
#define SPI_CS_PIN 13
extern void ada2200_start(void);
extern void ada2200_stop(void);
extern void ada2200_init(void);
extern void ada2200_uninit(void);
#endif //_ADA2200_SPI_H_

11
project/ble_peripheral/ble_app_bladder_patch/battery_saadc.c
View File

@@ -22,7 +22,6 @@
//#include "fstorage.h"
#include "battery_saadc.h"
#include "main_timer.h"
#include "meas_pd_48.h"
#include <cmd_parse.h>
#include "debug_print.h"
#define BATTERY_REF_VOLTAGE_IN_MILLIVOLTS 600 /**< Reference voltage (in milli volts) used by ADC while doing conversion. */
@@ -52,8 +51,8 @@ bool low_battery_check = false;
extern bool info4; //cmd_parse
// cj add edit 25/11/24
extern volatile uint16_t info_p1;
extern volatile uint16_t info_p2;
volatile uint16_t info_p1;
volatile uint16_t info_p2;
extern char ble_tx_buffer[BLE_NUS_MAX_DATA_LEN];
@@ -63,7 +62,7 @@ extern volatile bool processing;
extern which_cmd_t cmd_type_t;
extern uint8_t ble_bin_buffer[BLE_NUS_MAX_DATA_LEN] ;
extern volatile uint16_t info_batt; //48_c
volatile uint16_t info_batt; //48_c
extern bool go_temp; //
extern bool go_batt; //cmd_parse
@@ -133,7 +132,7 @@ void pressure_all_event_handler(nrf_drv_saadc_evt_t const * p_event)
result_data[0] = p1_mV;
result_data[1] = p2_mV;
format_data(ble_bin_buffer, "rpn:", result_data,2);
binary_tx_handler(ble_bin_buffer,4);
dr_binary_tx_safe(ble_bin_buffer,4);
}
@@ -199,7 +198,7 @@ void battery_event_handler( nrf_drv_saadc_evt_t const * p_event )
single_format_data(ble_bin_buffer, "rsn:", batt_lvl_in_milli_volt_1);
binary_tx_handler(ble_bin_buffer,3);
dr_binary_tx_safe(ble_bin_buffer,3);
//data_tx_handler(ble_tx_buffer);
}
}

163
project/ble_peripheral/ble_app_bladder_patch/cat_i2c.c
View File

@@ -1,163 +0,0 @@
/*******************************************************************************
* @file cat_i2c.c
* @brief
******************************************************************************/
#include <stdio.h>
#include <string.h>
#include <stdarg.h>
#include <stdbool.h>
#include "nrf.h"
#include "app_error.h"
#include "boards.h"
#include "nrfx_gpiote.h"
#include "nrfx_twi.h"
#include "nrf_drv_twi.h"
#include "nrf_delay.h"
#include "cat_i2c.h"
#define CAT_I2C_ADDR 0x50
#define MAX_SERIAL_WRITE 16
//int16_t read_from_DS3930 = 0;
//uint16_t data_160_to_write = 0;
//static volatile bool m_xfer_done = false;
/* TWI instance. */
//const nrfx_twi_t m_twi_ir = NRFX_TWI_INSTANCE(IR_I2C_INSTANCE);
const nrf_drv_twi_t m_twi_cat = NRF_DRV_TWI_INSTANCE (CAT_I2C_INSTANCE);
//void twi_handler(nrfx_twi_evt_t const * p_event, void * p_context)
//{
// m_xfer_done = true;
//}
//void ir_irq_init(void){
// ret_code_t err_code;
// /* Initialize int pin */
// if (!nrfx_gpiote_is_init())
// {
// err_code = nrfx_gpiote_init();
// APP_ERROR_CHECK(err_code);
// }
// nrfx_gpiote_in_config_t in_config = NRFX_GPIOTE_CONFIG_IN_SENSE_LOTOHI(true);
// in_config.pull = NRF_GPIO_PIN_PULLDOWN;
// err_code = nrfx_gpiote_in_init(ADA2200_SYNCO_PIN, &in_config, NULL);
// APP_ERROR_CHECK(err_code);
// nrfx_gpiote_in_event_enable(ADA2200_SYNCO_PIN, true);
//}
//void ir_irq_uninit(void){
// nrfx_gpiote_in_event_disable(ADA2200_SYNCO_PIN);
// nrfx_gpiote_in_uninit(ADA2200_SYNCO_PIN);
//}
void cat_i2c_uninit(void){
nrf_drv_twi_disable(&m_twi_cat);
nrf_drv_twi_uninit(&m_twi_cat);
//
}
void cat_i2c_init(void){
ret_code_t err_code;
const nrf_drv_twi_config_t twi_cat_config = {
.scl = CAT_I2C_SCL_PIN,
.sda = CAT_I2C_SDA_PIN,
.frequency = NRF_DRV_TWI_FREQ_100K,
.interrupt_priority = APP_IRQ_PRIORITY_HIGH,
.clear_bus_init = false
};
err_code = nrf_drv_twi_init(&m_twi_cat, &twi_cat_config, NULL, NULL);
APP_ERROR_CHECK(err_code);
nrf_drv_twi_enable(&m_twi_cat);
// ir_irq_init();
}
uint8_t cat_command_read(uint8_t device_id, uint8_t address, uint8_t *data)
{
uint8_t read_data = 0;
char adata[8];
ret_code_t err_code;
//address = 1|(address<<1);
address = (address & 0xFF);
err_code = nrf_drv_twi_tx(&m_twi_cat, device_id, &address, 1, true);
if (err_code != NRF_SUCCESS) {
// Handle error
// return;
}
err_code = nrf_drv_twi_rx(&m_twi_cat, device_id, data, 8);
if (err_code != NRF_SUCCESS) {
// Handle error
return 0;
}
read_data = data[0];
memcpy(adata,data,8);
printf("Data %s . \r\n", adata);
return read_data;
}
void cat_command_write(uint8_t device_id, uint8_t address, uint8_t *data)
{
//uint16_t data_to_write = 0;
uint8_t buffer[9]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
address = (address & 0xFF);
//buffer[0] = 0x00;
buffer[0] = (address);
// buffer[1] =(data & 0xFF);
// buffer[2] = data1+1;
// buffer[3] = data1+2;
// buffer[4] = data1+3;
// buffer[5] = data1+4;
// buffer[6] = data1+5;
memcpy(&buffer[1], data, 8 );
ret_code_t err_code;
//err_code = nrf_drv_twi_tx(&m_twi_ir, device_id, 0x00, 1, false);
err_code = nrf_drv_twi_tx(&m_twi_cat, device_id, buffer, 9, false);
printf("Data %x %x %x %x. \r\n", buffer[0], buffer[1], buffer[2], buffer[3]);
printf("Data %s. \r\n", buffer);
//err_code = nrf_drv_twi_tx(&m_twi_ir, device_id, buffer, 6, false);
if (err_code != NRF_SUCCESS) {
printf("TWI Error.\r\n");
}
}

50
project/ble_peripheral/ble_app_bladder_patch/cat_i2c.h
View File

@@ -1,50 +0,0 @@
/*******************************************************************************
* @file ir_i2c.h
* @date 2024-07-17
******************************************************************************/
#ifndef _CAT_I2C_H_
#define _CAT_I2C_H_
#include "sdk_common.h"
#include <stdbool.h>
#include "nrf.h"
#include "nrf_drv_gpiote.h"
#define CAT_I2C_INSTANCE 0 /**< I2C instance index. */
#define CAT_I2C_SDA_PIN NRF_GPIO_PIN_MAP(1,15)
#define CAT_I2C_SCL_PIN NRF_GPIO_PIN_MAP(1,14)
//#define IR_I2C_SDA_PIN NRF_GPIO_PIN_MAP(0,25)
//#define IR_I2C_SCL_PIN NRF_GPIO_PIN_MAP(1,0)
/**
* COMMAND CONSTANTS
* Commands are 16-bit writes: bits 15:14 are 0s
* Bits 13:10 are the command value below
* Bits 9:0 are data for the command, but not all bits are used with all commands
*/
void cat_i2c_uninit(void);
void cat_i2c_init(void);
uint8_t cat_command_read(uint8_t device_id, uint8_t address, uint8_t *data);
void cat_command_write(uint8_t device_id, uint8_t address, uint8_t *data);
#endif /* !_ADA5272_I2C_H_ */

522
project/ble_peripheral/ble_app_bladder_patch/cat_interface.c
View File

@@ -1,522 +0,0 @@
/*******************************************************************************
* @file cat_interface.c
* @brief
******************************************************************************/
/* board driver */
#include <stdio.h>
#include <string.h>
#include <stdarg.h>
#include <stdbool.h>
#include "nrf.h"
#include "app_error.h"
#include "boards.h"
#include "nrfx_gpiote.h"
#include "nrfx_twi.h"
#include "nrf_crypto.h"
#include "nrf_crypto_aes.h"
#include "nrf_drv_twi.h"
#include "system_interface.h"
#include "nrf_delay.h"
#include "cat_interface.h"
#include "debug_print.h"
/* I2C number and slave address for INV device */
#define ICM_I2C_ADDR 0x68
#define INV_MAX_SERIAL_WRITE 16
#define EEPROM_I2C_ADDRESS 0x50
#define EEPROM_PAGE_SIZE 64
#define EEPROM_INSTANCE 0
#define AES_BLOCK_SIZE 16
static uint8_t aes_key[16] = {
0x60, 0x3d, 0xeb, 0x10, 0x15, 0xca, 0x71, 0xbe,
0x2b, 0x73, 0xae, 0xf0, 0x85, 0x7d, 0x77, 0x81
};
static uint8_t aes_iv[16] = { 0 }; // Fixed IV for simplicity
const nrfx_twi_t m_eeprom = NRFX_TWI_INSTANCE(EEPROM_INSTANCE);
ret_code_t encrypt_data(const uint8_t *input, size_t length, uint8_t *output, size_t *output_len) {
nrf_crypto_aes_context_t aes_ctx;
size_t padded_len = ((length + AES_BLOCK_SIZE - 1) / AES_BLOCK_SIZE) * AES_BLOCK_SIZE;
uint8_t buffer[padded_len];
memcpy(buffer, input, length);
memset(&buffer[length], 0, padded_len - length); // Zero padding
ret_code_t err = nrf_crypto_aes_init(&aes_ctx, &g_nrf_crypto_aes_cbc_128_info, NRF_CRYPTO_ENCRYPT);
VERIFY_SUCCESS(err);
err = nrf_crypto_aes_key_set(&aes_ctx, aes_key);
VERIFY_SUCCESS(err);
err = nrf_crypto_aes_iv_set(&aes_ctx, aes_iv);
VERIFY_SUCCESS(err);
*output_len = padded_len;
err = nrf_crypto_aes_finalize(&aes_ctx, buffer, padded_len, output, output_len);
return err;
}
ret_code_t decrypt_data(const uint8_t *input, size_t length, uint8_t *output) {
nrf_crypto_aes_context_t aes_ctx;
uint8_t input_copy[length];
memcpy(input_copy, input, length);
ret_code_t err = nrf_crypto_aes_init(&aes_ctx, &g_nrf_crypto_aes_cbc_128_info, NRF_CRYPTO_DECRYPT);
VERIFY_SUCCESS(err);
err = nrf_crypto_aes_key_set(&aes_ctx, aes_key);
VERIFY_SUCCESS(err);
err = nrf_crypto_aes_iv_set(&aes_ctx, aes_iv);
VERIFY_SUCCESS(err);
size_t output_len = length;
err = nrf_crypto_aes_finalize(&aes_ctx, input_copy, length, output, &output_len);
return err;
}
ret_code_t eeprom_write_encrypted(uint16_t mem_address, const uint8_t *plaintext, size_t length) {
uint8_t encrypted_buf[256]; // Adjust if needed
size_t encrypted_len = 0;
ret_code_t err = encrypt_data(plaintext, length, encrypted_buf, &encrypted_len);
VERIFY_SUCCESS(err);
return eeprom_write_bytes(mem_address, encrypted_buf, encrypted_len);
}
ret_code_t eeprom_read_decrypted(uint16_t mem_address, uint8_t *plaintext, size_t original_length) {
size_t encrypted_len = ((original_length + AES_BLOCK_SIZE - 1) / AES_BLOCK_SIZE) * AES_BLOCK_SIZE;
uint8_t encrypted_buf[256]; // Adjust as needed
ret_code_t err = eeprom_read_bytes(mem_address, encrypted_buf, encrypted_len);
VERIFY_SUCCESS(err);
return decrypt_data(encrypted_buf, encrypted_len, plaintext);
}
void eeprom_uninitialize(void){
nrfx_twi_disable(&m_eeprom);
nrfx_twi_uninit(&m_eeprom);
}
void eeprom_initialize(void){
ret_code_t err_code;
const nrfx_twi_config_t eeprom_config = {
.scl = ICM42670_I2C_SCL_PIN,
.sda = ICM42670_I2C_SDA_PIN,
.frequency = NRF_TWI_FREQ_400K,
.interrupt_priority = APP_IRQ_PRIORITY_HIGH,
};
err_code = nrfx_twi_init(&m_eeprom, &eeprom_config, NULL, NULL);
APP_ERROR_CHECK(err_code);
nrfx_twi_enable(&m_eeprom);
}
ret_code_t eeprom_write_page(uint16_t mem_address, const uint8_t *data)
{
uint8_t buffer[2 + EEPROM_PAGE_SIZE]; // 2 bytes for address + 64 bytes data
ret_code_t ret;
buffer[0] = (uint8_t)(mem_address >> 8); // MSB
buffer[1] = (uint8_t)(mem_address & 0xFF); // LSB
memcpy(&buffer[2], data, EEPROM_PAGE_SIZE);
ret = icm42670_twi_tx(EEPROM_I2C_ADDRESS, buffer, 2 + EEPROM_PAGE_SIZE, false);
if (ret != NRF_SUCCESS) {
DBG_PRINTF("EEPROM write failed (code: %d)\n", ret);
return ret;
}
// Wait for internal EEPROM write cycle (typically ~5ms)
for (int i = 0; i < 100; i++) {
ret = icm42670_twi_tx(EEPROM_I2C_ADDRESS, NULL, 0, false);
if (ret == NRF_SUCCESS)
break;
nrf_delay_us(100); // Wait 100us before retry
}
return NRF_SUCCESS;
}
ret_code_t eeprom_write_uint16_array(uint16_t start_address, const uint16_t *data, size_t count)
{
if (count != 48) {
DBG_PRINTF("Error: This function is only for writing exactly 48 uint16_t values.\n");
return NRF_ERROR_INVALID_PARAM;
}
if (start_address < 128) {
DBG_PRINTF("Error: This function is only for after 192....\n");
return NRF_ERROR_INVALID_PARAM;
}
uint8_t buffer[EEPROM_PAGE_SIZE];
ret_code_t ret;
// Write first 32 uint16_t values (64 bytes)
for (size_t i = 0; i < 32; i++) {
buffer[i * 2] = (uint8_t)(data[i] >> 8); // MSB
buffer[i * 2 + 1] = (uint8_t)(data[i] & 0xFF); // LSB
// buffer[i * 2 +1] = (uint8_t)(data[i] >> 8); // MSB
// buffer[i * 2 ] = (uint8_t)(data[i] & 0xFF); // LSB
}
ret = eeprom_write_page(start_address, buffer);
if (ret != NRF_SUCCESS) {
return ret;
}
// Write remaining 16 uint16_t values (32 bytes)
for (size_t i = 0; i < 16; i++) {
buffer[i * 2] = (uint8_t)(data[i + 32] >> 8);
buffer[i * 2 + 1] = (uint8_t)(data[i + 32] & 0xFF);
}
ret = eeprom_write_page(start_address + EEPROM_PAGE_SIZE, buffer); // next page
return ret;
}
ret_code_t eeprom_read_uint16_array(uint16_t start_address, uint16_t *data, size_t count)
{
if (count != 48) {
DBG_PRINTF("Error: This function is only for reading exactly 48 uint16_t values.\n");
return NRF_ERROR_INVALID_PARAM;
}
uint8_t buffer[EEPROM_PAGE_SIZE];
ret_code_t ret;
// Read first 64 bytes (32 uint16_t)
ret = eeprom_read_bytes(start_address, buffer, EEPROM_PAGE_SIZE);
if (ret != NRF_SUCCESS) {
return ret;
}
for (size_t i = 0; i < 32; i++) {
data[i] = ((uint16_t)buffer[i * 2] << 8) | buffer[i * 2 + 1];
}
// Read next 32 bytes (16 uint16_t)
ret = eeprom_read_bytes(start_address + EEPROM_PAGE_SIZE, buffer, 32);
if (ret != NRF_SUCCESS) {
return ret;
}
for (size_t i = 0; i < 16; i++) {
data[i + 32] = ((uint16_t)buffer[i * 2] << 8) | buffer[i * 2 + 1];
}
return NRF_SUCCESS;
}
ret_code_t eeprom_read_page(uint16_t mem_address, uint8_t *data)
{
uint8_t addr_buf[2];
ret_code_t ret;
addr_buf[0] = (uint8_t)(mem_address >> 8);
addr_buf[1] = (uint8_t)(mem_address & 0xFF);
// Send memory address first
ret = icm42670_twi_tx(EEPROM_I2C_ADDRESS, addr_buf, 2, true);
if (ret != NRF_SUCCESS) {
DBG_PRINTF("EEPROM set read address failed (code: %d)\n", ret);
return ret;
}
// Read the page
ret = icm42670_twi_rx(EEPROM_I2C_ADDRESS, data, EEPROM_PAGE_SIZE);
if (ret != NRF_SUCCESS) {
DBG_PRINTF("EEPROM read failed (code: %d)\n", ret);
return ret;
}
DBG_PRINTF("EEPROM read \n");
for (int i = 0; i < EEPROM_PAGE_SIZE; i++) {
DBG_PRINTF("%02X\n", data[i]);
}
DBG_PRINTF("\r\n");
return NRF_SUCCESS;
}
ret_code_t eeprom_write_byte(uint16_t mem_address, uint8_t data)
{
uint8_t buffer[3]; // 2 bytes for address + 1 byte data
ret_code_t ret;
buffer[0] = (uint8_t)(mem_address >> 8); // MSB of address
buffer[1] = (uint8_t)(mem_address & 0xFF); // LSB of address
buffer[2] = data;
DBG_PRINTF("EEPROM write byte %02X,%02X,%02X\n", buffer[0], buffer[1], buffer[2]);
ret = icm42670_twi_tx(EEPROM_I2C_ADDRESS, buffer, 3, false);
if (ret != NRF_SUCCESS) {
DBG_PRINTF("EEPROM write byte failed (code: %d)\n", ret);
return ret;
}
// Wait for internal EEPROM write cycle (typically ~5ms)
for (int i = 0; i < 100; i++) {
ret = icm42670_twi_tx(EEPROM_I2C_ADDRESS, NULL, 0, false);
if (ret == NRF_SUCCESS)
break;
nrf_delay_us(100); // Wait 100us before retry
}
return NRF_SUCCESS;
}
ret_code_t eeprom_read_byte(uint16_t mem_address, uint8_t *data)
{
uint8_t addr_buf[2];
ret_code_t ret;
addr_buf[0] = (uint8_t)(mem_address >> 8); // MSB of address
addr_buf[1] = (uint8_t)(mem_address & 0xFF); // LSB of address
// Send memory address
ret = icm42670_twi_tx(EEPROM_I2C_ADDRESS, addr_buf, 2, true);
if (ret != NRF_SUCCESS) {
DBG_PRINTF("EEPROM set address failed (code: %d)\n", ret);
return ret;
}
// Read 1 byte
ret = icm42670_twi_rx(EEPROM_I2C_ADDRESS, data, 1);
if (ret != NRF_SUCCESS) {
DBG_PRINTF("EEPROM read byte failed (code: %d)\n", ret);
return ret;
}
return NRF_SUCCESS;
}
ret_code_t eeprom_write_bytes(uint16_t mem_address, const uint8_t *data, size_t length)
{
ret_code_t ret;
size_t bytes_written = 0;
while (bytes_written < length) {
size_t page_offset = mem_address % EEPROM_PAGE_SIZE;
size_t bytes_to_write = EEPROM_PAGE_SIZE - page_offset;
if (bytes_to_write > (length - bytes_written)) {
bytes_to_write = length - bytes_written;
}
uint8_t buffer[2 + EEPROM_PAGE_SIZE]; // 2-byte addr + up to 64 data bytes
buffer[0] = (uint8_t)(mem_address >> 8);
buffer[1] = (uint8_t)(mem_address & 0xFF);
memcpy(&buffer[2], &data[bytes_written], bytes_to_write);
ret = icm42670_twi_tx(EEPROM_I2C_ADDRESS, buffer, bytes_to_write + 2, false);
if (ret != NRF_SUCCESS) {
DBG_PRINTF("EEPROM write error at addr 0x%04X\n", mem_address);
return ret;
}
// Wait for internal EEPROM write cycle (typically ~5ms)
for (int i = 0; i < 100; i++) {
ret = icm42670_twi_tx(EEPROM_I2C_ADDRESS, NULL, 0, false);
if (ret == NRF_SUCCESS)
break;
nrf_delay_us(100); // Wait 100us before retry
}
mem_address += bytes_to_write;
bytes_written += bytes_to_write;
}
return NRF_SUCCESS;
}
ret_code_t eeprom_read_bytes(uint16_t mem_address, uint8_t *data, size_t length)
{
ret_code_t ret;
uint8_t addr_buf[2];
addr_buf[0] = (uint8_t)(mem_address >> 8);
addr_buf[1] = (uint8_t)(mem_address & 0xFF);
ret = icm42670_twi_tx(EEPROM_I2C_ADDRESS, addr_buf, 2, true); // send addr, no stop
if (ret != NRF_SUCCESS) {
DBG_PRINTF("EEPROM read set address failed\n");
return ret;
}
ret = icm42670_twi_rx(EEPROM_I2C_ADDRESS, data, length);
if (ret != NRF_SUCCESS) {
DBG_PRINTF("EEPROM read failed\n");
return ret;
}
return NRF_SUCCESS;
}
ret_code_t eeprom_write_word(uint16_t mem_address, uint16_t data)
{
uint8_t buffer[4]; // 2 bytes for address + 2 bytes for data
ret_code_t ret;
buffer[0] = (uint8_t)(mem_address >> 8); // MSB of address
buffer[1] = (uint8_t)(mem_address & 0xFF); // LSB of address
buffer[2] = (uint8_t)(data & 0xFF); // LSB of data
buffer[3] = (uint8_t)(data >> 8); // MSB of data
DBG_PRINTF("EEPROM write word %02X,%02X,%02X,%02X\n", buffer[0], buffer[1], buffer[2], buffer[3]);
ret = icm42670_twi_tx(EEPROM_I2C_ADDRESS, buffer, 4, false);
if (ret != NRF_SUCCESS) {
DBG_PRINTF("EEPROM write word failed (code: %d)\n", ret);
return ret;
}
// Wait for internal write cycle (~5ms typical)
for (int i = 0; i < 100; i++) {
ret = icm42670_twi_tx(EEPROM_I2C_ADDRESS, NULL, 0, false);
if (ret == NRF_SUCCESS)
break;
nrf_delay_us(100); // 100us delay between polling
}
return NRF_SUCCESS;
}
ret_code_t eeprom_read_word(uint16_t mem_address, uint16_t *data)
{
uint8_t addr_buf[2];
uint8_t read_buf[2];
ret_code_t ret;
addr_buf[0] = (uint8_t)(mem_address >> 8);
addr_buf[1] = (uint8_t)(mem_address & 0xFF);
ret = icm42670_twi_tx(EEPROM_I2C_ADDRESS, addr_buf, 2, true);
if (ret != NRF_SUCCESS) {
DBG_PRINTF("EEPROM set address for word read failed (code: %d)\n", ret);
return ret;
}
ret = icm42670_twi_rx(EEPROM_I2C_ADDRESS, read_buf, 2);
if (ret != NRF_SUCCESS) {
DBG_PRINTF("EEPROM read word failed (code: %d)\n", ret);
return ret;
}
*data = ((uint16_t)read_buf[1] << 8) | read_buf[0]; // Little-endian
return NRF_SUCCESS;
}
ret_code_t eeprom_write_uint32(uint16_t mem_address, uint32_t data)
{
uint8_t buffer[6]; // 2 bytes address + 4 bytes data
ret_code_t ret;
buffer[0] = (uint8_t)(mem_address >> 8); // MSB of address
buffer[1] = (uint8_t)(mem_address & 0xFF); // LSB of address
buffer[2] = (uint8_t)(data >> 24);
buffer[3] = (uint8_t)(data >> 16);
buffer[4] = (uint8_t)(data >> 8);
buffer[5] = (uint8_t)(data);
DBG_PRINTF("EEPROM write uint32: %02X %02X %02X %02X %02X %02X\n",
buffer[0], buffer[1], buffer[2], buffer[3], buffer[4], buffer[5]);
ret = icm42670_twi_tx(EEPROM_I2C_ADDRESS, buffer, 6, false);
if (ret != NRF_SUCCESS) {
DBG_PRINTF("EEPROM write uint32 failed (code: %d)\n", ret);
return ret;
}
// Wait for internal EEPROM write cycle
for (int i = 0; i < 100; i++) {
ret = icm42670_twi_tx(EEPROM_I2C_ADDRESS, NULL, 0, false);
if (ret == NRF_SUCCESS)
break;
nrf_delay_us(100);
}
return NRF_SUCCESS;
}
ret_code_t eeprom_read_uint32(uint16_t mem_address, uint32_t *data)
{
uint8_t addr_buf[2];
uint8_t data_buf[4];
ret_code_t ret;
addr_buf[0] = (uint8_t)(mem_address >> 8);
addr_buf[1] = (uint8_t)(mem_address & 0xFF);
DBG_PRINTF("EEPROM address:%02X,%02X \n",addr_buf[0],addr_buf[1]);
// Send memory address to read from
ret = icm42670_twi_tx(EEPROM_I2C_ADDRESS, addr_buf, 2, true);
if (ret != NRF_SUCCESS) {
DBG_PRINTF("EEPROM read (addr phase) failed (code: %d)\n", ret);
return ret;
}
// Read 4 bytes of data
ret = icm42670_twi_rx(EEPROM_I2C_ADDRESS, data_buf, 4);
if (ret != NRF_SUCCESS) {
DBG_PRINTF("EEPROM read (data phase) failed (code: %d)\n", ret);
return ret;
}
*data = ((uint32_t)data_buf[0] << 24) |
((uint32_t)data_buf[1] << 16) |
((uint32_t)data_buf[2] << 8) |
((uint32_t)data_buf[3]);
DBG_PRINTF("EEPROM read uint32: %02X %02X %02X %02X -> %08X\n",
data_buf[0], data_buf[1], data_buf[2], data_buf[3], *data);
return NRF_SUCCESS;
}

66
project/ble_peripheral/ble_app_bladder_patch/cat_interface.h
View File

@@ -1,66 +0,0 @@
/*******************************************************************************
* @file app_raw_main.h
******************************************************************************/
#ifndef _CAT_INTERFACE_H_
#define _CAT_INTERFACE_H_
#include "sdk_config.h"
#include <stdio.h>
#include <string.h>
#include <stdarg.h>
#include <stdint.h>
#include <stdlib.h>
#include "nordic_common.h"
#include "nrf.h"
#include "sdk_errors.h"
#define EEPROM_I2C_ADDRESS 0x50
#define EEPROM_PAGE_SIZE 64
#define SERIAL_ADDRESS 0x0030
ret_code_t encrypt_data(const uint8_t *input, size_t length, uint8_t *output, size_t *output_len);
ret_code_t decrypt_data(const uint8_t *input, size_t length, uint8_t *output);
ret_code_t eeprom_write_encrypted(uint16_t mem_address, const uint8_t *plaintext, size_t length);
ret_code_t eeprom_read_decrypted(uint16_t mem_address, uint8_t *plaintext, size_t original_length);
ret_code_t eeprom_read_page(uint16_t mem_address, uint8_t *data);
ret_code_t eeprom_write_page(uint16_t mem_address, const uint8_t *data);
ret_code_t eeprom_write_byte(uint16_t mem_address, uint8_t data);
ret_code_t eeprom_read_byte(uint16_t mem_address, uint8_t *data);
ret_code_t eeprom_write_bytes(uint16_t mem_address, const uint8_t *data, size_t length);
ret_code_t eeprom_read_bytes(uint16_t mem_address, uint8_t *data, size_t length);
ret_code_t eeprom_write_uint16_array(uint16_t start_address, const uint16_t *data, size_t count);
ret_code_t eeprom_read_uint16_array(uint16_t start_address, uint16_t *data, size_t count);
ret_code_t eeprom_write_word(uint16_t mem_address, uint16_t data);
ret_code_t eeprom_read_word(uint16_t mem_address, uint16_t *data);
void eeprom_uninitialize(void);
void eeprom_initialize(void);
ret_code_t eeprom_write_uint32(uint16_t mem_address, uint32_t data);
ret_code_t eeprom_read_uint32(uint16_t mem_address, uint32_t *data);
#endif /* */

1515
project/ble_peripheral/ble_app_bladder_patch/cmd/dr_adc121s051.c
View File

File diff suppressed because it is too large Load Diff

505
project/ble_peripheral/ble_app_bladder_patch/cmd/dr_adc121s051.h
View File

@@ -1,505 +0,0 @@
/*******************************************************************************
* @file dr_adc121s051.h
* @brief ADC121S051 12-bit ADC Driver for nRF52840
* For 1.2MHz Piezo Echo Envelope Detection
* @author Charles KWON
* @date 2025-12-15
*
* @details This driver reads the envelope-detected DC level from piezo echo.
*
* Signal Flow:
*
* [Piezo TX] [Echo RX] [Envelope] [ADC] [MCU]
* 1.2MHz --> Reflect --> Detector --> DC Level --> Digital
* burst signal (hardware) reading value
*
* The envelope detector circuit converts the 1.2MHz echo burst
* into a DC voltage proportional to the echo amplitude.
* ADC samples this DC level for amplitude measurement.
*
* @note Hardware: Texas Instruments ADC121S051
* - 12-bit resolution (0-4095)
* - Sample rate: 200-500 ksps
* - Input range: 0V to VA
* - SPI interface (software bit-bang)
******************************************************************************/
#ifndef DR_ADC121S051_H
#define DR_ADC121S051_H
#include <stdint.h>
#include <stdbool.h>
#include "nrf_gpio.h"
/*==============================================================================
* PIN CONFIGURATION
*
* WARNING: Never hardcode pin numbers!
* Hardcoding may save a developer's time momentarily,
* but it will also shorten their lifespan.
*============================================================================*/
#define DR_ADC_PIN_SCLK NRF_GPIO_PIN_MAP(0, 14) /**< Serial Clock */
#define DR_ADC_PIN_SDATA NRF_GPIO_PIN_MAP(0, 15) /**< Serial Data (MISO) */
#define DR_ADC_PIN_CS NRF_GPIO_PIN_MAP(0, 19) /**< Chip Select P0.13 -> P0.19 */
/*==============================================================================
* ADC SPECIFICATIONS
*============================================================================*/
#define DR_ADC_RESOLUTION 12 /**< Bits */
#define DR_ADC_MAX_VALUE 4095 /**< 2^12 - 1 */
#define DR_ADC_VREF_MV 3300 /**< Reference voltage (mV) */
/*==============================================================================
* ECHO DETECTION CONFIGURATION
*
* Bladder Measurement Requirements:
* - Target measurement range: 20cm (200mm)
* - SCLK frequency: 8.6MHz (bit-bang SPI)
* - ADC121S051 requires 16 SCLK cycles per sample
* - Actual sample rate: 8.6MHz / 16 = 0.5375MHz = 537.5kHz
* - Actual sample interval: 16 / 8.6MHz = 1.86us
* - Sound speed in tissue: 1540m/s = 1.54mm/us
*
* Formula: samples = distance(mm) * 2 / (1.86us * 1.54mm/us)
* = distance(mm) * 2 / 2.86
* = distance(mm) * 0.7
*
* 10cm = 100mm -> 100 * 0.7 = 70 samples (round-trip 130us)
* 17cm = 170mm -> 170 * 0.7 = 119 samples (round-trip 221us)
* 20cm = 200mm -> 200 * 0.7 = 140 samples (round-trip 260us)
*
* Buffer size: 200 samples * 2 bytes = 400 bytes (RAM 256KB, OK)
* BLE transmission: 140 samples * 2 bytes = 280 bytes (16-bit raw, no packing)
*============================================================================*/
#define DR_ADC_SCLK_MHZ 8.6f /**< SPI bit-bang SCLK frequency */
#define DR_ADC_CLOCKS_PER_SAMPLE 16 /**< ADC121S051: 16 SCLK per sample */
#define DR_ADC_ECHO_SAMPLES_MAX 200 /**< Maximum samples (20cm+ with margin) */
#define DR_ADC_ECHO_SAMPLES_DEFAULT 140 /**< Default samples (20cm depth target) */
#define DR_ADC_SAMPLE_INTERVAL_US 1.86f /**< 16 / 8.6MHz = 1.86us per sample */
#define DR_ADC_SOUND_SPEED_MM_US 1.54f /**< Sound speed in tissue (mm/us) */
/*==============================================================================
* ERROR CODES
*============================================================================*/
typedef enum {
DR_ADC_OK = 0,
DR_ADC_ERR_NOT_INIT,
DR_ADC_ERR_INVALID_PARAM,
DR_ADC_ERR_NO_ECHO
} dr_adc_err_t;
/*==============================================================================
* DATA STRUCTURES
*============================================================================*/
/**
* @brief Single ADC reading result
*/
typedef struct {
uint16_t raw; /**< Raw 12-bit value (0-4095) */
uint32_t voltage_mv; /**< Voltage in millivolts */
} dr_adc_result_t;
/**
* @brief Echo measurement result
*/
typedef struct {
uint16_t peak_raw; /**< Peak amplitude (raw) */
uint32_t peak_mv; /**< Peak amplitude (mV) */
uint16_t peak_index; /**< Sample index of peak */
uint32_t peak_time_us; /**< Time to peak (us) */
uint16_t baseline_raw; /**< Baseline level before echo */
uint16_t num_samples; /**< Number of samples captured */
} dr_adc_echo_t;
/**
* @brief Echo capture configuration
*/
typedef struct {
uint16_t num_samples; /**< Samples to capture (1-200) */
uint16_t threshold_raw; /**< Minimum peak threshold */
uint16_t delay_us; /**< Delay before capture starts */
} dr_adc_echo_config_t;
/*==============================================================================
* INITIALIZATION
*============================================================================*/
/**
* @brief Initialize ADC driver
* @return dr_adc_err_t Error code
*/
dr_adc_err_t dr_adc_init(void);
/**
* @brief Uninitialize ADC driver
*/
void dr_adc_uninit(void);
/**
* @brief Check if initialized
*/
bool dr_adc_is_initialized(void);
/*==============================================================================
* BASIC READ FUNCTIONS
*============================================================================*/
/**
* @brief Read single ADC value
* @param result Pointer to result structure
* @return dr_adc_err_t Error code
*/
dr_adc_err_t dr_adc_read(dr_adc_result_t *result);
/**
* @brief Read raw 12-bit value only
* @param raw_value Pointer to store value
* @return dr_adc_err_t Error code
*/
dr_adc_err_t dr_adc_read_raw(uint16_t *raw_value);
/**
* @brief Read averaged value
* @param result Pointer to result structure
* @param num_samples Number of samples to average (1-256)
* @return dr_adc_err_t Error code
*/
dr_adc_err_t dr_adc_read_averaged(dr_adc_result_t *result, uint16_t num_samples);
/*==============================================================================
* ECHO DETECTION FUNCTIONS
*============================================================================*/
/**
* @brief Capture echo envelope after piezo burst
* @param buffer Array to store samples (must be pre-allocated)
* @param num_samples Number of samples to capture
* @return dr_adc_err_t Error code
*
* @note Call this immediately after dr_piezo_burst_sw()
*/
dr_adc_err_t dr_adc_capture_echo(uint16_t *buffer, uint16_t num_samples);
/**
* @brief Capture and analyze echo in one call
* @param echo Pointer to echo result structure
* @param config Pointer to capture configuration (NULL for defaults)
* @return dr_adc_err_t Error code
*/
dr_adc_err_t dr_adc_measure_echo(dr_adc_echo_t *echo, const dr_adc_echo_config_t *config);
/**
* @brief Piezo burst + Echo capture in one call
* @param cycles Number of burst cycles (3~9)
* @param delay_us Delay before capture (us)
* @param num_samples Number of samples to capture
* @param echo Pointer to echo result structure
* @return dr_adc_err_t Error code
*/
dr_adc_err_t dr_adc_burst_and_capture(uint8_t cycles, uint16_t delay_us,
uint16_t num_samples, dr_adc_echo_t *echo);
/**
* @brief Get pointer to last captured echo buffer
* @return Pointer to internal buffer (valid until next capture)
* @note Buffer contains num_samples values from last burst_and_capture call
*/
const uint16_t* dr_adc_get_echo_buffer(void);
/**
* @brief Analyze captured echo buffer
* @param buffer Sample buffer
* @param num_samples Number of samples in buffer
* @param echo Pointer to echo result structure
* @param threshold Minimum threshold for valid peak
* @return dr_adc_err_t Error code
*/
dr_adc_err_t dr_adc_analyze_echo(const uint16_t *buffer, uint16_t num_samples,
dr_adc_echo_t *echo, uint16_t threshold);
/**
* @brief Find peak in buffer
* @param buffer Sample buffer
* @param num_samples Number of samples
* @param peak_value Pointer to store peak value
* @param peak_index Pointer to store peak index (can be NULL)
*/
void dr_adc_find_peak(const uint16_t *buffer, uint16_t num_samples,
uint16_t *peak_value, uint16_t *peak_index);
/**
* @brief Calculate baseline (average of first N samples)
* @param buffer Sample buffer
* @param num_samples Number of samples to average for baseline
* @return Baseline value
*/
uint16_t dr_adc_calc_baseline(const uint16_t *buffer, uint16_t num_samples);
/*==============================================================================
* UTILITY FUNCTIONS
*============================================================================*/
/**
* @brief Convert raw value to millivolts
* @param raw_value Raw 12-bit value
* @return Voltage in millivolts
*/
uint32_t dr_adc_raw_to_mv(uint16_t raw_value);
/**
* @brief Set reference voltage
* @param vref_mv Reference voltage in millivolts
*/
void dr_adc_set_vref(uint32_t vref_mv);
/**
* @brief Get reference voltage
* @return Reference voltage in millivolts
*/
uint32_t dr_adc_get_vref(void);
/*==============================================================================
* DEBUG FUNCTIONS
*============================================================================*/
/**
* @brief Test ADC communication
* @return true if OK
*/
bool dr_adc_test(void);
/**
* @brief Print echo buffer to debug output
* @param buffer Sample buffer
* @param num_samples Number of samples
*/
void dr_adc_print_buffer(const uint16_t *buffer, uint16_t num_samples);
/*==============================================================================
* POWER CONTROL
*============================================================================*/
/*==============================================================================
* BLE TRANSMISSION CALLBACK
*============================================================================*/
/*==============================================================================
* INTEGRATED BURST + CAPTURE + TRANSMIT
*============================================================================*/
/**
* @brief Piezo burst + ADC capture + BLE transmission (all-in-one)
*
* This function performs the complete measurement cycle internally:
* 1. Power on ADC
* 2. Select piezo channel (0~7)
* 3. Execute piezo burst (frequency based on freq_option)
* 4. Capture echo samples (after delay_us) - repeated 'averaging' times
* 5. Average the captured samples (firmware-level noise reduction)
* 6. Analyze peak/baseline
* 7. Transmit data via BLE with proper packet timing
*
* @param freq_option Frequency option: 0=1.8MHz (default), 1=2.1MHz, 2=2.0MHz, 3=1.7MHz
* @param delay_us Delay before capture (us), default 20
* @param num_samples Number of samples to capture (1~200)
* @param cycles Number of burst cycles (3~7), default 5
* @param averaging Number of measurements to average (1~1000), default 1
* @param piezo_ch Piezo channel to use (0~7), default 0
* @param ble_buffer Working buffer for BLE packets (must be >= 240 bytes)
* @return dr_adc_err_t Error code
*
* @note Must call dr_adc_register_ble_tx() before using this function
* @note BLE packets: reb: (header), red: (data), ree: (end)
* @note Higher averaging reduces noise but increases measurement time (~0.3ms per avg)
*/
dr_adc_err_t dr_adc_burst_capture_transmit(uint8_t freq_option, uint16_t delay_us,
uint16_t num_samples, uint8_t cycles,
uint16_t averaging, uint8_t piezo_ch,
uint8_t *ble_buffer, uint8_t skip_raa);
/**
* @brief Select piezo channel (0~7)
* @param channel Piezo channel number (0~7)
*
* @note Hardware-dependent: requires MUX or individual GPIO control
* Currently uses placeholder - implement based on actual hardware
*/
void dr_piezo_select_channel(uint8_t channel);
/*==============================================================================
* 4-CHANNEL CAPTURE (maa? command support)
*============================================================================*/
/**
* @brief 8-channel echo buffer for maa? command
* Memory: 140 samples × 2 bytes × 8 channels = 2,240 bytes
*/
#define MAA_NUM_CHANNELS 8 /* 4 -> 8 jhChun 26.02.12*/
#define MAA_SAMPLES_MAX 200
/**
* @brief Echo data for one channel
*/
typedef struct {
uint16_t samples[MAA_SAMPLES_MAX]; /**< Raw sample data */
uint16_t num_samples; /**< Actual sample count */
uint16_t peak_raw; /**< Peak amplitude */
uint16_t peak_index; /**< Peak sample index */
uint16_t baseline_raw; /**< Baseline level */
} dr_maa_channel_t;
/**
* @brief Capture echo from one channel (no BLE transmission)
*
* Captures averaged echo data for a single channel and stores
* in the provided channel buffer. Does NOT transmit via BLE.
*
* @param freq_option Frequency: 0=1.8MHz, 1=2.1MHz, 2=2.0MHz, 3=1.7MHz
* @param delay_us Delay before capture (us)
* @param num_samples Number of samples (1~200)
* @param cycles Burst cycles (3~7)
* @param averaging Number of averages (1~1000)
* @param piezo_ch Piezo channel (0~7)
* @param out_channel Output channel data structure
* @return dr_adc_err_t Error code
*/
dr_adc_err_t dr_adc_capture_channel_only(uint8_t freq_option, uint16_t delay_us,
uint16_t num_samples, uint8_t cycles,
uint16_t averaging, uint8_t piezo_ch,
dr_maa_channel_t *out_channel);
/**
* @brief Transmit captured channel data via BLE
*
* Sends previously captured channel data using reb:/red:/ree: protocol.
*
* @param ch_data Pointer to captured channel data
* @param ble_buffer Working buffer for BLE packets (>= 240 bytes)
* @return dr_adc_err_t Error code
*/
dr_adc_err_t dr_adc_transmit_channel(const dr_maa_channel_t *ch_data,
uint8_t *ble_buffer);
/*==============================================================================
* DELTA COMPRESSION (maa? mode=1)
*
* Format:
* Byte 0-1: First sample (16-bit, little endian)
* Byte 2+: Delta values (8-bit signed)
* If delta > 127 or < -127: escape (0x80) + 16-bit value
*
* Expected compression: ~50% (280 bytes -> ~140 bytes)
*============================================================================*/
#define DELTA_ESCAPE_BYTE 0x80 /**< Escape marker for out-of-range delta */
/**
* @brief Compress sample data using delta encoding
*
* @param samples Input sample array (16-bit values)
* @param num_samples Number of samples
* @param out_buffer Output buffer for compressed data
* @param out_size Output: number of bytes written
* @return dr_adc_err_t Error code
*/
dr_adc_err_t dr_adc_delta_compress(const uint16_t *samples, uint16_t num_samples,
uint8_t *out_buffer, uint16_t *out_size);
/**
* @brief Transmit captured channel data via BLE with delta compression
*
* Uses rdb:/rdd:/rde: protocol (delta variant of reb:/red:/ree:)
*
* @param ch_data Pointer to captured channel data
* @param ble_buffer Working buffer for BLE packets (>= 240 bytes)
* @return dr_adc_err_t Error code
*/
dr_adc_err_t dr_adc_transmit_channel_delta(const dr_maa_channel_t *ch_data,
uint8_t *ble_buffer);
/*==============================================================================
* ASYNC MAA - Non-blocking 8-channel capture
*
* Design: State machine driven by BLE TX complete events
* Flow:
* maa? cmd -> maa_async_start() -> capture CH0 -> TX reb: -> TX red: ...
* BLE_NUS_EVT_TX_RDY -> maa_async_continue() -> TX next packet or next channel
* All done -> TX raa: -> state=IDLE
*============================================================================*/
/** @brief MAA async state machine states */
typedef enum {
MAA_ASYNC_IDLE = 0, /**< Not active */
MAA_ASYNC_CAPTURING, /**< ADC capture in progress */
MAA_ASYNC_TX_HEADER, /**< Sending reb: header */
MAA_ASYNC_TX_DATA, /**< Sending red: data packets */
MAA_ASYNC_NEXT_CHANNEL, /**< Preparing next channel */
MAA_ASYNC_COMPLETE /**< Sending raa: and finishing */
} maa_async_state_t;
/** @brief MAA async context */
typedef struct {
maa_async_state_t state; /**< Current state */
uint8_t current_ch; /**< Current channel (0~7) */
uint8_t current_pkt; /**< Current packet index */
uint16_t data_offset; /**< Bytes sent so far for current channel */
uint8_t freq_option; /**< Frequency option */
uint16_t delay_us; /**< Capture delay */
uint16_t num_samples; /**< Samples per channel */
uint8_t cycles; /**< Burst cycles */
uint16_t averaging; /**< Averaging count */
uint8_t *ble_buffer; /**< Working buffer for BLE packets */
dr_maa_channel_t channels[MAA_NUM_CHANNELS]; /**< Captured data for each channel */
uint16_t total_packets; /**< Total packets for current channel */
uint16_t data_packets; /**< Data packets for current channel */
} maa_async_ctx_t;
/**
* @brief Start async MAA 8-channel capture
*
* Initiates the async state machine. Captures CH0 and begins transmission.
* Subsequent packets are sent when maa_async_on_tx_ready() is called.
*
* @param freq_option Frequency: 0=1.8MHz, 1=2.1MHz, 2=2.0MHz, 3=1.7MHz
* @param delay_us Capture delay (us)
* @param num_samples Samples per channel (1~200)
* @param cycles Burst cycles (3~9)
* @param averaging Averaging count (1~1000)
* @param ble_buffer Working buffer (>= 240 bytes)
* @return dr_adc_err_t DR_ADC_OK if started successfully
*/
dr_adc_err_t maa_async_start(uint8_t freq_option, uint16_t delay_us,
uint16_t num_samples, uint8_t cycles,
uint16_t averaging, uint8_t *ble_buffer);
/**
* @brief Handle BLE TX ready event
*
* Called from BLE_NUS_EVT_TX_RDY handler. Sends next packet or
* transitions to next state.
*
* @return true if more work pending, false if complete or idle
*/
bool maa_async_on_tx_ready(void);
/**
* @brief Check if async MAA is active
* @return true if state != IDLE
*/
bool maa_async_is_busy(void);
/**
* @brief Get current async state (for debugging)
* @return Current state
*/
maa_async_state_t maa_async_get_state(void);
/**
* @brief Abort async MAA operation
*/
void maa_async_abort(void);
#endif /* DR_ADC121S051_H */

82
project/ble_peripheral/ble_app_bladder_patch/cmd/dr_util.c
View File

@@ -1,82 +0,0 @@
#include "dr_util.h"
#include "parser.h"
extern void single_format_data(uint8_t *buffer, const char *tag, uint16_t value);
extern void format_data(uint8_t *buffer, const char *tag, uint16_t *data, uint8_t length);
extern void binary_tx_handler(uint8_t *buffer, uint8_t length);
extern uint8_t ble_bin_buffer[];
/* Use dr_binary_tx_safe from main.c - has retry logic for BLE TX queue */
extern void dr_binary_tx_safe(uint8_t const *ble_bin_buff, uint16_t length);
void dr_ble_return_1(const char *tag, uint16_t value)
{
single_format_data(ble_bin_buffer, tag, value);
dr_binary_tx_safe(ble_bin_buffer, 3); /* Use safe TX with retry */
}
void dr_ble_return_2(const char *tag, uint16_t v1, uint16_t v2)
{
ble_bin_buffer[0] = tag[0];
ble_bin_buffer[1] = tag[1];
ble_bin_buffer[2] = tag[2];
ble_bin_buffer[3] = tag[3];
ble_bin_buffer[4] = (uint8_t)(v1 >> 8);
ble_bin_buffer[5] = (uint8_t)(v1 & 0xFF);
ble_bin_buffer[6] = (uint8_t)(v2 >> 8);
ble_bin_buffer[7] = (uint8_t)(v2 & 0xFF);
dr_binary_tx_safe(ble_bin_buffer, 4); /* Use safe TX with retry */
}
void dr_ble_return_3(const char *tag, uint16_t v1, uint16_t v2, uint16_t v3)
{
ble_bin_buffer[0] = tag[0];
ble_bin_buffer[1] = tag[1];
ble_bin_buffer[2] = tag[2];
ble_bin_buffer[3] = tag[3];
ble_bin_buffer[4] = (uint8_t)(v1 >> 8);
ble_bin_buffer[5] = (uint8_t)(v1 & 0xFF);
ble_bin_buffer[6] = (uint8_t)(v2 >> 8);
ble_bin_buffer[7] = (uint8_t)(v2 & 0xFF);
ble_bin_buffer[8] = (uint8_t)(v3 >> 8);
ble_bin_buffer[9] = (uint8_t)(v3 & 0xFF);
dr_binary_tx_safe(ble_bin_buffer, 5); /* Use safe TX with retry */
}
void dr_ble_debug(uint16_t point_id, uint16_t value)
{
/* Use dedicated buffer to avoid conflicts with ble_bin_buffer */
static uint8_t dbg_buffer[8];
dbg_buffer[0] = 'd';
dbg_buffer[1] = 'b';
dbg_buffer[2] = 'g';
dbg_buffer[3] = ':';
dbg_buffer[4] = (uint8_t)(point_id >> 8);
dbg_buffer[5] = (uint8_t)(point_id & 0xFF);
dbg_buffer[6] = (uint8_t)(value >> 8);
dbg_buffer[7] = (uint8_t)(value & 0xFF);
dr_binary_tx_safe(dbg_buffer, 4);
}
void dr_ble_return_piezo_1(const char *tag, uint16_t value)
{
/* Use dedicated buffer for piezo responses to avoid conflicts with ble_bin_buffer */
static uint8_t piezo_buffer[8];
piezo_buffer[0] = tag[0];
piezo_buffer[1] = tag[1];
piezo_buffer[2] = tag[2];
piezo_buffer[3] = tag[3];
piezo_buffer[4] = (uint8_t)(value >> 8);
piezo_buffer[5] = (uint8_t)(value & 0xFF);
dr_binary_tx_safe(piezo_buffer, 3); /* 6 bytes = 3 words */
}

18
project/ble_peripheral/ble_app_bladder_patch/cmd/dr_util.h
View File

@@ -1,18 +0,0 @@
#ifndef DR_UTIL_H
#define DR_UTIL_H
#include <stdint.h>
void dr_ble_return_1(const char *tag, uint16_t value);
void dr_ble_return_2(const char *tag, uint16_t v1, uint16_t v2);
void dr_ble_return_3(const char *tag, uint16_t v1, uint16_t v2, uint16_t v3);
void dr_ble_return_3_be(const char *tag, uint16_t v1, uint16_t v2, uint16_t v3);
/* Piezo dedicated BLE return - uses separate buffer to avoid conflicts */
void dr_ble_return_piezo_1(const char *tag, uint16_t value);
/* BLE debug output - sends "dbg:" + point_id + value */
void dr_ble_debug(uint16_t point_id, uint16_t value);
#endif /* DR_UTIL_H */

1174
project/ble_peripheral/ble_app_bladder_patch/cmd/parser.c
View File

File diff suppressed because it is too large Load Diff

24
project/ble_peripheral/ble_app_bladder_patch/cmd/parser.h
View File

@@ -1,24 +0,0 @@
/* parser.h */
#ifndef PARSER_H
#define PARSER_H
#include <stdint.h>
#include <stdbool.h>
/* Platform-dependent function pointer set */
typedef struct {
void (*log)(const char *fmt, ...);
void (*tx_bin)(const uint8_t *buf, uint16_t len);
bool crc_check;
} dr_platform_if_t;
/* Global interface & log flag */
extern dr_platform_if_t g_plat;
extern bool g_log_enable;
/* Main parser entry point */
int dr_cmd_parser(const uint8_t *buf, uint8_t len);
#endif /* PARSER_H */

256
project/ble_peripheral/ble_app_bladder_patch/cmd_parse.c
View File

@@ -205,7 +205,7 @@ bool length_error(const char *cmd , uint8_t target_length, uint8_t length)
resp_error[3] = '!';
single_format_data(ble_bin_buffer, resp_error, err_code1);
binary_tx_handler(ble_bin_buffer,3);
dr_binary_tx_safe(ble_bin_buffer,3);
return false;
}
@@ -228,7 +228,7 @@ bool activate_error(const char *cmd , bool device_status)
resp_error[3] = '!';
single_format_data(ble_bin_buffer, resp_error, err_code2);
binary_tx_handler(ble_bin_buffer,3);
dr_binary_tx_safe(ble_bin_buffer,3);
return false;
}
@@ -244,7 +244,7 @@ void param_error(const char *cmd )
resp_error[3] = '!';
single_format_data(ble_bin_buffer, resp_error, err_code3);
binary_tx_handler(ble_bin_buffer,3);
dr_binary_tx_safe(ble_bin_buffer,3);
}
@@ -253,10 +253,8 @@ void quest_error(const char *cmd )
char resp_error[4];
const char pass_init[6] = "123456";
if( (cmd[0] == '*') && (cmd[1] == '*') && (cmd[2] == '*') && (cmd[3] == '*')){
if(eeprom_write_encrypted(0x0020, (uint8_t *)pass_init, 6)!= NRF_SUCCESS)
{
DBG_PRINTF("ERR!!! EEP_passkey 6\r\n\r\n");;
}
memcpy(m_config.static_passkey, pass_init, 6);
config_save();
resp_error[0] = '*';
@@ -264,7 +262,7 @@ void quest_error(const char *cmd )
resp_error[2] = cmd[2]; // 3rd letter (index 2)
resp_error[3] = '*';
single_format_data(ble_bin_buffer, resp_error, err_code4);
binary_tx_handler(ble_bin_buffer,3);
dr_binary_tx_safe(ble_bin_buffer,3);
}
else{
@@ -275,7 +273,7 @@ void quest_error(const char *cmd )
resp_error[3] = '!';
single_format_data(ble_bin_buffer, resp_error, err_code4);
binary_tx_handler(ble_bin_buffer,3);
dr_binary_tx_safe(ble_bin_buffer,3);
}
}
@@ -315,83 +313,7 @@ void quest_error(const char *cmd )
// }
// }
//}
ret_code_t eeprom_read_bool(uint16_t mem_address, bool *value_out)
{
uint8_t raw;
ret_code_t ret = eeprom_read_byte(mem_address, &raw);
if (ret != NRF_SUCCESS) {
return ret;
}
*value_out = (raw != 0);
return NRF_SUCCESS;
}
ret_code_t eeprom_init_values_read(void)
{
ret_code_t err_code;
//uint8_t *data_bond;
// Read 11 bytes from EEPROM
err_code = eeprom_read_decrypted(0x0030, (uint8_t *)SERIAL_NO, 12);
if (err_code != NRF_SUCCESS)
{
return err_code;
}
else
{
DBG_PRINTF("\r\n SN:%s \r\n", SERIAL_NO);
}
err_code = eeprom_read_decrypted(0x0020, (uint8_t *)m_static_passkey, 6);
if (err_code != NRF_SUCCESS)
{
return err_code;
}
else
{
DBG_PRINTF("\r\n passkey-0 :%s \n", m_static_passkey);
}
//err_code = eeprom_read_bytes(0x0060, data_bond,16);
err_code = eeprom_read_bool(0x0060, &bond_data_delete);
if (err_code != NRF_SUCCESS)
{
return err_code;
}
else
{
// bond_data_delete = data_bond[0];
DBG_PRINTF("\r\n bond_data_delete :%d \n", bond_data_delete);
}
err_code = eeprom_read_byte(0x0065, &m_reset_status);
if (err_code != NRF_SUCCESS)
{
return err_code;
}
else
{
if(m_reset_status){
//DBG_PRINTF("\r\n status :%d \n", m_reset_status);
}
}
DBG_PRINTF("m_life_cycle eprom read\n"); //ad cj
err_code = eeprom_read_uint32(0x0090, &m_life_cycle);
if (err_code != NRF_SUCCESS)
{
return err_code;
}
else
{
if(m_life_cycle){
DBG_PRINTF("\r\n m_life_cycle :%1u \r\n", m_life_cycle);
}
}
return NRF_SUCCESS;
}
/* eeprom_init_values_read() 삭제됨 — FDS config_load()가 동일 역할 수행 - jhChun 26.03.16 */
static void log_printf(const char *fmt, ...)
@@ -428,7 +350,7 @@ void received_command_process (uint8_t const *data_array, which_cmd_t cmd_t, uin
if (!parser_initialized) {
// Setup platform interface
g_plat.log = log_printf; // printf
g_plat.tx_bin = binary_tx_handler;
g_plat.tx_bin = dr_binary_tx_safe;
g_plat.crc_check = true; // CRC
g_log_enable = true;
@@ -471,7 +393,7 @@ void received_command_process (uint8_t const *data_array, which_cmd_t cmd_t, uin
resp_error[3] = '!';
single_format_data(ble_bin_buffer, resp_error, err_code6);
binary_tx_handler(ble_bin_buffer,3);
dr_binary_tx_safe(ble_bin_buffer,3);
return ;
}
else if(processing == true)
@@ -588,7 +510,7 @@ if((scmd.tag[0] == 's')&&(scmd.tag[1] == 't')&&(scmd.tag[2] == 'a')&&(scmd.tag[3
} else if(cmd_t == CMD_BLE) {
single_format_data(ble_bin_buffer, "rta:", scmd.value0);
binary_tx_handler(ble_bin_buffer,3);
dr_binary_tx_safe(ble_bin_buffer,3);
}
}
@@ -617,7 +539,7 @@ else if((scmd.tag[0] == 's')&&(scmd.tag[1] == 't')&&(scmd.tag[2] == 'r')&&(scmd.
single_format_data(ble_bin_buffer, "rtr:", (uint8_t)device_status);
binary_tx_handler(ble_bin_buffer,3);
dr_binary_tx_safe(ble_bin_buffer,3);
}
}
@@ -684,7 +606,7 @@ else if((scmd.tag[1] == 's') && (scmd.tag[2] == 'q')){ // Device power off
} else if(cmd_t == CMD_BLE) {
single_format_data(ble_bin_buffer, "rsq:", scmd.value0);
binary_tx_handler(ble_bin_buffer,2);
dr_binary_tx_safe(ble_bin_buffer,2);
// sprintf(ble_tx_buffer, "Tq\r\n");
// data_tx_handler(ble_tx_buffer);
}
@@ -701,16 +623,14 @@ else if((scmd.tag[1] == 's') && (scmd.tag[2] == 'r')){ // Bond Info Delete
DBG_PRINTF("Tr\r\n\r\n");
} else if(cmd_t == CMD_BLE) {
single_format_data(ble_bin_buffer, "rsr:", scmd.value0);
binary_tx_handler(ble_bin_buffer,2);
dr_binary_tx_safe(ble_bin_buffer,2);
}
bond_data_delete = true;
eeprom_write_byte(0x0060, (uint8_t)bond_data_delete);
//m_config.reset_status = 2;
m_config.bond_data_delete = (uint8_t)bond_data_delete;
m_reset_status = 2;
eeprom_write_byte(0x0065, m_reset_status);
//config_save();
m_config.reset_status = m_reset_status;
config_save();
nrf_delay_ms(5);
go_NVIC_SystemReset = true;
main_timer_start();
@@ -726,14 +646,14 @@ else if((scmd.tag[1] == 's') && (scmd.tag[2] == 's')){ //Device reset(Reboot)
DBG_PRINTF("Ts\r\n\r\n");
} else if(cmd_t == CMD_BLE) {
single_format_data(ble_bin_buffer, "rss:", scmd.value0);
binary_tx_handler(ble_bin_buffer,2);
dr_binary_tx_safe(ble_bin_buffer,2);
}
go_NVIC_SystemReset = true;
//m_config.reset_status = 2;
m_reset_status = 2;
eeprom_write_byte(0x0065, m_reset_status);
// config_save();
m_config.reset_status = m_reset_status;
config_save();
nrf_delay_ms(5);
go_NVIC_SystemReset = true;
main_timer_start();
@@ -745,7 +665,7 @@ else if((scmd.tag[1] == 's') && (scmd.tag[2] == 't')){ // Auto Gain Control
DBG_PRINTF("Ready\r\n\r\nREADY\r\n");
} else if(cmd_t == CMD_BLE) {
single_format_data(ble_bin_buffer, "rst:", scmd.value0);
binary_tx_handler(ble_bin_buffer,2);
dr_binary_tx_safe(ble_bin_buffer,2);
}
@@ -759,7 +679,7 @@ else if(0 && (scmd.tag[1] == 's') && (scmd.tag[2] == 'v')){ // Auto Gain Cont
DBG_PRINTF("%s\r\n",DEVICE_VERSION);
} else if(cmd_t == CMD_BLE) {
ascii_format_data(ble_bin_buffer, "rsv:", DEVICE_VERSION,12);
binary_tx_handler(ble_bin_buffer,8);
dr_binary_tx_safe(ble_bin_buffer,8);
//test_eeprom_page_rw();
}
@@ -779,7 +699,7 @@ else if(0 && (scmd.tag[1] == 's') && (scmd.tag[2] == 'z')){
config_save();
DBG_PRINTF("[ssz] S/N=%s saved to FDS\r\n", m_config.serial_no);
ascii_format_data(ble_bin_buffer, "rsz:", scmd.value_ascii,12);
binary_tx_handler(ble_bin_buffer,8);
dr_binary_tx_safe(ble_bin_buffer,8);
}
else{
DBG_PRINTF("ERR!!! Serial_number 12\r\n\r\n");
@@ -796,42 +716,16 @@ else if((scmd.tag[1] == 'p') && (scmd.tag[2] == 'z')){ //Write, passkey
{
return;
}
uint8_t tx_data[EEPROM_PAGE_SIZE];
uint8_t rx_data[EEPROM_PAGE_SIZE];
uint8_t raw_data[EEPROM_PAGE_SIZE];
if(cmd_t == CMD_UART) {
DBG_PRINTF("Tz0\r\n\r\n");
} else if(cmd_t == CMD_BLE) {
} else if(cmd_t == CMD_BLE) {
memcpy(m_static_passkey, scmd.value_ascii, 6);
memcpy(m_config.static_passkey, m_static_passkey, 6);
config_save();
DBG_PRINTF("Passkey saved: %.6s\n", m_static_passkey);
//memcpy(SERIAL_NO, scmd.value_ascii, 6);
//eeprom_write_bytes(uint16_t mem_address, const uint8_t *data, size_t length)
for (uint8_t i=0 ; i<6 ;i++)
{
tx_data[i] = (uint8_t)(scmd.value_ascii[i]);
}
if(eeprom_write_encrypted(0x0020, tx_data, 6)!= NRF_SUCCESS)
{
DBG_PRINTF("ERR!!! EEP_passkey 6\r\n\r\n");;
}
if(eeprom_read_bytes(0x0020, raw_data, 6)!= NRF_SUCCESS)
{
DBG_PRINTF("ERR!!! EEP_passkey 6\r\n\r\n");;
}
nrf_delay_ms(10);
DBG_PRINTF("encrypted: %s\n", raw_data);
if(eeprom_read_decrypted(0x0020, rx_data, 6)!= NRF_SUCCESS)
{
DBG_PRINTF("ERR!!! EEP_passkey 6\r\n\r\n");;
}
DBG_PRINTF("Decrypted: %s\n", rx_data);
ascii_format_data(ble_bin_buffer, "rpz:", scmd.value_ascii,6);
binary_tx_handler(ble_bin_buffer,5);
dr_binary_tx_safe(ble_bin_buffer,5);
}
@@ -852,30 +746,12 @@ else if((scmd.tag[1] == 'p') && (scmd.tag[2] == 'z')){ //Write, passkey
// sqz
else if((scmd.tag[1] == 'q') && (scmd.tag[2] == 'z')){ // Read, Serial Number
uint8_t rx_data[EEPROM_PAGE_SIZE];
if(cmd_t == CMD_UART) {
DBG_PRINTF("Tz1,%s\r\n\r\n", SERIAL_NO);
} else if(cmd_t == CMD_BLE) {
hw_i2c_init_once();
if(eeprom_read_decrypted(0x0020, rx_data, 6)!= NRF_SUCCESS)
{
DBG_PRINTF("ERR!!! EEP_Serial_number 12\r\n\r\n");;
}
DBG_PRINTF("Decrypted: %s\n", rx_data);
// if (eeprom_read_bytes(0x0030 , rx_data ,12) !=NRF_SUCCESS)
// {
// DBG_PRINTF("ERR!!! EEP_Serial_number 12\r\n\r\n");
// }
// sprintf(ble_tx_buffer, "Tz1,%s\r\n", m_config.serial_number);
// data_tx_handler(ble_tx_buffer);
for (uint8_t i=0 ; i<6 ;i++)
{
(m_static_passkey[i]) = (char)rx_data[i] ;
}
} else if(cmd_t == CMD_BLE) {
memcpy(m_static_passkey, m_config.static_passkey, 6);
ascii_format_data(ble_bin_buffer, "rqz:", m_static_passkey,6);
binary_tx_handler(ble_bin_buffer,5);
dr_binary_tx_safe(ble_bin_buffer,5);
}
}
@@ -886,7 +762,7 @@ else if(0 && (scmd.tag[1] == 'r') && (scmd.tag[2] == 'z')){
} else if(cmd_t == CMD_BLE) {
memcpy(SERIAL_NO, m_config.serial_no, 12);
ascii_format_data(ble_bin_buffer, "rrz:", SERIAL_NO, 12);
binary_tx_handler(ble_bin_buffer, 8);
dr_binary_tx_safe(ble_bin_buffer, 8);
}
#if 0 // ===== EEPROM start block =====
@@ -941,7 +817,7 @@ else if(0 && (scmd.tag[1] == 'r') && (scmd.tag[2] == 'z')){
// } else if(cmd_t == CMD_BLE) {
//// sprintf(ble_tx_buffer, "Tz3,%s\r\n",read_data
// ascii_format_data(ble_bin_buffer, "rcz:", "ok",3);
// binary_tx_handler(ble_bin_buffer,5);
// dr_binary_tx_safe(ble_bin_buffer,5);
//// data_tx_handler(ble_tx_buffer);
// }
@@ -969,7 +845,7 @@ else if(0 && (scmd.tag[1] == 'r') && (scmd.tag[2] == 'z')){
//
//
// format_data_byte(ble_bin_buffer, "rdz:", read_data,64);
// binary_tx_handler(ble_bin_buffer,34);
// dr_binary_tx_safe(ble_bin_buffer,34);
// }
@@ -981,26 +857,11 @@ else if(0 && (scmd.tag[1] == 'r') && (scmd.tag[2] == 'z')){
// sez
else if((scmd.tag[1] == 'e') && (scmd.tag[2] == 'z')){ // Read, Serial Number
hw_i2c_init_once();
uint16_t write_data[64];
for (int i = 0; i < 48; i++) {
write_data[i]= (uint16_t)(scmd.values[i*2+7] | (uint16_t)(scmd.values[i*2+6] << 8));
}
eeprom_write_uint16_array(scmd.value0,write_data,48);
/* AGC gain array — AD5272/MCP4725 HW 제거됨, 명령 비활성화 - jhChun 26.03.16 */
if(cmd_t == CMD_UART) {
DBG_PRINTF("rez,%s\r\n\r\n", scmd.value_ascii);
} else if(cmd_t == CMD_BLE) {
format_data(ble_bin_buffer, "rez:", write_data,48);
binary_tx_handler(ble_bin_buffer,50);
DBG_PRINTF("sez: HW not present\r\n");
} else if(cmd_t == CMD_BLE) {
param_error(scmd.tag);
}
}
@@ -1016,26 +877,11 @@ else if((scmd.tag[1] == 'f') && (scmd.tag[2] == 'z')){ // Read, Ser
// }
else{
hw_i2c_init_once();
uint16_t read_data[64];
//uint8_t EEPread_data[64];
eeprom_read_uint16_array(scmd.value0,read_data,48); //int16(48ea) DP Preset 0~6
// for (int i = 0; i < 48; i++) {
// EEPread_data[i]= (uint8_t)(read_data[i]);
// }
/* AGC gain array — AD5272/MCP4725 HW 제거됨, 명령 비활성화 - jhChun 26.03.16 */
if(cmd_t == CMD_UART) {
DBG_PRINTF("ref,%s\r\n\r\n", scmd.value_ascii);
} else if(cmd_t == CMD_BLE) {
format_data(ble_bin_buffer, "rfz:", read_data,48);
binary_tx_handler(ble_bin_buffer,50);
DBG_PRINTF("sfz: HW not present\r\n");
} else if(cmd_t == CMD_BLE) {
param_error(scmd.tag);
}
}
}
@@ -1046,7 +892,7 @@ else if(0 && (scmd.tag[1] == 'i') && (scmd.tag[2] == 'z')){
} else if(cmd_t == CMD_BLE) {
memcpy(HW_NO, m_config.hw_no, 12);
ascii_format_data(ble_bin_buffer, "riz:", HW_NO, 12);
binary_tx_handler(ble_bin_buffer, 8);
dr_binary_tx_safe(ble_bin_buffer, 8);
}
}
// shz - Write HW Number (FDS only) — DISABLED: use mwh? in pc_firm/parser.c
@@ -1063,7 +909,7 @@ else if(0 && (scmd.tag[1] == 'h') && (scmd.tag[2] == 'z')){
config_save();
DBG_PRINTF("[shz] HW=%s saved to FDS\r\n", m_config.hw_no);
ascii_format_data(ble_bin_buffer, "rhz:", scmd.value_ascii,12);
binary_tx_handler(ble_bin_buffer,8);
dr_binary_tx_safe(ble_bin_buffer,8);
}
else{
DBG_PRINTF("ERR!!! HW_NO 12\r\n\r\n");
@@ -1091,10 +937,10 @@ else if((scmd.tag[1] == 'x') && (scmd.tag[2] == 'z')){ // Set the delay for
if(cmd_t == CMD_UART) {
DBG_PRINTF("rxz\r\n\r\n");
} else if(cmd_t == CMD_BLE) {
hw_i2c_init_once();
eeprom_write_uint32(0x0090, m_life_cycle);
m_config.life_cycle = m_life_cycle;
config_save();
format_data(ble_bin_buffer, "rxz:", result_data,2);
binary_tx_handler(ble_bin_buffer,4);
dr_binary_tx_safe(ble_bin_buffer,4);
}
}else{
if(cmd_t == CMD_UART) {
@@ -1121,7 +967,7 @@ else if((scmd.tag[1] == 'y') && (scmd.tag[2] == 'z')){ //
else {
eeprom_read_uint32(0x0090, &m_life_cycle); //thnk cj
m_life_cycle = m_config.life_cycle;
result_data[0] = (uint16_t)(m_life_cycle >> 16);
result_data[1] = (uint16_t)(m_life_cycle & 0xFFFF);
@@ -1132,7 +978,7 @@ else if((scmd.tag[1] == 'y') && (scmd.tag[2] == 'z')){ //
} else if(cmd_t == CMD_BLE) {
format_data(ble_bin_buffer, "ryz:", result_data,4);
binary_tx_handler(ble_bin_buffer,4);
dr_binary_tx_safe(ble_bin_buffer,4);
}
}
@@ -1145,7 +991,7 @@ else if((scmd.tag[1] == 'y') && (scmd.tag[2] == 'z')){ //
DBG_PRINTF("ERR!!! UART Command Failed, %c%c%c%c\r\n",data_array[0], data_array[1], data_array[2], data_array[3]);
} else if(cmd_t == CMD_BLE) {
single_format_data(ble_bin_buffer, "err!", err_code5);
binary_tx_handler(ble_bin_buffer,3);
dr_binary_tx_safe(ble_bin_buffer,3);

16
project/ble_peripheral/ble_app_bladder_patch/cmd_parse.h
View File

@@ -33,8 +33,6 @@
#include "math.h"
#include "crc16.h" //add 25.04.23
#include "nrf_ble_lesc.h"
#include "cat_interface.h"
#include "ir_i2c.h"
#include "nrf_crypto.h"
#include "nrf_pwr_mgmt.h"
#include <ctype.h>
@@ -43,23 +41,10 @@
#include "main.h"
#include "app_raw_main.h" //0117
#include "main_timer.h"
#include "ad5272_i2c.h"
#include "ada2200_spi.h"
#include "power_control.h"
#include "tmp235_q1.h"
#include "mcp4725_i2c.h"
#include "measurements.h"
//#include "fstorage.h"
#include "battery_saadc.h"
#include "mcp4725_adc.h"
#include "meas_pd_voltage_simple.h"
#include "meas_pd_voltage_half.h"
#include "meas_pd_voltage_full.h"
#include "full_agc.h"
//#include "meas_pd_voltage_custom.h"
#include "meas_pd_imm.h"
#include "meas_pd_48.h"
typedef struct {
char tag[5]; // Null-terminated 4-char command
uint16_t value0; // Data value
@@ -82,7 +67,6 @@ bool is_valid_serial_no(const char *serial);
bool is_valid_passkey(const char *passkey);
ret_code_t eeprom_init_values_read(void);
bool crc16_check(uint8_t const * p_data, uint32_t data_len, uint16_t expected_crc);
bool crc16_check_packet(uint8_t const * packet, uint32_t packet_len);

14
project/ble_peripheral/ble_app_bladder_patch/debuf_print.h
View File

@@ -1,14 +0,0 @@
// file: debug_print.h
#ifndef DEBUG_PRINT_H
#define DEBUG_PRINT_H
#define ENABLE_PRINTF 1 // Set to 0 to disable globally
#if ENABLE_PRINTF
#include <stdio.h>
#define DBG_PRINTF(...) printf(__VA_ARGS__)
#else
#define DBG_PRINTF(...) // Do nothing
#endif
#endif // DEBUG_PRINT_H

29
project/ble_peripheral/ble_app_bladder_patch/fstorage.c
View File

@@ -78,6 +78,9 @@ void fds_default_value_set(void)
/* Measurement parameters */
m_config.pd_adc_cnt = 8;
m_config.pd_delay_us = 8000;
/* Device usage count */
m_config.life_cycle = 0;
}
@@ -106,19 +109,19 @@ static void fds_evt_handler( fds_evt_t const *p_evt )
{
fds_flag_write = false;
if(go_device_power_off == true) {
/* After flash writing completed, System Power Off */
device_power_off();
}
if(go_sleep_mode_enter == true) {
/* After flash writing completed, System go to Sleep Mode */
sleep_mode_enter();
}
if(go_NVIC_SystemReset == true) {
/* After flash writing completed, System Reset */
DBG_PRINTF("Off FDS_EVENT\r\n");
NVIC_SystemReset();
}
if(go_device_power_off == true) {
/* After flash writing completed, System Power Off */
device_power_off();
}
if(go_sleep_mode_enter == true) {
/* After flash writing completed, System go to Sleep Mode */
sleep_mode_enter();
}
if(go_NVIC_SystemReset == true) {
/* After flash writing completed, System Reset */
DBG_PRINTF("Off FDS_EVENT\r\n");
NVIC_SystemReset();
}
}
break;

3
project/ble_peripheral/ble_app_bladder_patch/fstorage.h
View File

@@ -25,7 +25,8 @@ typedef struct
int8_t reset_status; /* 1B - Reset status */
uint8_t pd_adc_cnt; /* 1B - ADC sample count */
uint16_t pd_delay_us; /* 2B - PD delay (us) */
} config_data_t; /* Total: 41 bytes - FDS에 저장하는 디바이스 설정 */
uint32_t life_cycle; /* 4B - Device usage count (sxz/syz command) */
} config_data_t; /* Total: 45 bytes - FDS에 저장하는 디바이스 설정 */
extern config_data_t m_config;

1033
project/ble_peripheral/ble_app_bladder_patch/full_agc.c
View File

File diff suppressed because it is too large Load Diff

34
project/ble_peripheral/ble_app_bladder_patch/full_agc.h
View File

@@ -1,34 +0,0 @@
/*******************************************************************************
* @file full_agc.h
* @author CandyPops Co.
* @version V1.0.0
* @date 2022-09-05
* @brief
******************************************************************************/
#ifndef _FULL_AGC_H__
#define _FULL_AGC_H__
#include "sdk_common.h"
#define PD_NO 1
//#define LED_NO 50
void full_agc_start(void);
void full_agc_end(void);
void full_agc_adc_init(void);
void full_agc_uninit(void);
void full_agc_loop(void * p_context); /* For x ms */
void full_agc_timer_start(void);
void full_agc_timer_stop(void);
void full_agc_timer_init(void);
void full_agc_mesurement_start(void);
void full_agc_send_loop(void * p_context); /* For x ms */
void full_agc_send_timer_start(void);
void full_agc_send_timer_stop(void);
void full_agc_send_timer_init(void);
#endif /* _FULL_AGC_H__ */

44
project/ble_peripheral/ble_app_bladder_patch/i2c_manager.c
View File

@@ -7,14 +7,41 @@
#include "debug_print.h"
#include "nrf_delay.h"
#include "mcp4725_i2c.h"
#include "nrf_drv_twi.h"
#include "cat_interface.h"
#include "nrfx_twi.h"
#include "boards.h"
#include "system_interface.h"
bool HW_I2C_FRQ = true;
bool SW_I2C_FRQ = false;
/* 외부 EEPROM TWI 인스턴스 */
extern const nrf_drv_twi_t m_eeprom;
#define TWI_INSTANCE 0
/* TWI (I2C) 하드웨어 인스턴스 : IMU 드라이버에서 사용 - jhChun 26.03.16 */
const nrfx_twi_t m_twi = NRFX_TWI_INSTANCE(TWI_INSTANCE);
/* TWI (I2C) 해제 - jhChun 26.03.16 */
static void twi_uninitialize(void){
nrfx_twi_disable(&m_twi);
nrfx_twi_uninit(&m_twi);
}
/* TWI (I2C) 하드웨어 초기화 (SCL/SDA핀, 400kHz) - jhChun 26.03.16 */
static void twi_initialize(void){
ret_code_t err_code;
const nrfx_twi_config_t twi_config = {
.scl = ICM42670_I2C_SCL_PIN,
.sda = ICM42670_I2C_SDA_PIN,
.frequency = NRF_TWI_FREQ_400K,
.interrupt_priority = APP_IRQ_PRIORITY_HIGH,
};
err_code = nrfx_twi_init(&m_twi, &twi_config, NULL, NULL);
APP_ERROR_CHECK(err_code);
nrfx_twi_enable(&m_twi);
}
/* -------------------------------------------------------------------------- */
/* HW (TWI) 초기화 */
@@ -39,7 +66,7 @@ void hw_i2c_init_once(void)
}
// 실제 HW 초기화
eeprom_initialize();
twi_initialize();
nrf_delay_ms(2);
HW_I2C_FRQ = true;
@@ -58,8 +85,8 @@ void sw_i2c_init_once(void)
{
//DBG_PRINTF("[I2C]HW→SW\r\n");
nrf_drv_twi_disable(&m_eeprom);
nrf_drv_twi_uninit(&m_eeprom);
nrfx_twi_disable(&m_twi);
nrfx_twi_uninit(&m_twi);
nrf_delay_ms(2);
HW_I2C_FRQ = false;
@@ -73,9 +100,8 @@ void sw_i2c_init_once(void)
}
// 실제 SW 초기화
eeprom_uninitialize(); // TWI 라인 해제
twi_uninitialize(); // TWI 라인 해제
nrf_delay_ms(1);
mcp4725_init(); // Port BangBang 방식 DAC init
SW_I2C_FRQ = true;
HW_I2C_FRQ = false;

4
project/ble_peripheral/ble_app_bladder_patch/icm42670p/app_raw/app_raw.c
View File

@@ -290,7 +290,7 @@ void imu_callback(inv_imu_sensor_event_t *event)
ssp_data[5] = (uint16_t)gyro[2];
format_data(imu_bin_buffer, "rsp:", ssp_data,12);
printf("Tp%d,%d,%d,%d,%d,%d\r\n\r\n", accel[0], accel[1], accel[2], gyro[0], gyro[1], gyro[2]);
binary_tx_handler(imu_bin_buffer,8);
dr_binary_tx_safe(imu_bin_buffer,8);
if(custom_add_data==true)
{
custom_add_data = false;
@@ -405,7 +405,7 @@ int imu_read_direct(void)
ssp_data[5] = (uint16_t)gyro[2];
format_data(imu_bin_buffer, "rsp:", ssp_data, 12);
binary_tx_handler(imu_bin_buffer, 8);
dr_binary_tx_safe(imu_bin_buffer, 8);
/* Put IMU back to sleep: accel OFF + gyro OFF */
{

1
project/ble_peripheral/ble_app_bladder_patch/icm42670p/app_raw/app_raw_main.c
View File

@@ -22,7 +22,6 @@
#include "nrf_delay.h"
#include "app_util_platform.h"
#include "meas_pd_48.h"
#include <cmd_parse.h>
#include "i2c_manager.h"
/* --------------------------------------------------------------------------------------

1
project/ble_peripheral/ble_app_bladder_patch/icm42670p/system_interface.c
View File

@@ -20,7 +20,6 @@
#include "system_interface.h"
#include "nrf_delay.h"
#include "meas_pd_48.h"
/* I2C number and slave address for INV device */
#define ICM_I2C_ADDR 0x68

168
project/ble_peripheral/ble_app_bladder_patch/ir_i2c.c
View File

@@ -1,168 +0,0 @@
/*******************************************************************************
* @file ir_i2c.c
* @brief
******************************************************************************/
/* board driver */
#include <stdio.h>
#include <string.h>
#include <stdarg.h>
#include <stdbool.h>
#include "nrf.h"
#include "app_error.h"
#include "boards.h"
#include "nrfx_gpiote.h"
#include "nrfx_twi.h"
#include "nrf_drv_twi.h"
#include "nrf_delay.h"
#include "ir_i2c.h"
#include "debug_print.h"
/* I2C number and slave address for DS39305272 */
#define LED_1_I2C_ADDR 0x50
#define AD5272_MAX_SERIAL_WRITE 16
int16_t read_from_DS3930 = 0;
uint16_t data_160_to_write = 0;
static volatile bool m_xfer_done = false;
/* TWI instance. */
//const nrfx_twi_t m_twi_ir = NRFX_TWI_INSTANCE(IR_I2C_INSTANCE);
const nrf_drv_twi_t m_twi_ir = NRF_DRV_TWI_INSTANCE(IR_I2C_INSTANCE);
//void twi_handler(nrfx_twi_evt_t const * p_event, void * p_context)
//{
// m_xfer_done = true;
//}
//void ir_irq_init(void){
// ret_code_t err_code;
// /* Initialize int pin */
// if (!nrfx_gpiote_is_init())
// {
// err_code = nrfx_gpiote_init();
// APP_ERROR_CHECK(err_code);
// }
// nrfx_gpiote_in_config_t in_config = NRFX_GPIOTE_CONFIG_IN_SENSE_LOTOHI(true);
// in_config.pull = NRF_GPIO_PIN_PULLDOWN;
// err_code = nrfx_gpiote_in_init(ADA2200_SYNCO_PIN, &in_config, NULL);
// APP_ERROR_CHECK(err_code);
// nrfx_gpiote_in_event_enable(ADA2200_SYNCO_PIN, true);
//}
//void ir_irq_uninit(void){
// nrfx_gpiote_in_event_disable(ADA2200_SYNCO_PIN);
// nrfx_gpiote_in_uninit(ADA2200_SYNCO_PIN);
//}
void ir_i2c_uninit(void){
nrf_drv_twi_disable(&m_twi_ir);
nrf_drv_twi_uninit(&m_twi_ir);
//
}
void ir_i2c_init(void){
ret_code_t err_code;
const nrf_drv_twi_config_t twi_ir_config = {
.scl = IR_I2C_SCL_PIN,
.sda = IR_I2C_SDA_PIN,
.frequency = NRF_DRV_TWI_FREQ_100K,
.interrupt_priority = APP_IRQ_PRIORITY_HIGH,
.clear_bus_init = false
};
err_code = nrf_drv_twi_init(&m_twi_ir, &twi_ir_config, NULL, NULL);
APP_ERROR_CHECK(err_code);
if (err_code != NRF_SUCCESS) {
DBG_PRINTF("TWI ir_irq_init Error.");
}
nrf_drv_twi_enable(&m_twi_ir);
// ir_irq_init();
}
uint8_t ir_command_read(uint8_t device_id, uint8_t address, uint8_t *data)
{
uint8_t read_data = 0;
char adata[8];
ret_code_t err_code;
//address = 1|(address<<1);
address = (address & 0xFF);
err_code = nrf_drv_twi_tx(&m_twi_ir, device_id, &address, 1, true);
if (err_code != NRF_SUCCESS) {
// Handle error
// return;
}
err_code = nrf_drv_twi_rx(&m_twi_ir, device_id, data, 8);
if (err_code != NRF_SUCCESS) {
// Handle error
DBG_PRINTF("TWI read Error.");
return 0;
}
read_data = data[0];
memcpy(adata,data,8);
// DBG_PRINTF("ir Data %x %x %x %x. \r\n", device_id, address, data[0], data[1]);
//DBG_PRINTF("ir Data read %s . \r\n", adata);
return read_data;
}
void ir_command_write(uint8_t device_id, uint8_t address, uint8_t data)
{
//uint16_t data_to_write = 0;
uint8_t buffer[7]={0x00,0x00,0x00,0x00,0x00,0x00,0x00};
address = (address & 0xFF);
//buffer[0] = 0x00;
buffer[0] = (address);
buffer[1] =(data & 0xFF);
// buffer[2] = data1+1;
// buffer[3] = data1+2;
// buffer[4] = data1+3;
// buffer[5] = data1+4;
// buffer[6] = data1+5;
//memcpy(&buffer[1], data, length );
ret_code_t err_code;
//err_code = nrf_drv_twi_tx(&m_twi_ir, device_id, 0x00, 1, false);
err_code = nrf_drv_twi_tx(&m_twi_ir, device_id, buffer, 2, false);
DBG_PRINTF("ir Write Data %x %x %x %x. \r\n", device_id, buffer[0], buffer[1], buffer[2]);
//err_code = nrf_drv_twi_tx(&m_twi_ir, device_id, buffer, 6, false);
if (err_code != NRF_SUCCESS) {
DBG_PRINTF("TWI Error.");
}
}

111
project/ble_peripheral/ble_app_bladder_patch/ir_i2c.h
View File

@@ -1,111 +0,0 @@
/*******************************************************************************
* @file ir_i2c.h
* @date 2024-07-17
******************************************************************************/
#ifndef _IR_I2C_H_
#define _IR_I2C_H_
#include "sdk_common.h"
#include <stdbool.h>
#include "nrf.h"
#include "nrf_drv_gpiote.h"
#define IR_I2C_INSTANCE 1 /**< I2C instance index. */
//#define IR_I2C_INSTANCE 1 /**< I2C instance index. */
//#define IR_I2C_SDA_PIN NRF_GPIO_PIN_MAP(0,10)
//#define IR_I2C_SCL_PIN NRF_GPIO_PIN_MAP(0,9)
#define IR_I2C_SDA_PIN NRF_GPIO_PIN_MAP(1,15)
#define IR_I2C_SCL_PIN NRF_GPIO_PIN_MAP(1,14)
/**
* COMMAND CONSTANTS
* Commands are 16-bit writes: bits 15:14 are 0s
* Bits 13:10 are the command value below
* Bits 9:0 are data for the command, but not all bits are used with all commands
*/
// The NOP command is included for completeness. It is a valid I2C operation.
#define AD5272_COMMAND_NOP 0x00 // Do nothing. Why you would want to do this I don't know
// write the 10 or 8 data bits to the RDAC wiper register (it must be unlocked first)
#define AD5272_RDAC_WRITE 0x01
#define AD5272_RDAC_READ 0x02 // read the RDAC wiper register
#define AD5272_50TP_WRITE 0x03 // store RDAC setting to 50-TP
// SW reset: refresh RDAC with last 50-TP stored value
// If not 50-TP value, reset to 50% I think???
// data bits are all dont cares
#define AD5272_RDAC_REFRESH 0x04 // TODO refactor this to AD5272_SOFT_RESET
// read contents of 50-TP in next frame, at location in data bits 5:0,
// see Table 16 page 22 Rev D datasheet
// location 0x0 is reserved, 0x01 is first programmed wiper location, 0x32 is 50th programmed wiper location
#define AD5272_50TP_WIPER_READ 0x05
/**
* Read contents of last-programmed 50-TP location
* This is the location used in SW Reset command 4 or on POR
*/
#define AD5272_50TP_LAST_USED 0x06
#define AD5272_CONTROL_WRITE 0x07 // data bits 2:0 are the control bits
#define AD5272_CONTROL_READ 0x08 // data bits all dont cares
#define AD5272_SHUTDOWN 0x09 // data bit 0 set = shutdown, cleared = normal mode
/**
* Control bits are three bits written with command 7
*/
// enable writing to the 50-TP memory by setting this control bit C0
// default is cleared so 50-TP writing is disabled
// only 50 total writes are possible!
#define AD5272_50TP_WRITE_ENABLE 0x01
// enable writing to volatile RADC wiper by setting this control bit C1
// otherwise it is frozen to the value in the 50-TP memory
// default is cleared, can't write to the wiper
#define AD5272_RDAC_WIPER_WRITE_ENABLE 0x02
// enable high precision calibration by clearing this control bit C2
// set this bit to disable high accuracy mode (dunno why you would want to)
// default is 0 = emabled
#define AD5272_RDAC_CALIB_DISABLE 0x04
// 50TP memory has been successfully programmed if this bit is set
#define AD5272_50TP_WRITE_SUCCESS 0x08
#define AD5272_NORMAL_MODE 0x01
#define AD5272_SHUTDOWN_MODE 0x01
#define ADA2200_SYNCO_PIN NRF_GPIO_PIN_MAP(0,17)
void ir_i2c_uninit(void);
void ir_i2c_init(void);
void ir_irq_init(void);
void ir_irq_uninit(void);
uint8_t ir_command_read(uint8_t device_id, uint8_t address, uint8_t *data);
void ir_command_write(uint8_t device_id, uint8_t address, uint8_t data);
void ad5272_i2c_is_busy(void);
int8_t ad5272_write_and_read_rdac (uint16_t data_16_to_write);
int16_t ad5272_read_rdac (void);
int8_t ad5272_write_rdac (uint16_t data_16_to_write);
void read_all_50tp (void);
void ad5272_RDAC_refresh(void);
void ad5272_shutdown_mode(void);
void ad5272_normal_mode(void);
#endif /* !_ADA5272_I2C_H_ */

199
project/ble_peripheral/ble_app_bladder_patch/main.c
View File

@@ -64,29 +64,16 @@
#include "main.h"
#include "app_raw_main.h"
#include "main_timer.h"
#include "ad5272_i2c.h"
#include "ada2200_spi.h"
#include "power_control.h"
#include "tmp235_q1.h"
#include "mcp4725_i2c.h"
#include "measurements.h"
#include "fds.h"
#include "battery_saadc.h"
#include "mcp4725_adc.h"
#include "meas_pd_voltage_simple.h"
#include "meas_pd_voltage_half.h"
#include "meas_pd_voltage_full.h"
#include "full_agc.h"
#include "meas_pd_voltage_custom.h"
#include "meas_pd_imm.h"
#if FEATURE_SECURE_CONNECTION
#include "peer_manager.h"
#include "peer_manager_handler.h"
#include "nrf_ble_lesc.h"
#include "ble_quick_security.h"
#include "cat_interface.h"
#include "ir_i2c.h"
#include "i2c_manager.h"
#endif
@@ -150,7 +137,6 @@
#define SEC_PARAM_MIN_KEY_SIZE 7
#define SEC_PARAM_MAX_KEY_SIZE 16
#define PASSKEY_TXT_LENGTH 8
#define PASSKEY_LENGTH 6
#endif
/*==============================================================================
@@ -217,18 +203,8 @@ extern bool go_sleep_mode_enter;
extern bool go_NVIC_SystemReset;
extern bool ble_got_new_data;
extern bool motion_data_once;
extern bool adc_enabled;
extern bool con_single;
extern bool info4;
extern uint16_t led_pd_dac_v[LED_NUM];
extern uint8_t pd_adc_count;
extern int8_t c_max;
extern uint8_t simple_samples_in_buffer;
extern uint8_t full_samples_in_buffer;
extern uint8_t custom_samples_in_buffer;
extern bool pd_adc_custom_a_start;
extern bool pd_adc_custom_start;
extern bool full_agc_a_start;
extern uint8_t add_cycle;
extern bool motion_raw_data_enabled;
@@ -247,13 +223,11 @@ bool erase_bonds;
volatile bool ble_connection_st;
volatile bool data_tx_in_progress = false;
extern char m_static_passkey[6];
extern char SERIAL_NO[12];
extern char m_static_passkey[PASSKEY_LENGTH];
extern char SERIAL_NO[SERIAL_NO_LENGTH];
extern bool bond_data_delete;
uint8_t m_reset_status;
extern uint8_t m_pd_adc_cnt;
extern uint16_t m_pd_delay_us;
extern uint32_t m_life_cycle;
/*==============================================================================
@@ -306,14 +280,6 @@ static void full_gpio_init(void)
{
minimal_gpio_init();
LED_CONFIG();
LED_ALLOFF();
PD_CONFIG();
PD_ALLOFF();
trig_r_CONFIG();
trig_SW(false);
GAIN_SW_CONFIG();
AGC_GAIN_SW(false);
eeprom_control(OFF);
DBG_PRINTF("[GPIO] Full OK\r\n");
@@ -325,14 +291,12 @@ static void full_gpio_init(void)
*============================================================================*/
static void load_default_config(void)
{
memset(SERIAL_NO, 0, 16);
memset(SERIAL_NO, 0, SERIAL_NO_LENGTH);
memcpy(SERIAL_NO, FIRMWARE_SERIAL_NO, strlen(FIRMWARE_SERIAL_NO));
memset(m_static_passkey, 0, 16);
memcpy(m_static_passkey, "123456", 6);
memset(m_static_passkey, 0, PASSKEY_LENGTH);
memcpy(m_static_passkey, "123456", PASSKEY_LENGTH);
m_pd_delay_us = 8000;
m_pd_adc_cnt = 8;
m_reset_status = 1;
bond_data_delete = 1;
@@ -352,7 +316,7 @@ static void load_flash_config(void)
/* Hardware Number — fill default if empty */
if (m_config.hw_no[0] == 0 || m_config.hw_no[0] == (char)0xFF) {
memset(m_config.hw_no, 0, 12);
memset(m_config.hw_no, 0, HW_NO_LENGTH);
memcpy(m_config.hw_no, HARDWARE_VERSION, strlen(HARDWARE_VERSION));
DBG_PRINTF("[CFG] HW empty, set default: %s\r\n", HARDWARE_VERSION);
m_need_save_defaults = true;
@@ -360,19 +324,19 @@ static void load_flash_config(void)
/* Serial Number — fill default if empty */
if (m_config.serial_no[0] == 0 || m_config.serial_no[0] == (char)0xFF) {
memset(m_config.serial_no, 0, 12);
memset(m_config.serial_no, 0, SERIAL_NO_LENGTH);
memcpy(m_config.serial_no, FIRMWARE_SERIAL_NO, strlen(FIRMWARE_SERIAL_NO));
DBG_PRINTF("[CFG] S/N empty, set default: %s\r\n", FIRMWARE_SERIAL_NO);
m_need_save_defaults = true;
}
/* Serial Number → BLE device name */
memset(SERIAL_NO, 0, 16);
memcpy(SERIAL_NO, m_config.serial_no, 12);
memset(SERIAL_NO, 0, SERIAL_NO_LENGTH);
memcpy(SERIAL_NO, m_config.serial_no, SERIAL_NO_LENGTH);
/* Passkey */
memset(m_static_passkey, 0, 16);
memcpy(m_static_passkey, m_config.static_passkey, 6);
memset(m_static_passkey, 0, PASSKEY_LENGTH);
memcpy(m_static_passkey, m_config.static_passkey, PASSKEY_LENGTH);
/* Bond data delete flag */
bond_data_delete = m_config.bond_data_delete;
@@ -380,52 +344,12 @@ static void load_flash_config(void)
/* Reset status */
m_reset_status = m_config.reset_status;
/* Measurement parameters (with validation) */
m_pd_adc_cnt = (m_config.pd_adc_cnt > 0 && m_config.pd_adc_cnt <= 32)
? m_config.pd_adc_cnt : 8;
m_pd_delay_us = (m_config.pd_delay_us > 0)
? m_config.pd_delay_us : 8000;
DBG_PRINTF("[CFG] HW=%.12s S/N=%s passkey=%.6s bond=%d rst=%d adc=%d delay=%u\r\n",
DBG_PRINTF("[CFG] HW=%.12s S/N=%s passkey=%.6s bond=%d rst=%d\r\n",
m_config.hw_no, SERIAL_NO, m_static_passkey, bond_data_delete,
m_reset_status, m_pd_adc_cnt, m_pd_delay_us);
m_reset_status);
}
#if !DEBUG_MINIMAL_BOOT
static void load_eeprom_config(void)
{
DBG_PRINTF("[CFG] EEPROM loading...\r\n");
eeprom_initialize();
nrf_delay_us(10);
eeprom_init_values_read();
eeprom_uninitialize();
nrf_delay_us(50);
#if BLE_DEV_MODE
memset(SERIAL_NO, 0, 16);
memcpy(SERIAL_NO, FIRMWARE_SERIAL_NO, strlen(FIRMWARE_SERIAL_NO));
DBG_PRINTF("[CFG] DEV S/N=%s\r\n", SERIAL_NO);
#else
if (!is_valid_serial_no(SERIAL_NO))
{
memset(SERIAL_NO, 0, 16);
memcpy(SERIAL_NO, FIRMWARE_SERIAL_NO, strlen(FIRMWARE_SERIAL_NO));
}
char const init_pass[6] = "123456";
memset(m_static_passkey, 0, 16);
memcpy(m_static_passkey, (uint8_t *)init_pass, 6);
#endif
m_pd_delay_us = 8000;
m_pd_adc_cnt = 8;
m_reset_status = 1;
bond_data_delete = BLE_DEV_MODE ? 1 : 0;
DBG_PRINTF("[CFG] EEPROM OK\r\n");
}
#endif
/* load_eeprom_config() 삭제 — EEPROM 제거됨, FDS가 대체 - jhChun 26.03.16 */
/*==============================================================================
* TIMER CALLBACKS
@@ -468,11 +392,6 @@ static void timers_init(void)
main_timer_init();
battery_timer_init();
imm_check_timer_init();
m48_check_timer_init();
full_agc_timer_init();
full_agc_send_timer_init();
mea_send_timer_init();
power_timer_init();
#if FEATURE_PRINTF
@@ -879,8 +798,6 @@ static void ble_evt_handler(ble_evt_t const * p_ble_evt, void * p_context)
if (device_status == true)
{
LED_ALLOFF();
PD_ALLOFF();
if (device_sleep_mode() == 0)
{
device_status = false;
@@ -1150,7 +1067,7 @@ void device_power_off(void)
/*==============================================================================
* DATA TRANSMISSION
*============================================================================*/
void data_tx_handler(char const *p_data_to_send)
void data_tx_handler(char const *p_data_to_send) // 문자열 (ASCII 텍스트) 전송 함수
{
if (m_tx_in_progress) return;
@@ -1180,8 +1097,9 @@ void data_tx_handler(char const *p_data_to_send)
m_conn_handle = BLE_CONN_HANDLE_INVALID;
m_tx_in_progress = false;
} else {
DBG_PRINTF("[BLE TX] Err:0x%X\r\n", err_code); // APP_ERROR_CHECK 대신 로그 - jhChun 26.03.16
m_tx_in_progress = false;
APP_ERROR_CHECK(err_code);
//APP_ERROR_CHECK(err_code);
}
}
}
@@ -1245,46 +1163,10 @@ void ascii_format_data(uint8_t *buffer, const char *tag, const char *data_ascii,
}
}
void binary_tx_handler(uint8_t const *ble_bin_buff, uint16_t length)
{
uint32_t err_code;
static uint8_t tx_buffer[BLE_NUS_MAX_DATA_LEN] = {0};
if (ble_connection_st == 0) return;
data_tx_in_progress = true;
if (length * sizeof(uint16_t) > (BLE_NUS_MAX_DATA_LEN - 2)) return;
if (ble_connection_st == BLE_CONNECTED_ST)
{
memcpy(tx_buffer, ble_bin_buff, length * sizeof(uint16_t));
uint16_t crc = crc16_compute(tx_buffer, length * sizeof(uint16_t), NULL);
tx_buffer[length * sizeof(uint16_t)] = (uint8_t)(crc & 0xFF);
tx_buffer[length * sizeof(uint16_t) + 1] = (uint8_t)((crc >> 8) & 0xFF);
uint16_t total_len = length * sizeof(uint16_t) + 2;
do {
err_code = ble_nus_data_send(&m_nus, tx_buffer, &total_len, m_conn_handle);
if ((err_code != NRF_ERROR_INVALID_STATE) &&
(err_code != NRF_ERROR_RESOURCES) &&
(err_code != NRF_ERROR_NOT_FOUND))
{
nrf_delay_ms(10);
}
APP_ERROR_CHECK(err_code);
} while (err_code == NRF_ERROR_RESOURCES);
data_tx_in_progress = false;
}
}
/**
* @brief Safe BLE binary transmission with proper error handling
*
* Unlike binary_tx_handler which may assert on errors,
* this function properly handles NRF_ERROR_RESOURCES by retrying
* Properly handles NRF_ERROR_RESOURCES by retrying
* and returns gracefully on connection errors.
*
* @param ble_bin_buff Data buffer to send
@@ -1309,18 +1191,19 @@ void dr_sd_delay_ms(uint32_t ms)
nrf_delay_ms(ms);
}
void dr_binary_tx_safe(uint8_t const *ble_bin_buff, uint16_t length)
/* 기존 binary_tx_handler 함수 삭제 및 호출처 교체 - jhChun 26.03.16 */
void dr_binary_tx_safe(uint8_t const *ble_bin_buff, uint16_t length) // BLE로 바이너리 데이터를 안전하게 전송하는 함수
{
uint32_t err_code;
static uint8_t tx_buffer[BLE_NUS_MAX_DATA_LEN] = {0};
uint16_t retry_count = 0;
const uint16_t MAX_RETRIES = 100; /* Max retries (~500ms at 5ms each) */
if (ble_connection_st == 0) return;
if (ble_connection_st == 0) return; // 연결 확인
data_tx_in_progress = true;
if (length * sizeof(uint16_t) > (BLE_NUS_MAX_DATA_LEN - 2)) {
if (length * sizeof(uint16_t) > (BLE_NUS_MAX_DATA_LEN - 2)) { // 길이 검증 (CRC 2바이트 공간 확보)
data_tx_in_progress = false;
return;
}
@@ -1328,9 +1211,9 @@ void dr_binary_tx_safe(uint8_t const *ble_bin_buff, uint16_t length)
if (ble_connection_st == BLE_CONNECTED_ST)
{
memcpy(tx_buffer, ble_bin_buff, length * sizeof(uint16_t));
uint16_t crc = crc16_compute(tx_buffer, length * sizeof(uint16_t), NULL);
uint16_t crc = crc16_compute(tx_buffer, length * sizeof(uint16_t), NULL); // 버퍼 복사
tx_buffer[length * sizeof(uint16_t)] = (uint8_t)(crc & 0xFF);
tx_buffer[length * sizeof(uint16_t) + 1] = (uint8_t)((crc >> 8) & 0xFF);
tx_buffer[length * sizeof(uint16_t) + 1] = (uint8_t)((crc >> 8) & 0xFF); // CRC16 2바이트 추가
uint16_t total_len = length * sizeof(uint16_t) + 2;
@@ -1339,27 +1222,26 @@ void dr_binary_tx_safe(uint8_t const *ble_bin_buff, uint16_t length)
uint16_t send_len = total_len; /* MUST reset each iteration - ble_nus_data_send modifies it! */
err_code = ble_nus_data_send(&m_nus, tx_buffer, &send_len, m_conn_handle);
if (err_code == NRF_SUCCESS) {
if (err_code == NRF_SUCCESS) { // 전송 성공 -> 루프 탈출
/* TX queued successfully */
break;
} else if (err_code == NRF_ERROR_RESOURCES) {
} else if (err_code == NRF_ERROR_RESOURCES) { // TX 큐가 가득 찬 경우 5ms 대기 후 재시도 (최대 100회, ~500ms)
/* BLE TX queue full - wait for connection event to complete TX */
/* Use small delay to allow BLE stack to process TX complete events */
nrf_delay_ms(5); /* Wait ~5ms for TX slot to free up */
retry_count++;
} else if (err_code == NRF_ERROR_INVALID_STATE ||
err_code == NRF_ERROR_NOT_FOUND) {
} else if (err_code == NRF_ERROR_INVALID_STATE || err_code == NRF_ERROR_NOT_FOUND) { // 연결 끊김, 리턴
DBG_PRINTF("[BLE TX] Disconnected\r\n");
data_tx_in_progress = false;
return;
} else {
} else { // 기타 에러 -> 로그 출력 후 리턴
DBG_PRINTF("[BLE TX] Err:0x%X\r\n", err_code);
data_tx_in_progress = false;
return;
}
} while (retry_count < MAX_RETRIES);
if (retry_count >= MAX_RETRIES) {
if (retry_count >= MAX_RETRIES) { // 최대 재시도(100회) 초과 시 해당 패킷 드롭, 연결은 유지
DBG_PRINTF("[BLE TX] FAIL %u retries\r\n", retry_count);
data_tx_in_progress = false;
/* Don't set ble_connection_st = 0 here - just drop this packet and continue */
@@ -1395,15 +1277,10 @@ static void main_s(void * p_context)
power_control_handler(ON);
nrf_delay_ms(100);
bond_data_delete = true;
eeprom_initialize();
nrf_delay_ms(10);
eeprom_write_byte(0x0060, (uint8_t)bond_data_delete);
nrf_delay_ms(20);
const char pass_init[6] = "123456";
eeprom_write_encrypted(0x0020, (uint8_t *)pass_init, 6);
nrf_delay_ms(10);
eeprom_init_values_read();
eeprom_uninitialize();
m_config.bond_data_delete = (uint8_t)bond_data_delete;
const char pass_init[PASSKEY_LENGTH] = "123456";
memcpy(m_config.static_passkey, pass_init, PASSKEY_LENGTH);
config_save();
nrf_delay_ms(1000);
go_device_power_off = true;
main_timer_start();
@@ -1435,16 +1312,10 @@ static void main_s(void * p_context)
advertising_start();
#endif
ada2200_init();
nrf_delay_ms(1);
mcp4725_init();
nrf_delay_ms(1);
ad5272_i2c_init();
m_reset_status = 1;
eeprom_write_byte(0x0065, m_reset_status);
nrf_delay_ms(10);
eeprom_init_values_read();
m_config.reset_status = m_reset_status;
config_save();
#endif
m_reset_status = 1;
DBG_PRINTF("[BOOT] Ready\r\n");

8
project/ble_peripheral/ble_app_bladder_patch/main.h
View File

@@ -9,6 +9,13 @@
#ifndef MAIN_H__
#define MAIN_H__
/*==============================================================================
* DATA LENGTH CONSTANTS
*============================================================================*/
#define SERIAL_NO_LENGTH 12
#define HW_NO_LENGTH 12
#define PASSKEY_LENGTH 6
#include <stdio.h>
#include <string.h>
#include <stdarg.h>
@@ -54,7 +61,6 @@ static void PM_s(void * p_context);
static void main_routine_handler(void * p_context);
void received_command_process(uint8_t const *data_array, which_cmd_t cmd_t,uint8_t length);
void data_tx_handler(char const *p_data_to_send);
void binary_tx_handler(uint8_t const *ble_bin_buff , uint16_t length);
void dr_binary_tx_safe(uint8_t const *ble_bin_buff, uint16_t length);
void dr_sd_delay_ms(uint32_t ms);
void single_format_data(uint8_t *buffer, const char *tag, const uint16_t value) ;

33
project/ble_peripheral/ble_app_bladder_patch/main_timer.c
View File

@@ -28,14 +28,8 @@
#include "main_timer.h"
#include "tmp235_q1.h"
//#include "fstorage.h"
//#include "meas_pd_voltage_custom.h"
#include "meas_pd_imm.h"
#include "meas_pd_voltage_full.h"
#include "mcp4725_i2c.h"
#include "ad5272_i2c.h"
#include "power_control.h"
#include <cmd_parse.h>
#include "meas_pd_48.h"
#include "debug_print.h"
#include "i2c_manager.h" //add cj
APP_TIMER_DEF(m_main_loop_timer_id);
@@ -55,15 +49,12 @@ extern which_cmd_t cmd_type_t;
#endif
bool go_batt= false;
bool go_temp= false;
bool go_pdread= false;
bool go_device_power_off = false;
bool go_sleep_mode_enter = false;
bool go_NVIC_SystemReset = false;
bool motion_raw_data_enabled = false;
bool ble_got_new_data = false;
bool motion_data_once = false;
bool adc_enabled = false;
static uint16_t cnt_adc = 0;
void main_loop(void * p_context) /* For x ms */
{
UNUSED_PARAMETER(p_context);
@@ -148,30 +139,6 @@ void main_loop(void * p_context) /* For x ms */
// main_timer_start();
}
if(go_pdread == true) {
//DBG_PRINTF("PD48 ADC=%d\r\n",cnt_adc);
main_timer_stop();
go_pdread = false;
m48_adc_start_init();
}
if(adc_enabled == true) {
main_timer_stop();
DBG_PRINTF("PD48 ADC=%d\r\n",cnt_adc);
if(ble_got_new_data==false){
if (cnt_adc<500){
cnt_adc++;
}
else if (cnt_adc == 500){
cnt_adc = 0;
}
main_timer_start();
}
}

114
project/ble_peripheral/ble_app_bladder_patch/mcp4725_adc.c
View File

@@ -1,114 +0,0 @@
/*******************************************************************************
* @file mcp4725_adc.c
* @author CandyPops Co.
* @version V1.0.0
* @date 2022-09-05
* @brief
******************************************************************************/
#include "sdk_common.h"
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include "nrf.h"
#include "boards.h"
#include "app_error.h"
#include "nrf_drv_saadc.h"
#include "ble_nus.h"
#include "mcp4725_adc.h"
#include "main.h"
#include "debug_print.h"
#define MCP4725_REF_VOLTAGE_IN_MILLIVOLTS 600.0f /**< Reference voltage (in milli volts) used by ADC while doing conversion. */
#define MCP4725_PRE_SCALING_COMPENSATION 6.0f /**< The ADC is configured to use VDD with 1/3 prescaling as input. And hence the result of conversion is to be multiplied by 3 to get the actual value of the battery voltage.*/
#define MCP4725_ADC_RES_10BITS 1024.0f /**< Maximum digital value for 10-bit ADC conversion. */
/**@brief Macro to convert the result of ADC conversion in millivolts.
*
* @param[in] ADC_VALUE ADC result.
*
* @retval Result converted to millivolts.
*/
#define MCP4725_VOUT_IN_MILLI_VOLTS(ADC_VALUE)\
((((ADC_VALUE) * MCP4725_REF_VOLTAGE_IN_MILLIVOLTS) / MCP4725_ADC_RES_10BITS) * MCP4725_PRE_SCALING_COMPENSATION)
#define ADC_SAMPLES_IN_BUFFER 1
static nrf_saadc_value_t mcp4725_adc_buf[2][ADC_SAMPLES_IN_BUFFER];
float mcp4725_voltage_in_milli_volts = 0;
//extern char ble_tx_buffer[BLE_NUS_MAX_DATA_LEN];
extern which_cmd_t cmd_type_t;
extern uint8_t ble_bin_buffer[BLE_NUS_MAX_DATA_LEN] ;
/**@brief Function for handling the ADC interrupt.
*
* @details This function will fetch the conversion result from the ADC, convert the value into
* percentage and send it to peer.
*/
void mcp4725_voltage_handler(nrf_drv_saadc_evt_t const * p_event) /* ADC_GAIN reading */
{
float Vref = 3.3f; /* It same as Vdd */
float dac_value = 0.0f;
uint16_t dac_value_16=0;
if (p_event->type == NRF_DRV_SAADC_EVT_DONE)
{
nrf_saadc_value_t adc_result;
nrf_drv_saadc_buffer_convert(p_event->data.done.p_buffer, ADC_SAMPLES_IN_BUFFER);
adc_result = p_event->data.done.p_buffer[0];
nrf_drv_saadc_uninit();
nrf_drv_saadc_channel_uninit(0);
mcp4725_voltage_in_milli_volts = MCP4725_VOUT_IN_MILLI_VOLTS(adc_result);
#if FEATURE_DETAIL_VALUE_AGC
DBG_PRINTF("AGC read Vol: %f(mV)\r\n", mcp4725_voltage_in_milli_volts);
#endif
/* For MCP4725, Dn = (Vout/Vref) x 4096, Vref = Vdd */
dac_value = (((mcp4725_voltage_in_milli_volts/Vref) * 4096.0f)/1000.0f); /* Unit is Volt */
if(cmd_type_t == CMD_UART) {
DBG_PRINTF("Te%d\r\n\r\n",(uint16_t)(dac_value + 0.5f));
} else if(cmd_type_t == CMD_BLE) {
dac_value_16 = (uint16_t)(dac_value + 0.5f);
single_format_data(ble_bin_buffer, "rse:", dac_value_16);
binary_tx_handler(ble_bin_buffer,3);
// sprintf(ble_tx_buffer, "Te%d\r\n",(uint16_t)(dac_value + 0.5f));
// data_tx_handler(ble_tx_buffer);
}
}
}
void mcp4725_adc_init(void)
{
ret_code_t err_code = nrf_drv_saadc_init(NULL, mcp4725_voltage_handler);
APP_ERROR_CHECK(err_code);
nrf_saadc_channel_config_t config =
NRFX_SAADC_DEFAULT_CHANNEL_CONFIG_SE(NRF_SAADC_INPUT_AIN6); /* FSA5157P6X Voltage Output Measurement */
err_code = nrf_drv_saadc_channel_init(0, &config);
APP_ERROR_CHECK(err_code);
err_code = nrf_drv_saadc_buffer_convert(mcp4725_adc_buf[0], ADC_SAMPLES_IN_BUFFER);
APP_ERROR_CHECK(err_code);
err_code = nrf_drv_saadc_buffer_convert(mcp4725_adc_buf[1], ADC_SAMPLES_IN_BUFFER);
APP_ERROR_CHECK(err_code);
err_code = nrf_drv_saadc_sample();
APP_ERROR_CHECK(err_code);
}
void mcp4725_voltage_level_meas(void)
{
mcp4725_adc_init();
}

16
project/ble_peripheral/ble_app_bladder_patch/mcp4725_adc.h
View File

@@ -1,16 +0,0 @@
/*******************************************************************************
* @file mcp4725.h
* @author CandyPops Co.
* @version V1.0.0
* @date 2022-09-05
* @brief
******************************************************************************/
#ifndef _MCP4725_ADC_H_
#define _MCP4725_ADC_H_
void mcp4725_adc_init(void);
void mcp4725_voltage_level_meas(void);
#endif /* !_MCP4725_ADC_H_ */

513
project/ble_peripheral/ble_app_bladder_patch/mcp4725_i2c.c
View File

@@ -1,513 +0,0 @@
/*******************************************************************************
* @file mcp4725_i2c.c
* @author CandyPops Co.
* @version V1.0.0
* @date 2022-09-05
* @brief
******************************************************************************/
/* board driver */
#include <stdio.h>
#include <string.h>
#include <stdarg.h>
#include <stdbool.h>
#include <math.h>
#include "nrf.h"
#include "app_error.h"
#include "boards.h"
#include "nrfx_gpiote.h"
#include "mcp4725_i2c.h"
#include "nrf_delay.h"
#include "debug_print.h"
/* I2C number and slave address for MCP4725 */
#define MCP4725_I2C_ADDR_7bit 0x66
uint8_t MCP4725_I2C_ADDR = MCP4725_I2C_ADDR_7bit << 1;
uint16_t _lastValue;
uint8_t _powerDownMode;
uint32_t _lastWriteEEPROM;
void mcp4725_i2c_initialize(void)
{
SCL_OUT();
SDA_OUT();
SCL_H();
SDA_H();
}
static uint8_t mcp4725_i2c_write(uint8_t data)
{
for(uint8_t i = 0; i < 8; i++)
{
// MSB first
if(data & 0x80) SDA_H();
else SDA_L();
i2c_clock();
data = data << 1;
}
// read ACK
SDA_H(); // leave SDA HI
SDA_IN(); // change direction to input on SDA line
i2c_delay();
SCL_H(); // clock back up
i2c_delay();
uint8_t ack = SDA_READ(); // get the ACK bit
SCL_L();
SDA_OUT(); // change direction back to output
if(ack) {
DBG_PRINTF("ACK Extra=%d,Data=%d\r\n", ack,data);
}
return ack;
}
static uint8_t mcp4725_i2c_read(bool ack)
{
uint8_t data;
SDA_H(); // leave SDA HI
SDA_IN(); // change direction to input on SDA line
data = 0;
for(uint8_t i = 0; i < 8; i++)
{
// MSB first
data = data << 1;
SCL_H();
do{
}while(SCL_READ() != 0); // Wait for any SCL clock stratching
i2c_delay();
if(SDA_READ()) // get the Data bit
data |= 1;
else
data |= 0;
SCL_L(); // clock LO
i2c_delay();
}
SDA_OUT(); // change direction back to output
// send ACK
if(ack == ACK) SDA_L();
else if(ack == NACK) SDA_H();
i2c_clock();
SDA_H(); // leave with SDA HI
return data;
}
void mcp4725_writeFastMode(const uint16_t value)
{
uint8_t low = value & 0xFF;
uint8_t high = ((value >> 8) & 0x0F); // set C2,c1 == 0,0(FastMode Write) pd1,pd0 == 0,0 (Normal Mode)
i2c_start();
mcp4725_i2c_write(MCP4725_I2C_ADDR|TWI_WRITE); // slave address
//uint8_t address = MCP4725_I2C_ADDR | TWI_WRITE;
//DBG_PRINTF("[I2C] Write to 0x%02X\r\n", address); //oxCC
mcp4725_i2c_write(high); // value1 ~ 3
mcp4725_i2c_write(low);
i2c_stop();
}
void mcp4725_generalCall(const uint8_t gc)
{
i2c_start();
mcp4725_i2c_write(0x00); // First Byte 0x00
mcp4725_i2c_write(gc); // Second Byte, General Call Reset = 0x06, General Call Wake-Up = 0x09
i2c_stop();
}
void mcp4725_init(void)
{
mcp4725_i2c_initialize();
}
// DAC value is reset to EEPROM value
// need to reflect this in cached value
void mcp4725_powerOnReset(void)
{
mcp4725_generalCall(MCP4725_GC_RESET);
}
// _powerDownMode DAC resets to 0 -- PDM EEPROM stays same !!!
// need to reflect this in cached value
void mcp4725_powerOnWakeUp(void)
{
mcp4725_generalCall(MCP4725_GC_WAKEUP);
}
/* 현재 DAC값 읽어서 그 값에 Power Down 넣고 Write */
void mcp4725_PowerDownMode(void)
{
uint8_t low = 0x00; //read_value & 0xFF;
uint8_t high = 0x00; //((read_value >> 8) & 0x0F);
high = high | (MCP4725_PDMODE_1K << 4); // set C2,c1 == 0,0(FastMode Write) pd1,pd0 == 0,1 (Power Down Mode, 1Kohm to GND)
i2c_start();
mcp4725_i2c_write(MCP4725_I2C_ADDR|TWI_WRITE); // slave address
mcp4725_i2c_write(high); // value
mcp4725_i2c_write(low);
i2c_stop();
}
////////////////////////////////////////////////////////////////////////////////
uint16_t mcp4725_readDAC(void)
{
while(!mcp4725_ready());
uint8_t buffer[3];
mcp4725_readRegister(buffer, 3);
uint16_t value = buffer[1];
value = value << 4;
value = value + (buffer[2] >> 4);
return value;
}
// ready checks if the last write to EEPROM has been written.
// until ready all writes to the MCP4725 are ignored!
bool mcp4725_ready(void)
{
uint8_t buffer[1];
mcp4725_readRegister(buffer, 1);
return ((buffer[0] & 0x80) > 0);
}
void mcp4725_writeRegisterMode(const uint16_t value, uint8_t reg)
{
uint8_t high = (value / 16);
uint8_t low = (value & 0x0F) << 4;
reg = reg | (_powerDownMode << 1);
i2c_start();
mcp4725_i2c_write(MCP4725_I2C_ADDR|TWI_WRITE); // slave address
mcp4725_i2c_write(reg); // configuration
mcp4725_i2c_write(high); // value1 ~ 3
mcp4725_i2c_write(low);
i2c_stop();
}
void mcp4725_readRegister(uint8_t* buffer, const uint8_t length)
{
i2c_start();
mcp4725_i2c_write(MCP4725_I2C_ADDR|TWI_READ); // slave address with READ
switch(length) {
case 1:
buffer[0] = mcp4725_i2c_read(NACK); // NACK, SDA = 1;
break;
case 2:
buffer[0] = mcp4725_i2c_read(ACK); // ACK, SDA = 0;
buffer[1] = mcp4725_i2c_read(NACK); // NACK, SDA = 1;
break;
case 3:
buffer[0] = mcp4725_i2c_read(ACK); // ACK, SDA = 0;
buffer[1] = mcp4725_i2c_read(ACK); // ACK, SDA = 0;
buffer[2] = mcp4725_i2c_read(NACK); // NACK, SDA = 1;
break;
case 4:
buffer[0] = mcp4725_i2c_read(ACK); // ACK, SDA = 0;
buffer[1] = mcp4725_i2c_read(ACK); // ACK, SDA = 0;
buffer[2] = mcp4725_i2c_read(ACK); // ACK, SDA = 0;
buffer[3] = mcp4725_i2c_read(NACK); // NACK, SDA = 1;
break;
case 5:
buffer[0] = mcp4725_i2c_read(ACK); // ACK, SDA = 0;
buffer[1] = mcp4725_i2c_read(ACK); // ACK, SDA = 0;
buffer[2] = mcp4725_i2c_read(ACK); // ACK, SDA = 0;
buffer[3] = mcp4725_i2c_read(ACK); // ACK, SDA = 0;
buffer[4] = mcp4725_i2c_read(NACK); // NACK, SDA = 1;
break;
default:
#if FEATURE_PRINTF
DBG_PRINTF("ERR!! mcp4725_i2c_readregister\r\n");
#endif
break;
}
i2c_stop();
}
void mcp4725_setValue(const uint16_t value)
{
if (value == _lastValue) return;
if (value > MCP4725_MAXVALUE) return;
mcp4725_writeFastMode(value);
_lastValue = value;
}
uint16_t mcp4725_getValue(void)
{
return _lastValue;
}
void mcp4725_setPercentage(float percentage)
{
if ((percentage > 100) || (percentage < 0))
DBG_PRINTF("ERR!!! mcp4725 percentage error\r\n");
mcp4725_setValue(round(percentage * (0.01 * MCP4725_MAXVALUE)));
}
// unfortunately it is not possible to write a different value
// to the DAC and EEPROM simultaneously or write EEPROM only.
void mcp4725_writeDAC(const uint16_t value, const bool EEPROM)
{
if (value > MCP4725_MAXVALUE)
#if FEATURE_PRINTF
DBG_PRINTF("ERR!!! mcp4725 writeDAC error\r\n");
#endif
while(!mcp4725_ready());
mcp4725_writeRegisterMode(value, EEPROM ? MCP4725_DACEEPROM : MCP4725_DAC);
_lastValue = value;
}
uint16_t mcp4725_readEEPROM(void)
{
while(!mcp4725_ready());
uint8_t buffer[5];
mcp4725_readRegister(buffer, 5);
uint16_t value = buffer[3] & 0x0F;
value = value << 8;
value = value + buffer[4];
return value;
}
// depending on bool EEPROM the value of PDM is written to
// (false) DAC or
// (true) DAC & EEPROM,
void mcp4725_writePowerDownMode(const uint8_t PDM, const bool EEPROM)
{
_powerDownMode = (PDM & 0x03); // mask PDM bits only (written later low level)
_lastValue = mcp4725_readDAC();
_powerDownMode = mcp4725_readPowerDownModeDAC();
mcp4725_writeDAC(_lastValue, EEPROM);
}
uint8_t mcp4725_readPowerDownModeEEPROM(void)
{
while(!mcp4725_ready());
uint8_t buffer[4];
mcp4725_readRegister(buffer, 4);
uint8_t value = (buffer[3] >> 5) & 0x03;
return value;
}
uint8_t mcp4725_readPowerDownModeDAC(void)
{
while(!mcp4725_ready()); // TODO needed?
uint8_t buffer[1];
mcp4725_readRegister(buffer, 1);
uint8_t value = (buffer[0] >> 1) & 0x03;
return value;
}
void ds_i2c_start(void) {
SDA_H();//nrf_gpio_pin_set(I2C_SDA_PIN);
SCL_H();//nrf_gpio_pin_set(I2C_SCL_PIN);
i2c_delay();//nrf_delay_us(I2C_DELAY_US);
SDA_L();//nrf_gpio_pin_clear(I2C_SDA_PIN);
i2c_delay();//nrf_delay_us(I2C_DELAY_US);
SCL_L();//nrf_gpio_pin_clear(I2C_SCL_PIN);
i2c_delay();//nrf_delay_us(I2C_DELAY_US);
}
void ds_i2c_stop(void) {
i2c_delay();//nrf_delay_us(I2C_DELAY_US);
SDA_L();//nrf_gpio_pin_clear(I2C_SDA_PIN);
SCL_H();// nrf_gpio_pin_set(I2C_SCL_PIN);
i2c_delay();//nrf_delay_us(I2C_DELAY_US);
SDA_H();//nrf_gpio_pin_set(I2C_SDA_PIN);
i2c_delay();//nrf_delay_us(I2C_DELAY_US);
}
void i2c_write_bit(uint8_t bit) {
if (bit) {
SDA_H();
} else {
SDA_L();
}
i2c_delay();//nrf_delay_us(I2C_DELAY_US);
SCL_H(); //nrf_gpio_pin_set(SCL_PIN);
i2c_delay();//nrf_delay_us(I2C_DELAY_US);
SCL_L();//nrf_gpio_pin_clear(SCL_PIN);
}
uint8_t i2c_read_bit(void) {
uint8_t bit;
SDA_IN();//nrf_gpio_cfg_input(SDA_PIN, NRF_GPIO_PIN_NOPULL);
i2c_delay();//nrf_delay_us(I2C_DELAY_US);
SCL_H(); ////nrf_gpio_pin_set(SCL_PIN);
i2c_delay();//nrf_delay_us(I2C_DELAY_US);
bit = SDA_READ();//nrf_gpio_pin_read(SDA_PIN);
SCL_L(); //nrf_gpio_pin_clear(SCL_PIN);
SDA_OUT();//nrf_gpio_cfg_output(SDA_PIN);
return bit;
}
uint8_t i2c_write_byte(uint8_t byte) {
for (uint8_t i = 0; i < 8; i++) {
i2c_write_bit(byte & 0x80);
byte <<= 1;
}
return i2c_read_bit(); // Read ACK/NACK
}
uint8_t i2c_read_byte(uint8_t ack) {
uint8_t byte = 0;
SDA_IN();//nrf_gpio_cfg_input(SDA_PIN, NRF_GPIO_PIN_NOPULL);
for (uint8_t i = 0; i < 8; i++) {
byte <<= 1;
byte |= i2c_read_bit();
}
SDA_OUT();//nrf_gpio_cfg_output(SDA_PIN);
i2c_write_bit(!ack); // Send ACK/NACK
return byte;
}
void i2c_repeated_start(void) {
SDA_H();//nrf_gpio_pin_set(SDA_PIN);
SCL_H();//nrf_gpio_pin_set(SCL_PIN);
i2c_delay();//nrf_delay_us(I2C_DELAY_US);
SDA_L();////nrf_gpio_pin_clear(SDA_PIN);
i2c_delay();//nrf_delay_us(I2C_DELAY_US);
SCL_L();//nrf_gpio_pin_clear(SCL_PIN);
}
// i2c_start();
// i2c_write_byte(I2C_ADDRESS << 1); // Write address
// i2c_write_byte(0x00); // Register address
// i2c_write_byte(0xFF); // Data
// i2c_stop();
// // Read example
// i2c_start();
// i2c_write_byte((I2C_ADDRESS << 1) | 1); // Read address
// uint8_t data = i2c_read_byte(0); // Read data with NACK
// i2c_stop();
void DS3930_write(uint8_t id, uint8_t addr, uint8_t wdata)
{
//i2c_start();
// ds_i2c_stop();
ds_i2c_start();
i2c_write_byte(id << 1); // Write address
i2c_write_byte(addr); // Register address
i2c_write_byte(wdata); // Data
// mcp4725_i2c_write(id << 1);
// mcp4725_i2c_write(addr);
// mcp4725_i2c_write(wdata);
//
// }
//i2c_delay();
//i2c_stop();
ds_i2c_stop();
}
uint8_t DS3930_read(uint8_t id, uint8_t addr, uint8_t* rdata)
{
ds_i2c_start();
i2c_write_byte(id << 1); // Write address
i2c_write_byte(addr); // Register address
i2c_repeated_start();
i2c_write_byte((id << 1) | 1); // Read address
uint8_t data = i2c_read_byte(0); // Read data with NACK
ds_i2c_stop();
rdata[0] = data;
DBG_PRINTF("Data 0x%x . \r\n", data);
//i2c_stop();
return data;
}
//void CAT24_write(uint8_t id, uint8_t addr, uint8_t* wdata)
//{
////i2c_start();
//// ds_i2c_stop();
// ds_i2c_start();
// i2c_write_byte(id << 1); // Write address
// i2c_write_byte(addr); // Register address
// i2c_write_byte(wdata); // Data
//
//// mcp4725_i2c_write(id << 1);
//// mcp4725_i2c_write(addr);
//// mcp4725_i2c_write(wdata);
////
//// }
////i2c_delay();
////i2c_stop();
// ds_i2c_stop();
//}
//uint8_t CAT24_read(uint8_t id, uint8_t addr, uint8_t* rdata,uint8_t length)
//{
// ds_i2c_start();
// i2c_write_byte(id << 1); // Write address
// i2c_write_byte(addr); // Register address
// i2c_repeated_start();
// i2c_write_byte((id << 1) | 1); // Read address
// uint8_t data = i2c_read_byte(0); // Read data with NACK
// ds_i2c_stop();
// rdata[0] = data;
// DBG_PRINTF("Data 0x%x . \r\n", data);
// //i2c_stop();
// return data;
//}

92
project/ble_peripheral/ble_app_bladder_patch/mcp4725_i2c.h
View File

@@ -1,92 +0,0 @@
/*******************************************************************************
* @file mcp4725_i2c.h
* @author CandyPops Co.
* @version V1.0.0
* @date 2022-09-05
* @brief
******************************************************************************/
#include "sdk_common.h"
#include <stdbool.h>
#include "nrf.h"
#include "nrf_drv_gpiote.h"
#ifndef _MCP4725_I2C_H_
#define _MCP4725_I2C_H_
#define MCP4725_I2C_SDA_PIN NRF_GPIO_PIN_MAP(1,15)//cj edit
#define MCP4725_I2C_SCL_PIN NRF_GPIO_PIN_MAP(1,14) //cd eidt
#define SDA_H() nrf_gpio_pin_set(MCP4725_I2C_SDA_PIN) // SDA pin high
#define SDA_L() nrf_gpio_pin_clear(MCP4725_I2C_SDA_PIN) // SDA pin low
#define SCL_H() nrf_gpio_pin_set(MCP4725_I2C_SCL_PIN) // SCL pin high
#define SCL_L() nrf_gpio_pin_clear(MCP4725_I2C_SCL_PIN) // SCL pin low
#define SDA_OUT() nrf_gpio_cfg_output(MCP4725_I2C_SDA_PIN) // SDA pin output mode
#define SCL_OUT() nrf_gpio_cfg_output(MCP4725_I2C_SCL_PIN) // SCL pin output mode
#define SDA_IN() nrf_gpio_cfg_input(MCP4725_I2C_SDA_PIN, NRF_GPIO_PIN_NOPULL) // SDA pin input mode
#define SDA_READ() nrf_gpio_pin_read(MCP4725_I2C_SDA_PIN) // SDA pin read
#define SCL_READ() nrf_gpio_pin_read(MCP4725_I2C_SCL_PIN) // SCL pin read
#define i2c_delay() nrf_delay_us(1) // delay time for 400khz clock 1
#define i2c_clock() { i2c_delay(); SCL_H(); i2c_delay(); SCL_L(); }
#define i2c_start() { SDA_H(); i2c_delay(); SCL_H(); i2c_delay(); SDA_L(); i2c_delay(); SCL_L(); i2c_delay();}
#define i2c_stop() { SDA_L(); i2c_delay(); SCL_H(); i2c_delay(); SDA_H(); i2c_delay(); }
#define TWI_WRITE 0x00
#define TWI_READ 0x01
#define ACK true
#define NACK false
#define DAC_write false
#define EEPROM_write true
// constants
#define MCP4725_MAXVALUE 4095
// registerMode
#define MCP4725_DAC 0x40
#define MCP4725_DACEEPROM 0x60
// reset & wake up
#define MCP4725_GC_RESET 0x06
#define MCP4725_GC_WAKEUP 0x09
// powerDown Mode - TODO ENUM?
#define MCP4725_PDMODE_NORMAL 0x00
#define MCP4725_PDMODE_1K 0x01
#define MCP4725_PDMODE_100K 0x02
#define MCP4725_PDMODE_500K 0x03
void mcp4725_i2c_initialize(void);
void mcp4725_writeFastMode(const uint16_t value);
void mcp4725_generalCall(const uint8_t gc);
void mcp4725_init(void);
void mcp4725_powerOnReset(void);
void mcp4725_powerOnWakeUp(void);
void mcp4725_PowerDownMode(void);
/* * * * * * * * * * * * * * * * * * * * */
uint16_t mcp4725_readDAC(void);
bool mcp4725_ready(void);
uint16_t mcp4725_readDAC(void);
bool mcp4725_ready(void);
void mcp4725_writeRegisterMode(const uint16_t value, uint8_t reg);
void mcp4725_readRegister(uint8_t* buffer, const uint8_t length);
void mcp4725_setValue(const uint16_t value);
uint16_t mcp4725_getValue(void);
void mcp4725_setPercentage(float percentage);
void mcp4725_writeDAC(const uint16_t value, const bool EEPROM);
uint16_t mcp4725_readEEPROM(void);
void mcp4725_writePowerDownMode(const uint8_t PDM, const bool EEPROM);
uint8_t mcp4725_readPowerDownModeEEPROM(void);
uint8_t mcp4725_readPowerDownModeDAC(void);
void DS3930_write(uint8_t id, uint8_t addr, uint8_t wdata);
uint8_t DS3930_read(uint8_t id, uint8_t addr, uint8_t* rdata);
#endif /* !_MCP4725_I2C_H_ */

913
project/ble_peripheral/ble_app_bladder_patch/meas_pd_48.c
View File

@@ -1,913 +0,0 @@
/*******************************************************************************
TEST medi50 Dec 23
mmeas_pd_48.c
******************************************************************************/
#include "sdk_common.h"
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include "nrf.h"
#include "boards.h"
#include "app_error.h"
#include "nrf_drv_saadc.h"
#include "nrfx_gpiote.h"
#include "app_timer.h"
#include "nrf_drv_timer.h"
#include "nrf_delay.h"
#include "nrf_drv_ppi.h"
#include "ada2200_spi.h"
#include "ble_nus.h"
//#include "fstorage.h"
#include "measurements.h"
#include "meas_pd_48.h"
#include "mcp4725_i2c.h"
#include "ad5272_i2c.h"
#include "main_timer.h"
#include "battery_saadc.h"
#include "tmp235_q1.h"
#include "main.h"
#include "app_raw_main.h"
#include <cmd_parse.h>
#include "debug_print.h"
extern bool info4; //cmd_parse add 3other items.
uint8_t ADC_PD_MODE = 0; //0: Full 1: Full Continuous 2: HALF 1 3: HALF 1 Continuous 4: Half2 5: Half 2 Countiuous.
uint8_t m48_samples_in_buffer = 8;
uint8_t CURRENT_LED_NO = 24;//48
//uint8_t CURRENT_list_m48[m48_LED_NO]={0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23, 24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47};
uint8_t CURRENT_list_m48[m48_LED_NO]={0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23};
//uint32_t s_cnt;
//static const uint8_t LED_list_m48[m48_LED_NO]={0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23, 24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47};
static const uint8_t LED_list_m48[m48_LED_NO]={0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23};
static const uint8_t LED_list_m48_1h[m48_LED_NO_H] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23};
static const uint8_t LED_list_m48_2h[m48_LED_NO_H] = {24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47};
extern uint16_t m_pd_delay_us;
//int32_t c_max;
extern volatile bool processing;
extern volatile bool data_tx_in_progress;
extern volatile bool ble_connection_st;
extern bool go_temp;
extern bool go_batt;
//extern bool ble_got_new_data;
////extern bool motion_data_once;
uint16_t volatile info_batt = 0;
uint16_t volatile info_temp = 0;
uint16_t volatile info_imu[6]={0,1,2,3,4,5};
// new add Pressure
uint16_t volatile info_p1 = 0;
uint16_t volatile info_p2 = 0;
uint32_t m48_cnt;
static int8_t pd_no = -1;
static int8_t led_no = -1;
static int8_t buf_no = 0;
//static int8_t order = 0;
//static int8_t c_max = 5;
static int32_t t_ms = 0;
uint8_t order_pd=0;
/* /int16_t buff_m48_cycle_old[48][m48_CYCLE_CNT] =
// {
// {0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}, //0
// {0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}, //1
// {0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}, //2
// {0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}, //3
// {0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}, //4
// {0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}, //5
// {0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}, //6
// {0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}, //7
// {0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}, //8
// {0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}, //9
//
// {0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}, //0
// {0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}, //1
// {0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}, //2
// {0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}, //3
// {0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}, //4
// {0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}, //5
// {0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}, //6
// {0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}, //7
// {0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}, //8
// {0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}, //9
//
//
// {0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}, //0
// {0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}, //1
// {0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}, //2
// {0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}, //3
// {0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}, //4
// {0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}, //5
// {0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}, //6
// {0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}, //7
// {0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}, //8
// {0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}, //9
//
//
// {0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}, //0
// {0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}, //1
// {0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}, //2
// {0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}, //3
// {0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}, //4
// {0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}, //5
// {0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}, //6
// {0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}, //7
// {0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}, //8
// {0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}, //9
//
//
// {0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}, //0
// {0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}, //1
// {0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}, //2
// {0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}, //3
// {0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}, //4
// {0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}, //5
// {0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}, //6
// {0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}, //7
// }; */
int16_t buff_m48_cycle[m48_LED_NO][m48_CYCLE_CNT] =
{
{0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}, //0
{0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}, //1
{0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}, //2
{0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}, //3
{0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}, //4
{0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}, //5
{0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}, //6
{0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}, //7
{0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}, //8
{0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}, //9
{0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}, //0
{0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}, //1
{0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}, //2
{0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}, //3
{0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}, //4
{0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}, //5
{0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}, //6
{0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}, //7
{0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}, //8
{0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}, //9
{0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}, //0
{0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}, //1
{0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}, //2
{0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}, //3
};
//int16_t m48_cycle_send_buff[m48_LED_NO] = {0, 0, 0, 0, 0, 0, 0, 0, 0,0,0, 0, 0, 0, 0, 0, 0, 0, 0,0,0, 0, 0, 0, 0, 0, 0, 0, 0,0,0, 0, 0, 0, 0, 0, 0, 0, 0,0,0, 0, 0, 0, 0, 0, 0, 0}
int16_t m48_cycle_send_buff[m48_LED_NO] = {0, 0, 0, 0, 0, 0, 0, 0, 0,0,0, 0, 0, 0, 0, 0, 0, 0, 0,0,0, 0, 0, 0,}; //24 size
//int16_t buff_cycle_send_buff1[buff_LED_NO] = {0, };
//int16_t buff_cycle_send_buff2[buff_LED_NO] = {0, };
//int16_t buff_cycle_send_buff3[buff_LED_NO] = {0, };
//int16_t buff_cycle_send_buff4[buff_LED_NO] = {0, };
//int16_t buff_cycle_send_buff5[buff_LED_NO] = {0, };
//int16_t buff_cycle_send_buff6[buff_LED_NO] = {0, };
//int16_t buff_cycle_send_buff7[buff_LED_NO] = {0, };
//int16_t buff_cycle_send_buff8[buff_LED_NO] = {0, };
//int16_t buff_cycle_send_buff9[buff_LED_NO] = {0, };
// uint16_t bi_buff_cycle_send_buff[10][m48_LED_NO] = {
// {0, 0, 0, 0, 0, 0, 0, 0, 0,0,0, 0, 0, 0, 0, 0, 0, 0, 0,0,0, 0, 0, 0, 0, 0, 0, 0, 0,0,0, 0, 0, 0, 0, 0, 0, 0, 0,0,0, 0, 0, 0, 0, 0, 0, 0, 0,0,0, 0, 0, 0, 0, 0, 0, 0, 0,0
// ,0, 0, 0, 0, 0, 0, 0, 0, 0,0,0, 0, 0, 0, 0, 0, 0, 0, 0,0,0, 0, 0, 0, 0, 0, 0, 0, 0,0,0, 0, 0, 0, 0, 0, 0, 0, 0,0},
// };
//uint16_t single_bi_m48_cycle_send_buff[m48_LED_NO] =
//{0, 0, 0, 0, 0, 0, 0, 0, 0,0,0, 0, 0, 0, 0, 0, 0, 0, 0,0,0, 0, 0, 0, 0, 0, 0, 0, 0,0,0, 0, 0, 0, 0, 0, 0, 0, 0,0,0, 0, 0, 0, 0, 0, 0, 0};
uint16_t single_bi_m48_cycle_send_buff[m48_LED_NO] =
{0, 0, 0, 0, 0, 0, 0, 0, 0,0,0, 0, 0, 0, 0, 0, 0, 0, 0,0,0, 0, 0, 0}; //24 ==old is 48
#define SAMPLES_IN_BUFFER 4095+32
static nrf_saadc_value_t pd_m48_adc_buf[2][SAMPLES_IN_BUFFER];
//uint16_t single_info_m48_cycle_send_buff[56] ={0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0,
// 0, 0, 0, 0,0 };
uint16_t single_info_m48_cycle_send_buff[24] ={0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0}; //edit cj 56-->24
//bool pd_adc_custom_a_start = false;
//bool pd_adc_custom_b_start = false;
//bool pd_adc_custom_c_start = false;
//bool pd_adc_custom_d_start = false;
//bool pd_adc_custom_end = false;
//bool pd_adc_custom_start = false;
bool pd_adc_m48_start = false;
bool pd_adc_m48_running = false;
bool m48_testing = false;
//
//bool custom_add_data;
extern bool ble_got_new_data;
extern bool motion_raw_data_enabled;
//extern char ble_tx_buffer[BLE_NUS_MAX_DATA_LEN];
uint8_t m48_bin_buffer[BLE_NUS_MAX_DATA_LEN];
//add imu
extern which_cmd_t cmd_type_t;
APP_TIMER_DEF(m_m48_check_loop_timer_id);
//APP_TIMER_DEF(m_m48_send_loop_timer_id);
#if FEATURE_DELAY
#define m48_SEND_LOOP_INTERVAL 500
#else
#define m48_SEND_LOOP_INTERVAL 100 //100 cj chun
#endif
#define m48_CHECK_LOOP_INTERVAL 1 //1
static nrf_ppi_channel_t m_ppi_channel;
#if !FEATURE_PRINTF
void m48_ppi_init(void)
{
ret_code_t err_code;
err_code = nrf_drv_ppi_init();
APP_ERROR_CHECK(err_code);
uint32_t gpiote_event_addr = nrf_drv_gpiote_in_event_addr_get(ADA2200_SYNCO_PIN);
uint32_t saadc_sample_task_addr = nrf_drv_saadc_sample_task_get();
/* setup ppi channel so that timer compare event is triggering sample task in SAADC */
err_code = nrf_drv_ppi_channel_alloc(&m_ppi_channel);
APP_ERROR_CHECK(err_code);
err_code = nrf_drv_ppi_channel_assign(m_ppi_channel,
gpiote_event_addr,
saadc_sample_task_addr);
APP_ERROR_CHECK(err_code);
}
void m48_ppi_uninit(void)
{
ret_code_t err_code;
err_code = nrf_drv_ppi_uninit();
APP_ERROR_CHECK(err_code);
}
void m48_sampling_event_enable(void)
{
ret_code_t err_code = nrf_drv_ppi_channel_enable(m_ppi_channel);
APP_ERROR_CHECK(err_code);
}
void m48_sampling_event_disable(void)
{
ret_code_t err_code = nrf_drv_ppi_channel_disable(m_ppi_channel);
APP_ERROR_CHECK(err_code);
}
#endif
/**@brief Function for handling the ADC interrupt.
*
* @details This function will fetch the conversion result from the ADC, convert the value into
* percentage and send it to peer.
*/
static void m48_voltage_handler(nrf_drv_saadc_evt_t const * p_event) /* PD Voltage reading */
{
ret_code_t err_code;
int16_t sum = 0;
uint32_t m48_clk_delay = m_pd_delay_us/16;
if(ble_connection_st == 0) {
//imm_adc_end();
//custom_send_timer_stop();
DBG_PRINTF("m48 ADC STOP 1\r\n");
led_off(99);
pd_off(99);
pd_adc_m48_start=false;
pd_adc_m48_running=false;
m48_testing = false;
info4 = false;
DBG_PRINTF ("LOST_AT48\r\n");
processing = false;
go_batt = false;
go_temp = false;
m48_adc_end_final();
}
else{
if (p_event->type == NRF_DRV_SAADC_EVT_DONE)
{
err_code = nrf_drv_saadc_buffer_convert(p_event->data.done.p_buffer, m48_samples_in_buffer + m48_clk_delay);
APP_ERROR_CHECK(err_code);
if(led_no == -1) {
led_no = 0;
pd_no = 0;
led_on(CURRENT_list_m48[led_no]);
led_pd_matching_value_set(CURRENT_list_m48[led_no]); /* MCP4725 DAC setting and PD on */
} else {
for(uint16_t i = m48_clk_delay; i < m48_clk_delay + m48_samples_in_buffer; i++){
buff_m48_cycle[buf_no][i-m48_clk_delay] = p_event->data.done.p_buffer[i];
}
#if FEATURE_PRINTF
DBG_PRINTF("-----------------Read ADC // led_no = %d(%d), pd_no = %d(%d), buf_no = %d\r\n\r\n", led_no, LED_list_m48[led_no], pd_no, PD_list_m48[pd_no], buf_no);
#endif
buf_no++;
if(pd_no >= - 1) {
//pd_no = 0;
if(led_no < CURRENT_LED_NO - 1) {
led_no++;
led_on(CURRENT_list_m48[led_no]);
led_pd_matching_value_set(CURRENT_list_m48[led_no]); /* MCP4725 DAC setting and PD on */
} else if(led_no >= CURRENT_LED_NO - 1) {
pd_no = -1;
led_no = -1;
#if FEATURE_PRINTF
DBG_PRINTF("\r\nEnded\r\n");
#endif
//imm_adc_end();
//imm_adc_end_final();
///////////////////////////////////////////////////////////////////////////////////////////
uint8_t k =0;
sum = 0;
for(uint16_t i = 0; i < CURRENT_LED_NO; i++){
for(uint16_t j = 0; j < m48_samples_in_buffer; j++){
sum += buff_m48_cycle[i][j];
}
m48_cycle_send_buff[k++] = sum;
sum = 0;
}
buf_no = 0;
if(ble_connection_st == 0) {
DBG_PRINTF("m24 ADC STOP 1");
// pd_adc_m48_start=false;
// pd_adc_m48_running=false;
// DBG_PRINTF ("FINISH SEND\r\n");
//
// m48_testing = false;
// m48_adc_end_final();
}
else {
pd_adc_m48_start=false;
DBG_PRINTF ("FINISH SEND\r\n");
m48_testing = false;
//m48_adc_end_final();
if(cmd_type_t == CMD_UART) {
//custom_send_timer_stop();
}else if(cmd_type_t == CMD_BLE) {
// DBG_PRINTF("%d ms \r\n",t_ms);
//DBG_PRINTF("value 4: %d,%d,%d,%d \r\n",imm_cycle_send_buff[0] ,imm_cycle_send_buff[1] ,imm_cycle_send_buff[2] ,imm_cycle_send_buff[3] );
for(uint16_t i = 0; i < CURRENT_LED_NO; i++){
DBG_PRINTF("%d,",m48_cycle_send_buff[i]);
//bi_m48_cycle_send_buff[m48_cnt][i]=(uint16_t)(m48_cycle_send_buff[i]);
single_bi_m48_cycle_send_buff[i]=(uint16_t)(m48_cycle_send_buff[i]);
}
if (info4 == true){
single_info_m48_cycle_send_buff[0] = info_batt;
single_info_m48_cycle_send_buff[1] = info_temp;
for(uint16_t i = 0; i < 6; i++)
single_info_m48_cycle_send_buff[i+2]= info_imu[i];
single_info_m48_cycle_send_buff[8] = info_p1; //add cj 25/11/24
single_info_m48_cycle_send_buff[9] = info_p2; //add cj 25/11/24
for(uint16_t i = 0; i < CURRENT_LED_NO; i++){
single_info_m48_cycle_send_buff[i+10]= single_bi_m48_cycle_send_buff[i];
}
if(ADC_PD_MODE==0){
format_data(m48_bin_buffer, "rsj:", single_info_m48_cycle_send_buff, 56); //MEASURE ADC 24 48+6+2
binary_tx_handler(m48_bin_buffer,58);
}
else if(ADC_PD_MODE==2){
format_data(m48_bin_buffer, "rcj:", single_info_m48_cycle_send_buff, 34); //24(pd)+6(imu)+2(pressure p1p2)
binary_tx_handler(m48_bin_buffer,36);
}
else if(ADC_PD_MODE==3){
format_data(m48_bin_buffer, "rdj:", single_info_m48_cycle_send_buff, 34); //24(pd)+6(imu)+2(pressure p1p2)
binary_tx_handler(m48_bin_buffer,36);
}
else if(ADC_PD_MODE==4){
format_data(m48_bin_buffer, "rej:", single_info_m48_cycle_send_buff, 34); //24(pd)+6(imu)+2(pressure p1p2)
binary_tx_handler(m48_bin_buffer,36);
}
else if(ADC_PD_MODE==5){
format_data(m48_bin_buffer, "rfj:", single_info_m48_cycle_send_buff, 34); //24(pd)+6(imu)+2(pressure p1p2)
binary_tx_handler(m48_bin_buffer,36);
}
else {
// format_data(m48_bin_buffer, "rsj:", single_info_m48_cycle_send_buff, 56);
// binary_tx_handler(m48_bin_buffer,56);
}
}
else{
char resp[4];
if(ADC_PD_MODE==2){
format_data(m48_bin_buffer, "rdj:", single_bi_m48_cycle_send_buff, 24);
binary_tx_handler(m48_bin_buffer,26);
}
else if(ADC_PD_MODE==4){
format_data(m48_bin_buffer, "rfj:", single_bi_m48_cycle_send_buff, 24);
binary_tx_handler(m48_bin_buffer,26);
}
else if(ADC_PD_MODE==3){
sprintf(resp,"rd%01X:", order_pd);
format_data(m48_bin_buffer, resp, single_bi_m48_cycle_send_buff, 24);
binary_tx_handler(m48_bin_buffer,26);
}
else if(ADC_PD_MODE==4){
format_data(m48_bin_buffer, "rej:", single_bi_m48_cycle_send_buff, 24);
binary_tx_handler(m48_bin_buffer,26);
}
else if(ADC_PD_MODE==5){
sprintf(resp,"rf%01X:", order_pd);
format_data(m48_bin_buffer, resp, single_bi_m48_cycle_send_buff, 24);
binary_tx_handler(m48_bin_buffer,26);
}
else {
// format_data(m48_bin_buffer, "rtj:", single_bi_m48_cycle_send_buff, 48);
// binary_tx_handler(m48_bin_buffer,50);
}
}
DBG_PRINTF("\r\n %d ms \r\n",t_ms);
// format_data(buff_bin_buffer, "rjb:", bi_buff_cycle_send_buff, 200);
// //
// binary_tx_handler(buff_bin_buffer,102);
}
// if(ble_connection_st == 1) {
// battery_timer_start();
// }
if (pd_adc_m48_running==true){
//m48_adc_end_final();
if(info4 == true){
m48_adc_end_final();
pd_adc_m48_start=true;
go_batt = true; // BATT.TEMP IMU
//motion_raw_data_enabled = true;//only IMU
main_timer_start();
}
else{t_ms=0;
m48_cnt=0;
m48_testing = true;
//
//processing = false;
m48_adc_start();
}
}
else
{
if(info4 == true){ //for single shot
info4 = false;
}
led_off(99);
pd_off(99);
processing = false;
m48_adc_end_final();
}
}
}
}
}
}
}
}
void m48_check_loop(void * p_context)
{
UNUSED_PARAMETER(p_context);
m48_check_timer_stop();
if ( m48_testing == false)
{
DBG_PRINTF("%d ms \r\n",t_ms);
// sprintf(custom_tx_buffer, "Measure Time :%d ms \r\n",t_ms);
}
else
{
t_ms++;
m48_check_timer_start();
}
}
//void m48_send_loop(void * p_context) /* For x ms */
//{
// UNUSED_PARAMETER(p_context);
// m48_send_timer_stop();
//
//
// order++;
// if(ble_connection_st == BLE_DISCONNECTED_ST) {
// // order=0;
// // full_send_timer_stop();
// // DBG_PRINTF("Full ADC STOP 2\r\n");
//
// }
// else{
//
// }
//}
void m48_adc_start_init(void)
{
if (ble_got_new_data ==true)
{
if (pd_adc_m48_running==true){
led_off(99);
pd_off(99);
pd_adc_m48_start=false;
pd_adc_m48_running=false;
DBG_PRINTF ("FINISH NEWDATA\r\n");
processing = false;
go_batt = false;
go_temp = false;
//pd_adc_m48_running=false;
//motion_data_once = true;
motion_raw_data_enabled = false;
m48_testing = false;
if(info4 == true){ //for complex continous
info4 = false;
}
else {
m48_adc_end_final(); //normal contuion
}
}
}
// else if (pd_adc_m48_running==true){
//
// info4 = true;
// t_ms=0;
// m48_cnt=0;
// m48_testing = true;
// //
// //processing = false;
// m48_adc_start();
// //m48_adc_end_final();
//
//
// }
else if (pd_adc_m48_start==true)
{
switch (ADC_PD_MODE)
{
case 0:
pd_adc_m48_running=false;
CURRENT_LED_NO = m48_LED_NO;
for(uint16_t i = 0; i < CURRENT_LED_NO; i++) {
CURRENT_list_m48[i] = LED_list_m48[i];
}
break;
case 1:
pd_adc_m48_running=true;
CURRENT_LED_NO = m48_LED_NO;
for(uint16_t i = 0; i < CURRENT_LED_NO; i++) {
CURRENT_list_m48[i] = LED_list_m48[i];
}
break;
case 2:
pd_adc_m48_running=false;
CURRENT_LED_NO = m48_LED_NO_H;
for(uint16_t i = 0; i < CURRENT_LED_NO; i++) {
CURRENT_list_m48[i] = LED_list_m48_1h[i];
}
break;
case 3:
pd_adc_m48_running=true;
CURRENT_LED_NO = m48_LED_NO_H;
for(uint16_t i = 0; i < CURRENT_LED_NO; i++) {
CURRENT_list_m48[i] = LED_list_m48_1h[i];
}
break;
case 4:
pd_adc_m48_running=false;
CURRENT_LED_NO = m48_LED_NO_H;
for(uint16_t i = 0; i < CURRENT_LED_NO; i++) {
CURRENT_list_m48[i] = LED_list_m48_2h[i];
DBG_PRINTF("%d,",CURRENT_list_m48[i]);
}
break;
case 5:
pd_adc_m48_running=true;
CURRENT_LED_NO = m48_LED_NO_H;
for(uint16_t i = 0; i < CURRENT_LED_NO; i++) {
CURRENT_list_m48[i] = LED_list_m48_2h[i];
}
break;
default:
pd_adc_m48_running=false;
CURRENT_LED_NO = m48_LED_NO;
for(uint16_t i = 0; i < CURRENT_LED_NO; i++) {
CURRENT_list_m48[i] = LED_list_m48[i];
break;
}
}
t_ms=0;
m48_cnt=0;
pd_adc_m48_start=false;
m48_testing = true;
// custom_check_timer_start();
// c_cnt=0;
// pd_adc_custom_start=false;
// pd_adc_custom_a_start=true;
// static const uint8_t LED_list_m48[m48_LED_NO]={0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23, 24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47};
//static const uint8_t LED_list_m48_1h[m48_LED_NO_H] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23};
//static const uint8_t LED_list_m48_2h[m48_LED_NO_H] = {24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47};
// uint8_t ADC_PD_MODE = 0; //0: Full 1: Full Continuous 2: HALF 1 3: HALF 1 Continuous 4: Half2 5: Half 2 Countiuous.
m48_adc_start2();
m48_check_timer_start();
// c_cnt++;
}
else
{
}
}
void m48_adc_start(void)
{
pd_no = -1;
led_no = -1;
buf_no = 0;
for(uint16_t i = 0; i < m48_LED_NO; i++) { //ok
for(uint16_t j = 0; j < m48_CYCLE_CNT; j++) {
buff_m48_cycle[i][j] = 0;
if (ble_got_new_data ==true){
if (pd_adc_m48_running==true){
// led_off(99);
// pd_off(99);
pd_adc_m48_start=false;
pd_adc_m48_running=false;
}
}
}
}
if(order_pd>=15){
order_pd=0;
}
else
{ order_pd++;
}
}
void m48_adc_start2(void)
{
m48_adc_start();
m48_adc_init();
m48_irq_init();
m48_ppi_init();
m48_sampling_event_enable();
}
void m48_adc_end(void)
{
DBG_PRINTF("m48_adc_end\r\n");
m48_sampling_event_disable();
}
void m48_adc_end_final(void)
{
DBG_PRINTF("adc_end_final\r\n");
m48_sampling_event_disable();
m48_irq_uninit();
m48_ppi_uninit();
m48_adc_uninit();
battery_timer_start();
}
void m48_adc_init(void)
{
#if FEATURE_PRINTF
DBG_PRINTF("m48_adc_init\r\n");
#endif
static nrfx_saadc_config_t default_config;
default_config.resolution = (nrf_saadc_resolution_t)NRFX_SAADC_CONFIG_RESOLUTION; /* Resolution is 10bits */
default_config.oversample = (nrf_saadc_oversample_t)NRFX_SAADC_CONFIG_OVERSAMPLE; /* Over Sampling Disabled */
default_config.interrupt_priority = NRFX_SAADC_CONFIG_IRQ_PRIORITY; /* Interrupt Priority is 0(Highest) */
default_config.low_power_mode = NRFX_SAADC_CONFIG_LP_MODE; /* Low Power Mode is Disabled */
static nrf_saadc_channel_config_t config;
config.resistor_p = NRF_SAADC_RESISTOR_DISABLED;
config.resistor_n = NRF_SAADC_RESISTOR_DISABLED;
config.gain = NRF_SAADC_GAIN1_6;
config.reference = NRF_SAADC_REFERENCE_INTERNAL;
config.acq_time = NRF_SAADC_ACQTIME_3US;
config.mode = NRF_SAADC_MODE_DIFFERENTIAL;
config.burst = NRF_SAADC_BURST_DISABLED;
config.pin_p = (nrf_saadc_input_t)(NRF_SAADC_INPUT_AIN0);
config.pin_n = (nrf_saadc_input_t)(NRF_SAADC_INPUT_AIN1);
ret_code_t err_code = nrf_drv_saadc_init(&default_config, m48_voltage_handler);
APP_ERROR_CHECK(err_code);
err_code = nrf_drv_saadc_channel_init(0, &config);
APP_ERROR_CHECK(err_code);
err_code = nrf_drv_saadc_buffer_convert(pd_m48_adc_buf[0], m48_samples_in_buffer + m_pd_delay_us/16);
APP_ERROR_CHECK(err_code);
}
void m48_adc_uninit(void)
{
#if FEATURE_PRINTF
DBG_PRINTF("pd_m48_adc_uninit\r\n");
#endif
nrf_drv_saadc_uninit();
nrf_drv_saadc_channel_uninit(0);
}
#if !FEATURE_PRINTF
void m48_irq_init(void)
{
ret_code_t err_code;
/* Initialize int pin */
if (!nrfx_gpiote_is_init())
{
err_code = nrfx_gpiote_init();
APP_ERROR_CHECK(err_code);
}
nrfx_gpiote_in_config_t in_config = NRFX_GPIOTE_CONFIG_IN_SENSE_LOTOHI(true);
in_config.pull = NRF_GPIO_PIN_PULLDOWN;
err_code = nrfx_gpiote_in_init(ADA2200_SYNCO_PIN, &in_config, NULL);
APP_ERROR_CHECK(err_code);
nrfx_gpiote_in_event_enable(ADA2200_SYNCO_PIN, true);
}
void m48_irq_uninit(void)
{
nrfx_gpiote_in_event_disable(ADA2200_SYNCO_PIN);
nrfx_gpiote_in_uninit(ADA2200_SYNCO_PIN);
}
#endif
// void m48_send_timer_start(void)
// {
// APP_ERROR_CHECK(app_timer_start(m_m48_send_loop_timer_id, APP_TIMER_TICKS(m48_SEND_LOOP_INTERVAL), NULL));
// }
// void m48_send_timer_stop(void)
// {
// APP_ERROR_CHECK(app_timer_stop(m_m48_send_loop_timer_id));
// }
// void m48_send_timer_init(void)
// {
// APP_ERROR_CHECK(app_timer_create(&m_m48_send_loop_timer_id, APP_TIMER_MODE_SINGLE_SHOT, m48_send_loop));
// }
void m48_check_timer_start(void)
{
APP_ERROR_CHECK(app_timer_start(m_m48_check_loop_timer_id, APP_TIMER_TICKS(m48_CHECK_LOOP_INTERVAL), NULL));
}
void m48_check_timer_stop(void)
{
APP_ERROR_CHECK(app_timer_stop(m_m48_check_loop_timer_id));
}
void m48_check_timer_init(void)
{
APP_ERROR_CHECK(app_timer_create(&m_m48_check_loop_timer_id, APP_TIMER_MODE_SINGLE_SHOT, m48_check_loop));
}

59
project/ble_peripheral/ble_app_bladder_patch/meas_pd_48.h
View File

@@ -1,59 +0,0 @@
/*******************************************************************************
* @file meas_pd_48.h
******************************************************************************/
#ifndef _MEAS_PD_48_H__
#define _MEAS_PD_48_H__
#include "sdk_common.h"
#include "nrf_drv_saadc.h"
#define ADA2200_SYNCO_PIN NRF_GPIO_PIN_MAP(0,17)
#define m48_PD_NO 1 /////4
#define m48_LED_NO 24 ////5 ///48 cj edit 25/10/14
#define m48_LED_NO_H 24 ////5
#define m48_CYCLE_CNT 32 ////32
void m48_ppi_init(void);
void m48_ppi_uninit(void);
void m48_sampling_event_enable(void);
void m48_sampling_event_disable(void);
/**@brief Function for handling the ADC interrupt.
*
* @details This function will fetch the conversion result from the ADC, convert the value into
* percentage and send it to peer.
*/
static void m48_voltage_handler(nrf_drv_saadc_evt_t const * p_event); /* PD Voltage reading */
void m48_adc_start_init(void);
void m48_adc_start(void);
void m48_adc_start2(void);
//void custom_adc_start2(void);
//void custom_adc_total_start(void);
void m48_adc_end(void);
void m48_adc_end_final(void);
void m48_adc_init(void);
void m48_adc_uninit(void);
void m48_irq_init(void);
void m48_irq_uninit(void);
// void bm48_send_start(void);
// void m48_send_loop(void * p_context); /* For x ms */
// void m48f_send_timer_start(void);
// void m48_send_timer_stop(void);;
// void m48_send_timer_init(void);
void m48_check_loop(void * p_context);
void m48_check_timer_start(void);
void m48_check_timer_stop(void);;
void m48_check_timer_init(void);
#endif /* _MEAS_PD_48_H__ */

785
project/ble_peripheral/ble_app_bladder_patch/meas_pd_buff.c
View File

@@ -1,785 +0,0 @@
/*******************************************************************************
TEST medi50 Dec 23
******************************************************************************/
#include "sdk_common.h"
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include "nrf.h"
#include "boards.h"
#include "app_error.h"
#include "nrf_drv_saadc.h"
#include "nrfx_gpiote.h"
#include "app_timer.h"
#include "nrf_drv_timer.h"
#include "nrf_delay.h"
#include "nrf_drv_ppi.h"
#include "ada2200_spi.h"
#include "ble_nus.h"
//#include "fstorage.h"
#include "measurements.h"
#include "meas_pd_buff.h"
#include "mcp4725_i2c.h"
#include "ad5272_i2c.h"
#include "main_timer.h"
#include "battery_saadc.h"
#include "main.h"
#include "app_raw_main.h"
//#define CUSTOM_REF_VOLTAGE_IN_MILLIVOLTS 600.0f /**< Reference voltage (in milli volts) used by ADC while doing conversion. */
//#define CUSTOM_PRE_SCALING_COMPENSATION 6.0f /**< The ADC is configured to use VDD with 1/3 prescaling as input. And hence the result of conversion is to be multiplied by 3 to get the actual value of the battery voltage.*/
//#define CUSTOM_ADC_RES_10BITS 1024.0f /**< Maximum digital value for 10-bit ADC conversion. */
//#define st_c_max 20
///**@brief Macro to convert the result of ADC conversion in millivolts.
// *
// * @param[in] ADC_VALUE ADC result.
// *
// * @retval Result converted to millivolts.
// */
//#define CUSTOM_VOUT_IN_MILLI_VOLTS(ADC_VALUE)\
// (((((ADC_VALUE) * CUSTOM_REF_VOLTAGE_IN_MILLIVOLTS) / CUSTOM_ADC_RES_10BITS) * CUSTOM_PRE_SCALING_COMPENSATION)*2)
uint16_t b_t_cnt=5;
uint8_t buff_samples_in_buffer = 8;
//uint32_t s_cnt;
uint8_t LED_list_buff[buff_LED_NO]={0, 0, 0, 0, 0, 0, 0, 0, 0,0,0, 0, 0, 0, 0, 0, 0, 0, 0,0,0, 0, 0, 0, 0, 0, 0, 0, 0,0,0, 0, 0, 0, 0, 0, 0, 0, 0,0,0, 0, 0, 0, 0, 0, 0, 0, 0,0,0, 0, 0, 0, 0, 0, 0, 0, 0,0
,0, 0, 0, 0, 0, 0, 0, 0, 0,0,0, 0, 0, 0, 0, 0, 0, 0, 0,0,0, 0, 0, 0, 0, 0, 0, 0, 0,0,0, 0, 0, 0, 0, 0, 0, 0, 0,0};
//uint8_t PD_list_custom[4];
//uint8_t led_custom_list_a[5] = {2,3,4,5,6};
//uint8_t pd_custom_list_a[4] = {5,7,8,10};
//uint8_t led_custom_list_b[5] = {20,21,22,23,24};
//uint8_t pd_custom_list_b[4] = {16,14,13,11};
//int32_t c_max;
extern volatile bool processing;
extern volatile bool data_tx_in_progress;
extern volatile bool ble_connection_st;
uint32_t buff_cnt;
static int8_t pd_no = -1;
static int8_t led_no = -1;
static int8_t buf_no = 0;
static int8_t order = 0;
uint16_t bsel_led_index0 =0;
uint16_t bsel_led_index1 =1;
uint16_t bsel_led_index2 =2;
uint16_t bsel_led_index3 =3;
static int32_t t_ms = 0;
int16_t buff_cycle_buff[buff_LED_NO][buff_CYCLE_CNT] =
{
{0, 0, 0, 0, 0, 0, 0, 0}, //0
{0, 0, 0, 0, 0, 0, 0, 0}, //1
{0, 0, 0, 0, 0, 0, 0, 0}, //2
{0, 0, 0, 0, 0, 0, 0, 0}, //3
{0, 0, 0, 0, 0, 0, 0, 0}, //4
{0, 0, 0, 0, 0, 0, 0, 0}, //5
{0, 0, 0, 0, 0, 0, 0, 0}, //6
{0, 0, 0, 0, 0, 0, 0, 0}, //7
{0, 0, 0, 0, 0, 0, 0, 0}, //8
{0, 0, 0, 0, 0, 0, 0, 0}, //9
{0, 0, 0, 0, 0, 0, 0, 0}, //10
{0, 0, 0, 0, 0, 0, 0, 0}, //1
{0, 0, 0, 0, 0, 0, 0, 0}, //2
{0, 0, 0, 0, 0, 0, 0, 0}, //3
{0, 0, 0, 0, 0, 0, 0, 0}, //4
{0, 0, 0, 0, 0, 0, 0, 0}, //5
{0, 0, 0, 0, 0, 0, 0, 0}, //6
{0, 0, 0, 0, 0, 0, 0, 0}, //7
{0, 0, 0, 0, 0, 0, 0, 0}, //8
{0, 0, 0, 0, 0, 0, 0, 0}, //9
{0, 0, 0, 0, 0, 0, 0, 0}, //20
{0, 0, 0, 0, 0, 0, 0, 0}, //1
{0, 0, 0, 0, 0, 0, 0, 0}, //2
{0, 0, 0, 0, 0, 0, 0, 0}, //3
{0, 0, 0, 0, 0, 0, 0, 0}, //4
{0, 0, 0, 0, 0, 0, 0, 0}, //5
{0, 0, 0, 0, 0, 0, 0, 0}, //6
{0, 0, 0, 0, 0, 0, 0, 0}, //7
{0, 0, 0, 0, 0, 0, 0, 0}, //8
{0, 0, 0, 0, 0, 0, 0, 0}, //9
{0, 0, 0, 0, 0, 0, 0, 0}, //30
{0, 0, 0, 0, 0, 0, 0, 0}, //1
{0, 0, 0, 0, 0, 0, 0, 0}, //2
{0, 0, 0, 0, 0, 0, 0, 0}, //3
{0, 0, 0, 0, 0, 0, 0, 0}, //4
{0, 0, 0, 0, 0, 0, 0, 0}, //5
{0, 0, 0, 0, 0, 0, 0, 0}, //6
{0, 0, 0, 0, 0, 0, 0, 0}, //7
{0, 0, 0, 0, 0, 0, 0, 0}, //8
{0, 0, 0, 0, 0, 0, 0, 0}, //9
{0, 0, 0, 0, 0, 0, 0, 0}, //40
{0, 0, 0, 0, 0, 0, 0, 0}, //1
{0, 0, 0, 0, 0, 0, 0, 0}, //2
{0, 0, 0, 0, 0, 0, 0, 0}, //3
{0, 0, 0, 0, 0, 0, 0, 0}, //4
{0, 0, 0, 0, 0, 0, 0, 0}, //5
{0, 0, 0, 0, 0, 0, 0, 0}, //6
{0, 0, 0, 0, 0, 0, 0, 0}, //7
{0, 0, 0, 0, 0, 0, 0, 0}, //8
{0, 0, 0, 0, 0, 0, 0, 0}, //9
{0, 0, 0, 0, 0, 0, 0, 0}, //50
{0, 0, 0, 0, 0, 0, 0, 0}, //1
{0, 0, 0, 0, 0, 0, 0, 0}, //2
{0, 0, 0, 0, 0, 0, 0, 0}, //3
{0, 0, 0, 0, 0, 0, 0, 0}, //4
{0, 0, 0, 0, 0, 0, 0, 0}, //5
{0, 0, 0, 0, 0, 0, 0, 0}, //6
{0, 0, 0, 0, 0, 0, 0, 0}, //7
{0, 0, 0, 0, 0, 0, 0, 0}, //8
{0, 0, 0, 0, 0, 0, 0, 0}, //9
{0, 0, 0, 0, 0, 0, 0, 0}, //60
{0, 0, 0, 0, 0, 0, 0, 0}, //1
{0, 0, 0, 0, 0, 0, 0, 0}, //2
{0, 0, 0, 0, 0, 0, 0, 0}, //3
{0, 0, 0, 0, 0, 0, 0, 0}, //4
{0, 0, 0, 0, 0, 0, 0, 0}, //5
{0, 0, 0, 0, 0, 0, 0, 0}, //6
{0, 0, 0, 0, 0, 0, 0, 0}, //7
{0, 0, 0, 0, 0, 0, 0, 0}, //8
{0, 0, 0, 0, 0, 0, 0, 0}, //9
{0, 0, 0, 0, 0, 0, 0, 0}, //70
{0, 0, 0, 0, 0, 0, 0, 0}, //1
{0, 0, 0, 0, 0, 0, 0, 0}, //2
{0, 0, 0, 0, 0, 0, 0, 0}, //3
{0, 0, 0, 0, 0, 0, 0, 0}, //4
{0, 0, 0, 0, 0, 0, 0, 0}, //5
{0, 0, 0, 0, 0, 0, 0, 0}, //6
{0, 0, 0, 0, 0, 0, 0, 0}, //7
{0, 0, 0, 0, 0, 0, 0, 0}, //8
{0, 0, 0, 0, 0, 0, 0, 0}, //9
{0, 0, 0, 0, 0, 0, 0, 0}, //80
{0, 0, 0, 0, 0, 0, 0, 0}, //1
{0, 0, 0, 0, 0, 0, 0, 0}, //2
{0, 0, 0, 0, 0, 0, 0, 0}, //3
{0, 0, 0, 0, 0, 0, 0, 0}, //4
{0, 0, 0, 0, 0, 0, 0, 0}, //5
{0, 0, 0, 0, 0, 0, 0, 0}, //6
{0, 0, 0, 0, 0, 0, 0, 0}, //7
{0, 0, 0, 0, 0, 0, 0, 0}, //8
{0, 0, 0, 0, 0, 0, 0, 0}, //9
{0, 0, 0, 0, 0, 0, 0, 0}, //90
{0, 0, 0, 0, 0, 0, 0, 0}, //1
{0, 0, 0, 0, 0, 0, 0, 0}, //2
{0, 0, 0, 0, 0, 0, 0, 0}, //3
{0, 0, 0, 0, 0, 0, 0, 0}, //4
{0, 0, 0, 0, 0, 0, 0, 0}, //5
{0, 0, 0, 0, 0, 0, 0, 0}, //6
{0, 0, 0, 0, 0, 0, 0, 0}, //7
{0, 0, 0, 0, 0, 0, 0, 0}, //8
{0, 0, 0, 0, 0, 0, 0, 0}, //9
};
int16_t buff_cycle_send_buff[buff_LED_NO] = {0, 0, 0, 0, 0, 0, 0, 0, 0,0,0, 0, 0, 0, 0, 0, 0, 0, 0,0,0, 0, 0, 0, 0, 0, 0, 0, 0,0,0, 0, 0, 0, 0, 0, 0, 0, 0,0,0, 0, 0, 0, 0, 0, 0, 0, 0,0,0, 0, 0, 0, 0, 0, 0, 0, 0,0
,0, 0, 0, 0, 0, 0, 0, 0, 0,0,0, 0, 0, 0, 0, 0, 0, 0, 0,0,0, 0, 0, 0, 0, 0, 0, 0, 0,0,0, 0, 0, 0, 0, 0, 0, 0, 0,0};
//int16_t buff_cycle_send_buff1[buff_LED_NO] = {0, };
//int16_t buff_cycle_send_buff2[buff_LED_NO] = {0, };
//int16_t buff_cycle_send_buff3[buff_LED_NO] = {0, };
//int16_t buff_cycle_send_buff4[buff_LED_NO] = {0, };
//int16_t buff_cycle_send_buff5[buff_LED_NO] = {0, };
//int16_t buff_cycle_send_buff6[buff_LED_NO] = {0, };
//int16_t buff_cycle_send_buff7[buff_LED_NO] = {0, };
//int16_t buff_cycle_send_buff8[buff_LED_NO] = {0, };
//int16_t buff_cycle_send_buff9[buff_LED_NO] = {0, };
uint16_t bi_buff_cycle_send_buff[60][buff_LED_NO] = {
{0, 0, 0, 0, 0, 0, 0, 0, 0,0,0, 0, 0, 0, 0, 0, 0, 0, 0,0,0, 0, 0, 0, 0, 0, 0, 0, 0,0,0, 0, 0, 0, 0, 0, 0, 0, 0,0,0, 0, 0, 0, 0, 0, 0, 0, 0,0,0, 0, 0, 0, 0, 0, 0, 0, 0,0
,0, 0, 0, 0, 0, 0, 0, 0, 0,0,0, 0, 0, 0, 0, 0, 0, 0, 0,0,0, 0, 0, 0, 0, 0, 0, 0, 0,0,0, 0, 0, 0, 0, 0, 0, 0, 0,0},
};
uint16_t single_bi_buff_cycle_send_buff[buff_LED_NO] =
{0, 0, 0, 0, 0, 0, 0, 0, 0,0,0, 0, 0, 0, 0, 0, 0, 0, 0,0,0, 0, 0, 0, 0, 0, 0, 0, 0,0,0, 0, 0, 0, 0, 0, 0, 0, 0,0,0, 0, 0, 0, 0, 0, 0, 0, 0,0,0, 0, 0, 0, 0, 0, 0, 0, 0,0
,0, 0, 0, 0, 0, 0, 0, 0, 0,0,0, 0, 0, 0, 0, 0, 0, 0, 0,0,0, 0, 0, 0, 0, 0, 0, 0, 0,0,0, 0, 0, 0, 0, 0, 0, 0, 0,0};
#define SAMPLES_IN_BUFFER 4095+32
static nrf_saadc_value_t pd_buff_adc_buf[2][SAMPLES_IN_BUFFER];
//bool pd_adc_custom_a_start = false;
//bool pd_adc_custom_b_start = false;
//bool pd_adc_custom_c_start = false;
//bool pd_adc_custom_d_start = false;
//bool pd_adc_custom_end = false;
//bool pd_adc_custom_start = false;
bool pd_adc_buff_start = false;
bool pd_adc_buff_running = false;
bool buff_testing = false;
extern uint16_t m_pd_delay_us;
//
//bool custom_add_data;
extern bool ble_got_new_data;
extern bool motion_raw_data_enabled;
//extern char ble_tx_buffer[BLE_NUS_MAX_DATA_LEN];
uint8_t buff_bin_buffer[BLE_NUS_MAX_DATA_LEN];
//add imu
extern which_cmd_t cmd_type_t;
APP_TIMER_DEF(m_buff_check_loop_timer_id);
APP_TIMER_DEF(m_buff_send_loop_timer_id);
#if FEATURE_DELAY
#define CUSTOM_SEND_LOOP_INTERVAL 500
#else
#define BUFF_SEND_LOOP_INTERVAL 100
#endif
#define BUFF_CHECK_LOOP_INTERVAL 1
static nrf_ppi_channel_t m_ppi_channel;
#if !FEATURE_PRINTF
void buff_ppi_init(void)
{
ret_code_t err_code;
err_code = nrf_drv_ppi_init();
APP_ERROR_CHECK(err_code);
uint32_t gpiote_event_addr = nrf_drv_gpiote_in_event_addr_get(ADA2200_SYNCO_PIN);
uint32_t saadc_sample_task_addr = nrf_drv_saadc_sample_task_get();
/* setup ppi channel so that timer compare event is triggering sample task in SAADC */
err_code = nrf_drv_ppi_channel_alloc(&m_ppi_channel);
APP_ERROR_CHECK(err_code);
err_code = nrf_drv_ppi_channel_assign(m_ppi_channel,
gpiote_event_addr,
saadc_sample_task_addr);
APP_ERROR_CHECK(err_code);
}
void buff_ppi_uninit(void)
{
ret_code_t err_code;
err_code = nrf_drv_ppi_uninit();
APP_ERROR_CHECK(err_code);
}
void buff_sampling_event_enable(void)
{
ret_code_t err_code = nrf_drv_ppi_channel_enable(m_ppi_channel);
APP_ERROR_CHECK(err_code);
}
void buff_sampling_event_disable(void)
{
ret_code_t err_code = nrf_drv_ppi_channel_disable(m_ppi_channel);
APP_ERROR_CHECK(err_code);
}
#endif
/**@brief Function for handling the ADC interrupt.
*
* @details This function will fetch the conversion result from the ADC, convert the value into
* percentage and send it to peer.
*/
static void buff_voltage_handler(nrf_drv_saadc_evt_t const * p_event) /* PD Voltage reading */
{
ret_code_t err_code;
int16_t sum = 0;
uint32_t buff_clk_delay = m_pd_delay_us/16;
if(ble_connection_st == 0) {
//imm_adc_end();
//custom_send_timer_stop();
printf("Custom ADC STOP 1\r\n");
}
else{
if (p_event->type == NRF_DRV_SAADC_EVT_DONE)
{
err_code = nrf_drv_saadc_buffer_convert(p_event->data.done.p_buffer, buff_samples_in_buffer + buff_clk_delay);
APP_ERROR_CHECK(err_code);
if(led_no == -1) {
led_no = 0;
pd_no = 0;
led_on(LED_list_buff[led_no]);
led_pd_matching_value_set(LED_list_buff[led_no]); /* MCP4725 DAC setting and PD on */
} else {
for(uint16_t i = buff_clk_delay; i < buff_clk_delay + buff_samples_in_buffer; i++){
buff_cycle_buff[buf_no][i-buff_clk_delay] = p_event->data.done.p_buffer[i];
}
#if FEATURE_PRINTF
printf("-----------------Read ADC // led_no = %d(%d), pd_no = %d(%d), buf_no = %d\r\n\r\n", led_no, LED_list_custom[led_no], pd_no, PD_list_custom[pd_no], buf_no);
#endif
buf_no++;
if(pd_no >= - 1) {
//pd_no = 0;
if(led_no < buff_LED_NO - 1) {
led_no++;
led_on(LED_list_buff[led_no]);
led_pd_matching_value_set(LED_list_buff[led_no]); /* MCP4725 DAC setting and PD on */
} else if(led_no >= buff_LED_NO - 1) {
pd_no = -1;
led_no = -1;
#if FEATURE_PRINTF
printf("\r\nEnded\r\n");
#endif
//imm_adc_end();
//imm_adc_end_final();
///////////////////////////////////////////////////////////////////////////////////////////
uint8_t k =0;
sum = 0;
for(uint16_t i = 0; i < buff_LED_NO; i++){
for(uint16_t j = 0; j < buff_samples_in_buffer; j++){
sum += buff_cycle_buff[i][j];
}
buff_cycle_send_buff[k++] = sum;
sum = 0;
}
buf_no = 0;
if(ble_connection_st == 0) {
printf("Custom ADC STOP 1");
pd_adc_buff_start=false;
pd_adc_buff_running=false;
printf ("FINISH SEND\r\n");
processing = false;
buff_testing = false;
buff_adc_end_final();
}
else {
if(cmd_type_t == CMD_UART) {
//custom_send_timer_stop();
}else if(cmd_type_t == CMD_BLE) {
// printf("%d ms \r\n",t_ms);
//printf("value 4: %d,%d,%d,%d \r\n",imm_cycle_send_buff[0] ,imm_cycle_send_buff[1] ,imm_cycle_send_buff[2] ,imm_cycle_send_buff[3] );
for(uint16_t i = 0; i < buff_LED_NO; i++){
printf("%d,",buff_cycle_send_buff[i]);
bi_buff_cycle_send_buff[buff_cnt][i]=(uint16_t)(buff_cycle_send_buff[i]);
//single_bi_buff_cycle_send_buff[i]=(uint16_t)(buff_cycle_send_buff[i]);
}
printf("%d ms \r\n",t_ms);
// format_data(buff_bin_buffer, "rjb:", bi_buff_cycle_send_buff, 200);
//
//
// binary_tx_handler(buff_bin_buffer,102);
}
// if(ble_connection_st == 1) {
// battery_timer_start();
// }
led_off(99);
pd_off(99);
buff_adc_start_init();
}
}
}
}
}
}
}
void buff_check_loop(void * p_context)
{
UNUSED_PARAMETER(p_context);
buff_check_timer_stop();
if ( buff_testing == false)
{
printf("%d ms \r\n",t_ms);
// sprintf(custom_tx_buffer, "Measure Time :%d ms \r\n",t_ms);
}
else
{
t_ms++;
buff_check_timer_start();
}
}
void buff_send_loop(void * p_context) /* For x ms */
{
UNUSED_PARAMETER(p_context);
buff_send_timer_stop();
char resp[4];
if(ble_connection_st == BLE_DISCONNECTED_ST) {
// order=0;
// full_send_timer_stop();
buff_adc_end_final();
printf("BUFF ADC STOP 2\r\n");
processing = false;
}
else if(order<4){
sprintf(resp,"r%02d:", order);
format_data(buff_bin_buffer, resp, bi_buff_cycle_send_buff[order],100);
binary_tx_handler(buff_bin_buffer,102);
order++;
buff_send_timer_start();
}
else
{
printf("ddddd%d ms \r\n",t_ms);
processing = false;
buff_adc_end_final();
//battery_timer_start();
}
}
// switch(order) {
// case 0:
// sprintf(resp,"r%02X:", order);
// format_data(buff_bin_buffer, resp, bi_buff_cycle_send_buff[0],100);
// binary_tx_handler(buff_bin_buffer,102);
// break;
// case 1:
// format_data(buff_bin_buffer, "rb1:", bi_buff_cycle_send_buff[1],100);
// binary_tx_handler(buff_bin_buffer,102);
//
// break;
// case 2:
// format_data(buff_bin_buffer, "rb2:", bi_buff_cycle_send_buff[2],100);
// binary_tx_handler(buff_bin_buffer,102);
//
// break;
// case 3:
// format_data(buff_bin_buffer, "rb3:", bi_buff_cycle_send_buff[3],100);
// binary_tx_handler(buff_bin_buffer,102);
// break;
// case 4:
// format_data(buff_bin_buffer, "rb4:", bi_buff_cycle_send_buff[4],100);
// binary_tx_handler(buff_bin_buffer,102);
// break;
//
// case 5:
// format_data(buff_bin_buffer, "rb5:", bi_buff_cycle_send_buff[5],100);
// binary_tx_handler(buff_bin_buffer,102);
// break;
//
//
// case 6:
// format_data(buff_bin_buffer, "rb6:", bi_buff_cycle_send_buff[6],100);
// binary_tx_handler(buff_bin_buffer,102);
// break;
// case 7:
// format_data(buff_bin_buffer, "rb7:", bi_buff_cycle_send_buff[7],100);
// binary_tx_handler(buff_bin_buffer,102);
//
// break;
// case 8:
// format_data(buff_bin_buffer, "rb8:", bi_buff_cycle_send_buff[8],100);
// binary_tx_handler(buff_bin_buffer,102);
//
// break;
// case 9:
// format_data(buff_bin_buffer, "rb9:", bi_buff_cycle_send_buff[9],100);
// binary_tx_handler(buff_bin_buffer,102);
// break;
//
//
//
//
//
// case 10:
// printf("Measure Time : %d ms \r\n",t_ms);
// //sprintf(full_tx_buffer, "Measure Time :%d ms \r\n",t_ms);
// // data_tx_handler(full_tx_buffer);
// order = 0;
// return;
//#if FEATURE_PRINTF
// printf("full_send Completed\r\n");
//#endif
// default:
//
// break;
// }
void buff_adc_start_init(void)
{
if (ble_got_new_data ==true)
{
pd_adc_buff_start=false;
pd_adc_buff_running=false;
printf ("FINISH SEND\r\n");
led_off(99);
pd_off(99);
processing = false;
buff_testing = false;
buff_adc_end_final();
}
else if (pd_adc_buff_running==true){
if(buff_cnt>=b_t_cnt){
led_off(99);
pd_off(99);
pd_adc_buff_start=false;
pd_adc_buff_running=false;
printf ("FIFNISH SEND\r\n");
buff_testing = false;
order =0;
buff_send_timer_start();
//buff_adc_start();
}
else{
buff_adc_start();
buff_cnt++;
}
}
else if (pd_adc_buff_start==true)
{
// custom_testing = false;
// motion_raw_data_enabled = true;
// custom_add_data = true;
// icm42670_main();
for(uint8_t i =0; i < 25; i++) {
LED_list_buff[i*4] = bsel_led_index0;
LED_list_buff[i*4+1] = bsel_led_index1;
LED_list_buff[i*4+2] = bsel_led_index2;
LED_list_buff[i*4+3] = bsel_led_index3;
// data_tx_handler(ble_tx_buffer);
}
for(uint8_t i =0; i < 60; i++) {
for(uint8_t j =0; j < 100; j++) {
bi_buff_cycle_send_buff[i][j]=0;
}
}
t_ms=0;
buff_cnt=0;
pd_adc_buff_start=false;
pd_adc_buff_running=true;
buff_testing = true;
// custom_check_timer_start();
// c_cnt=0;
// pd_adc_custom_start=false;
// pd_adc_custom_a_start=true;
buff_adc_start2();
buff_check_timer_start();
// c_cnt++;
}
else
{
}
}
void buff_adc_start(void)
{
pd_no = -1;
led_no = -1;
buf_no = 0;
for(uint16_t i = 0; i < buff_LED_NO; i++) {
for(uint16_t j = 0; j < buff_CYCLE_CNT; j++) {
buff_cycle_buff[i][j] = 0;
}
}
}
void buff_adc_start2(void)
{
buff_adc_start();
buff_adc_init();
buff_irq_init();
buff_ppi_init();
buff_sampling_event_enable();
}
void buff_adc_end(void)
{
printf("adc_end\r\n");
buff_sampling_event_disable();
}
void buff_adc_end_final(void)
{
printf("adc_end_for_good\r\n");
buff_sampling_event_disable();
buff_irq_uninit();
buff_ppi_uninit();
buff_adc_uninit();
}
void buff_adc_init(void)
{
#if FEATURE_PRINTF
printf("custom_adc_init\r\n");
#endif
static nrfx_saadc_config_t default_config;
default_config.resolution = (nrf_saadc_resolution_t)NRFX_SAADC_CONFIG_RESOLUTION; /* Resolution is 10bits */
default_config.oversample = (nrf_saadc_oversample_t)NRFX_SAADC_CONFIG_OVERSAMPLE; /* Over Sampling Disabled */
default_config.interrupt_priority = NRFX_SAADC_CONFIG_IRQ_PRIORITY; /* Interrupt Priority is 0(Highest) */
default_config.low_power_mode = NRFX_SAADC_CONFIG_LP_MODE; /* Low Power Mode is Disabled */
static nrf_saadc_channel_config_t config;
config.resistor_p = NRF_SAADC_RESISTOR_DISABLED;
config.resistor_n = NRF_SAADC_RESISTOR_DISABLED;
config.gain = NRF_SAADC_GAIN1_6;
config.reference = NRF_SAADC_REFERENCE_INTERNAL;
config.acq_time = NRF_SAADC_ACQTIME_3US;
config.mode = NRF_SAADC_MODE_DIFFERENTIAL;
config.burst = NRF_SAADC_BURST_DISABLED;
config.pin_p = (nrf_saadc_input_t)(NRF_SAADC_INPUT_AIN0);
config.pin_n = (nrf_saadc_input_t)(NRF_SAADC_INPUT_AIN1);
ret_code_t err_code = nrf_drv_saadc_init(&default_config, buff_voltage_handler);
APP_ERROR_CHECK(err_code);
err_code = nrf_drv_saadc_channel_init(0, &config);
APP_ERROR_CHECK(err_code);
err_code = nrf_drv_saadc_buffer_convert(pd_buff_adc_buf[0], buff_samples_in_buffer + m_pd_delay_us/16);
APP_ERROR_CHECK(err_code);
}
void buff_adc_uninit(void)
{
#if FEATURE_PRINTF
printf("pd_custom_adc_uninit\r\n");
#endif
nrf_drv_saadc_uninit();
nrf_drv_saadc_channel_uninit(0);
}
#if !FEATURE_PRINTF
void buff_irq_init(void)
{
ret_code_t err_code;
/* Initialize int pin */
if (!nrfx_gpiote_is_init())
{
err_code = nrfx_gpiote_init();
APP_ERROR_CHECK(err_code);
}
nrfx_gpiote_in_config_t in_config = NRFX_GPIOTE_CONFIG_IN_SENSE_LOTOHI(true);
in_config.pull = NRF_GPIO_PIN_PULLDOWN;
err_code = nrfx_gpiote_in_init(ADA2200_SYNCO_PIN, &in_config, NULL);
APP_ERROR_CHECK(err_code);
nrfx_gpiote_in_event_enable(ADA2200_SYNCO_PIN, true);
}
void buff_irq_uninit(void)
{
nrfx_gpiote_in_event_disable(ADA2200_SYNCO_PIN);
nrfx_gpiote_in_uninit(ADA2200_SYNCO_PIN);
}
#endif
void buff_send_timer_start(void)
{
APP_ERROR_CHECK(app_timer_start(m_buff_send_loop_timer_id, APP_TIMER_TICKS(BUFF_SEND_LOOP_INTERVAL), NULL));
}
void buff_send_timer_stop(void)
{
APP_ERROR_CHECK(app_timer_stop(m_buff_send_loop_timer_id));
}
void buff_send_timer_init(void)
{
APP_ERROR_CHECK(app_timer_create(&m_buff_send_loop_timer_id, APP_TIMER_MODE_SINGLE_SHOT, buff_send_loop));
}
void buff_check_timer_start(void)
{
APP_ERROR_CHECK(app_timer_start(m_buff_check_loop_timer_id, APP_TIMER_TICKS(BUFF_CHECK_LOOP_INTERVAL), NULL));
}
void buff_check_timer_stop(void)
{
APP_ERROR_CHECK(app_timer_stop(m_buff_check_loop_timer_id));
}
void buff_check_timer_init(void)
{
APP_ERROR_CHECK(app_timer_create(&m_buff_check_loop_timer_id, APP_TIMER_MODE_SINGLE_SHOT, buff_check_loop));
}

58
project/ble_peripheral/ble_app_bladder_patch/meas_pd_buff.h
View File

@@ -1,58 +0,0 @@
/*******************************************************************************
* @file meas_pd_buff.h
******************************************************************************/
#ifndef _MEAS_PD_BUFF_H__
#define _MEAS_PD_BUFF_H__
#include "sdk_common.h"
#include "nrf_drv_saadc.h"
#define ADA2200_SYNCO_PIN NRF_GPIO_PIN_MAP(0,17)
#define buff_PD_NO 1/////4
#define buff_LED_NO 100////5
#define buff_CYCLE_CNT 8 ////32
void buff_ppi_init(void);
void buff_ppi_uninit(void);
void buff_sampling_event_enable(void);
void buff_sampling_event_disable(void);
/**@brief Function for handling the ADC interrupt.
*
* @details This function will fetch the conversion result from the ADC, convert the value into
* percentage and send it to peer.
*/
static void buff_voltage_handler(nrf_drv_saadc_evt_t const * p_event); /* PD Voltage reading */
void buff_adc_start_init(void);
void buff_adc_start(void);
void buff_adc_start2(void);
//void custom_adc_start2(void);
//void custom_adc_total_start(void);
void buff_adc_end(void);
void buff_adc_end_final(void);
void buff_adc_init(void);
void buff_adc_uninit(void);
void buff_irq_init(void);
void buff_irq_uninit(void);
void buff_send_start(void);
void buff_send_loop(void * p_context); /* For x ms */
void buff_send_timer_start(void);
void buff_send_timer_stop(void);;
void buff_send_timer_init(void);
void buff_check_loop(void * p_context);
void buff_check_timer_start(void);
void buff_check_timer_stop(void);;
void buff_check_timer_init(void);
#endif /* _MEAS_PD_buff_H__ */

522
project/ble_peripheral/ble_app_bladder_patch/meas_pd_imm.c
View File

@@ -1,522 +0,0 @@
/*******************************************************************************
TEST medi50 Dec 23
******************************************************************************/
#include "sdk_common.h"
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include "nrf.h"
#include "boards.h"
#include "app_error.h"
#include "nrf_drv_saadc.h"
#include "nrfx_gpiote.h"
#include "app_timer.h"
#include "nrf_drv_timer.h"
#include "nrf_delay.h"
#include "nrf_drv_ppi.h"
#include "ada2200_spi.h"
#include "ble_nus.h"
//#include "fstorage.h"
#include "measurements.h"
#include "meas_pd_imm.h"
#include "mcp4725_i2c.h"
#include "ad5272_i2c.h"
#include "main_timer.h"
#include "battery_saadc.h"
#include "main.h"
#include "app_raw_main.h"
#include "debug_print.h"
//#define CUSTOM_REF_VOLTAGE_IN_MILLIVOLTS 600.0f /**< Reference voltage (in milli volts) used by ADC while doing conversion. */
//#define CUSTOM_PRE_SCALING_COMPENSATION 6.0f /**< The ADC is configured to use VDD with 1/3 prescaling as input. And hence the result of conversion is to be multiplied by 3 to get the actual value of the battery voltage.*/
//#define CUSTOM_ADC_RES_10BITS 1024.0f /**< Maximum digital value for 10-bit ADC conversion. */
//#define st_c_max 20
///**@brief Macro to convert the result of ADC conversion in millivolts.
// *
// * @param[in] ADC_VALUE ADC result.
// *
// * @retval Result converted to millivolts.
// */
//#define CUSTOM_VOUT_IN_MILLI_VOLTS(ADC_VALUE)\
// (((((ADC_VALUE) * CUSTOM_REF_VOLTAGE_IN_MILLIVOLTS) / CUSTOM_ADC_RES_10BITS) * CUSTOM_PRE_SCALING_COMPENSATION)*2)
static const uint8_t imm_samples_in_buffer = 8;
//uint32_t s_cnt;
uint8_t LED_list_imm[4];
//uint8_t PD_list_custom[4];
//uint8_t led_custom_list_a[5] = {2,3,4,5,6};
//uint8_t pd_custom_list_a[4] = {5,7,8,10};
//uint8_t led_custom_list_b[5] = {20,21,22,23,24};
//uint8_t pd_custom_list_b[4] = {16,14,13,11};
int32_t c_max;
extern volatile bool processing;
extern volatile bool data_tx_in_progress;
extern volatile bool ble_connection_st;
extern uint16_t m_pd_delay_us;
uint32_t c_cnt;
static int8_t pd_no = -1;
static int8_t led_no = -1;
static int8_t buf_no = 0;
uint16_t sel_led_index0 =0;
uint16_t sel_led_index1 =1;
uint16_t sel_led_index2 =2;
uint16_t sel_led_index3 =3;
//static int8_t c_max = 5;
static int32_t t_ms = 0;
int16_t imm_cycle_buff[4][imm_CYCLE_CNT] =
{
{0, 0, 0, 0, 0, 0, 0, 0}, //0
{0, 0, 0, 0, 0, 0, 0, 0}, //1
{0, 0, 0, 0, 0, 0, 0, 0}, //2
{0, 0, 0, 0, 0, 0, 0, 0} //3
};
int16_t imm_cycle_send_buff[imm_LED_NO] = {0, 0, 0, 0};
uint16_t bi_imm_cycle_send_buff[imm_LED_NO] = {0, 0, 0, 0};
#define SAMPLES_IN_BUFFER 4095+32
static nrf_saadc_value_t pd_imm_adc_buf[2][SAMPLES_IN_BUFFER];
bool pd_adc_custom_a_start = false;
bool pd_adc_custom_b_start = false;
bool pd_adc_custom_c_start = false;
bool pd_adc_custom_d_start = false;
bool pd_adc_custom_end = false;
bool pd_adc_custom_start = false;
bool pd_adc_imm_start = false;
bool pd_adc_imm_running = false;
bool custom_testing = false;
//
bool custom_add_data;
extern bool ble_got_new_data;
extern bool motion_raw_data_enabled;
extern char ble_tx_buffer[BLE_NUS_MAX_DATA_LEN];
uint8_t imm_bin_buffer[BLE_NUS_MAX_DATA_LEN];
//add imu
uint8_t order_imm=0;
extern which_cmd_t cmd_type_t;
APP_TIMER_DEF(m_custom_check_loop_timer_id);
//APP_TIMER_DEF(m_custom_send_loop_timer_id);
#if FEATURE_DELAY
#define CUSTOM_SEND_LOOP_INTERVAL 500
#else
#define CUSTOM_SEND_LOOP_INTERVAL 100
#endif
#define CUSTOM_CHECK_LOOP_INTERVAL 1
static nrf_ppi_channel_t m_ppi_channel;
#if !FEATURE_PRINTF
void imm_ppi_init(void)
{
ret_code_t err_code;
err_code = nrf_drv_ppi_init();
APP_ERROR_CHECK(err_code);
uint32_t gpiote_event_addr = nrf_drv_gpiote_in_event_addr_get(ADA2200_SYNCO_PIN);
uint32_t saadc_sample_task_addr = nrf_drv_saadc_sample_task_get();
/* setup ppi channel so that timer compare event is triggering sample task in SAADC */
err_code = nrf_drv_ppi_channel_alloc(&m_ppi_channel);
APP_ERROR_CHECK(err_code);
err_code = nrf_drv_ppi_channel_assign(m_ppi_channel,
gpiote_event_addr,
saadc_sample_task_addr);
APP_ERROR_CHECK(err_code);
}
void imm_ppi_uninit(void)
{
ret_code_t err_code;
err_code = nrf_drv_ppi_uninit();
APP_ERROR_CHECK(err_code);
}
void imm_sampling_event_enable(void)
{
ret_code_t err_code = nrf_drv_ppi_channel_enable(m_ppi_channel);
APP_ERROR_CHECK(err_code);
}
void imm_sampling_event_disable(void)
{
ret_code_t err_code = nrf_drv_ppi_channel_disable(m_ppi_channel);
APP_ERROR_CHECK(err_code);
}
#endif
/**@brief Function for handling the ADC interrupt.
*
* @details This function will fetch the conversion result from the ADC, convert the value into
* percentage and send it to peer.
*/
static void imm_voltage_handler(nrf_drv_saadc_evt_t const * p_event) /* PD Voltage reading */
{
ret_code_t err_code;
int16_t sum = 0;
uint32_t custom_clk_delay = m_pd_delay_us/16;
if(ble_connection_st == 0) {
//imm_adc_end();
//custom_send_timer_stop();
DBG_PRINTF("Custom ADC STOP 1\r\n");
}
else{
if (p_event->type == NRF_DRV_SAADC_EVT_DONE)
{
err_code = nrf_drv_saadc_buffer_convert(p_event->data.done.p_buffer, imm_samples_in_buffer + custom_clk_delay);
APP_ERROR_CHECK(err_code);
if(led_no == -1) {
led_no = 0;
pd_no = 0;
led_on(LED_list_imm[led_no]);
led_pd_matching_value_set(LED_list_imm[led_no]); /* MCP4725 DAC setting and PD on */
} else {
for(uint16_t i = custom_clk_delay; i < custom_clk_delay + imm_samples_in_buffer; i++){
imm_cycle_buff[buf_no][i-custom_clk_delay] = p_event->data.done.p_buffer[i];
}
#if FEATURE_PRINTF
DBG_PRINTF("-----------------Read ADC // led_no = %d(%d), pd_no = %d(%d), buf_no = %d\r\n\r\n", led_no, LED_list_custom[led_no], pd_no, PD_list_custom[pd_no], buf_no);
#endif
buf_no++;
if(pd_no >= - 1) {
//pd_no = 0;
if(led_no < imm_LED_NO - 1) {
led_no++;
led_on(LED_list_imm[led_no]);
led_pd_matching_value_set(LED_list_imm[led_no]); /* MCP4725 DAC setting and PD on */
} else if(led_no >= imm_LED_NO - 1) {
pd_no = -1;
led_no = -1;
#if FEATURE_PRINTF
DBG_PRINTF("\r\nEnded\r\n");
#endif
//imm_adc_end();
//imm_adc_end_final();
///////////////////////////////////////////////////////////////////////////////////////////
uint8_t k =0;
sum = 0;
for(uint16_t i = 0; i < 4; i++){
for(uint16_t j = 0; j < imm_samples_in_buffer; j++){
sum += imm_cycle_buff[i][j];
}
imm_cycle_send_buff[k++] = sum;
sum = 0;
}
buf_no = 0;
if(ble_connection_st == 0) {
DBG_PRINTF("Custom ADC STOP 1");
pd_adc_imm_start=false;
pd_adc_imm_running=false;
DBG_PRINTF ("FINISH SEND\r\n");
processing = false;
custom_testing = false;
imm_adc_end_final();
}
else {
char resp[4];
if(cmd_type_t == CMD_UART) {
//custom_send_timer_stop();
DBG_PRINTF("value 4: %d,%d,%d,%d \r\n",imm_cycle_send_buff[0] ,imm_cycle_send_buff[1] ,imm_cycle_send_buff[2] ,imm_cycle_send_buff[3] );
}else if(cmd_type_t == CMD_BLE) {
DBG_PRINTF("%d ms \r\n",t_ms);
DBG_PRINTF("value 4: %d,%d,%d,%d \r\n",imm_cycle_send_buff[0] ,imm_cycle_send_buff[1] ,imm_cycle_send_buff[2] ,imm_cycle_send_buff[3] );
for(uint16_t i = 0; i < 4; i++){
bi_imm_cycle_send_buff[i]=(uint16_t)(imm_cycle_send_buff[i]);
}
sprintf(resp,"rF%01X:", order_imm);
format_data(imm_bin_buffer, resp, bi_imm_cycle_send_buff, 4);
binary_tx_handler(imm_bin_buffer,6);
}
// if(ble_connection_st == 1) {
// battery_timer_start();
// }
// led_off(99);
// pd_off(99);
imm_adc_start_init();
}
}
}
}
}
}
}
void imm_check_loop(void * p_context)
{
UNUSED_PARAMETER(p_context);
imm_check_timer_stop();
if ( custom_testing == false)
{
DBG_PRINTF("%d ms \r\n",t_ms);
// sprintf(custom_tx_buffer, "Measure Time :%d ms \r\n",t_ms);
}
else
{
t_ms++;
imm_check_timer_start();
}
}
void imm_adc_start_init(void)
{
if (ble_got_new_data ==true)
{
pd_adc_imm_start=false;
pd_adc_imm_running=false;
DBG_PRINTF ("FINISH SEND\r\n");
led_off(99);
pd_off(99);
processing = false;
custom_testing = false;
imm_adc_end_final();
}
else if (pd_adc_imm_running==true){
imm_adc_start();
}
else if (pd_adc_imm_start==true)
{
// custom_testing = false;
// motion_raw_data_enabled = true;
// custom_add_data = true;
// icm42670_main();
//for(uint8_t i =0; i < imm_LED_NO; i++) {
LED_list_imm[0] = sel_led_index0;
LED_list_imm[1] = sel_led_index1;
LED_list_imm[2] = sel_led_index2;
LED_list_imm[3] = sel_led_index3;
// data_tx_handler(ble_tx_buffer);
t_ms=0;
pd_adc_imm_start=false;
pd_adc_imm_running=true;
custom_testing = true;
// custom_check_timer_start();
c_cnt=0;
// pd_adc_custom_start=false;
// pd_adc_custom_a_start=true;
imm_adc_start2();
imm_check_timer_start();
c_cnt++;
}
else
{
}
}
void imm_adc_start(void)
{
pd_no = -1;
led_no = -1;
buf_no = 0;
t_ms=0;
for(uint16_t i = 0; i < 4; i++) {
for(uint16_t j = 0; j < imm_CYCLE_CNT; j++) {
imm_cycle_buff[i][j] = 0;
}
}
if(order_imm>=15){
order_imm=0;
}
else
{ order_imm++;
}
}
void imm_adc_start2(void)
{
imm_adc_start();
imm_adc_init();
imm_irq_init();
imm_ppi_init();
imm_sampling_event_enable();
}
void imm_adc_end(void)
{
DBG_PRINTF("adc_end\r\n");
imm_sampling_event_disable();
}
void imm_adc_end_final(void)
{
DBG_PRINTF("adc_end_for_good\r\n");
imm_sampling_event_disable();
imm_irq_uninit();
imm_ppi_uninit();
imm_adc_uninit();
battery_timer_start();
}
void imm_adc_init(void)
{
#if FEATURE_PRINTF
DBG_PRINTF("custom_adc_init\r\n");
#endif
static nrfx_saadc_config_t default_config;
default_config.resolution = (nrf_saadc_resolution_t)NRFX_SAADC_CONFIG_RESOLUTION; /* Resolution is 10bits */
default_config.oversample = (nrf_saadc_oversample_t)NRFX_SAADC_CONFIG_OVERSAMPLE; /* Over Sampling Disabled */
default_config.interrupt_priority = NRFX_SAADC_CONFIG_IRQ_PRIORITY; /* Interrupt Priority is 0(Highest) */
default_config.low_power_mode = NRFX_SAADC_CONFIG_LP_MODE; /* Low Power Mode is Disabled */
static nrf_saadc_channel_config_t config;
config.resistor_p = NRF_SAADC_RESISTOR_DISABLED;
config.resistor_n = NRF_SAADC_RESISTOR_DISABLED;
config.gain = NRF_SAADC_GAIN1_6;
config.reference = NRF_SAADC_REFERENCE_INTERNAL;
config.acq_time = NRF_SAADC_ACQTIME_3US;
config.mode = NRF_SAADC_MODE_DIFFERENTIAL;
config.burst = NRF_SAADC_BURST_DISABLED;
config.pin_p = (nrf_saadc_input_t)(NRF_SAADC_INPUT_AIN0);
config.pin_n = (nrf_saadc_input_t)(NRF_SAADC_INPUT_AIN1);
ret_code_t err_code = nrf_drv_saadc_init(&default_config, imm_voltage_handler);
APP_ERROR_CHECK(err_code);
err_code = nrf_drv_saadc_channel_init(0, &config);
APP_ERROR_CHECK(err_code);
err_code = nrf_drv_saadc_buffer_convert(pd_imm_adc_buf[0], imm_samples_in_buffer + m_pd_delay_us/16);
APP_ERROR_CHECK(err_code);
}
void imm_adc_uninit(void)
{
#if FEATURE_PRINTF
DBG_PRINTF("pd_custom_adc_uninit\r\n");
#endif
nrf_drv_saadc_uninit();
nrf_drv_saadc_channel_uninit(0);
}
#if !FEATURE_PRINTF
void imm_irq_init(void)
{
ret_code_t err_code;
/* Initialize int pin */
if (!nrfx_gpiote_is_init())
{
err_code = nrfx_gpiote_init();
APP_ERROR_CHECK(err_code);
}
nrfx_gpiote_in_config_t in_config = NRFX_GPIOTE_CONFIG_IN_SENSE_LOTOHI(true);
in_config.pull = NRF_GPIO_PIN_PULLDOWN;
err_code = nrfx_gpiote_in_init(ADA2200_SYNCO_PIN, &in_config, NULL);
APP_ERROR_CHECK(err_code);
nrfx_gpiote_in_event_enable(ADA2200_SYNCO_PIN, true);
}
void imm_irq_uninit(void)
{
nrfx_gpiote_in_event_disable(ADA2200_SYNCO_PIN);
nrfx_gpiote_in_uninit(ADA2200_SYNCO_PIN);
}
#endif
void imm_check_timer_start(void)
{
APP_ERROR_CHECK(app_timer_start(m_custom_check_loop_timer_id, APP_TIMER_TICKS(CUSTOM_CHECK_LOOP_INTERVAL), NULL));
}
void imm_check_timer_stop(void)
{
APP_ERROR_CHECK(app_timer_stop(m_custom_check_loop_timer_id));
}
void imm_check_timer_init(void)
{
APP_ERROR_CHECK(app_timer_create(&m_custom_check_loop_timer_id, APP_TIMER_MODE_SINGLE_SHOT, imm_check_loop));
}

58
project/ble_peripheral/ble_app_bladder_patch/meas_pd_imm.h
View File

@@ -1,58 +0,0 @@
/*******************************************************************************
* @file meas_pd_imm.h
******************************************************************************/
#ifndef _MEAS_PD_IMM_H__
#define _MEAS_PD_IMM_H__
#include "sdk_common.h"
#include "nrf_drv_saadc.h"
#define ADA2200_SYNCO_PIN NRF_GPIO_PIN_MAP(0,17)
#define imm_PD_NO 1/////4
#define imm_LED_NO 4////5
#define imm_CYCLE_CNT 8 ////32
void imm_ppi_init(void);
void imm_ppi_uninit(void);
void imm_sampling_event_enable(void);
void imm_sampling_event_disable(void);
/**@brief Function for handling the ADC interrupt.
*
* @details This function will fetch the conversion result from the ADC, convert the value into
* percentage and send it to peer.
*/
static void imm_voltage_handler(nrf_drv_saadc_evt_t const * p_event); /* PD Voltage reading */
void imm_adc_start_init(void);
void imm_adc_start(void);
void imm_adc_start2(void);
//void custom_adc_start2(void);
//void custom_adc_total_start(void);
void imm_adc_end(void);
void imm_adc_end_final(void);
void imm_adc_init(void);
void imm_adc_uninit(void);
void imm_irq_init(void);
void imm_irq_uninit(void);
//void custom_send_start(void);
//void custom_send_loop(void * p_context); /* For x ms */
//void custom_send_timer_start(void);
//void custom_send_timer_stop(void);;
//void custom_send_timer_init(void);
void imm_check_loop(void * p_context);
void imm_check_timer_start(void);
void imm_check_timer_stop(void);;
void imm_check_timer_init(void);
#endif /* _MEAS_PD_VOLTAGE_CUSTOM_H__ */

885
project/ble_peripheral/ble_app_bladder_patch/meas_pd_voltage_custom.c
View File

@@ -1,885 +0,0 @@
/*******************************************************************************
TEST medi50 Dec 23
******************************************************************************/
#include "sdk_common.h"
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include "nrf.h"
#include "boards.h"
#include "app_error.h"
#include "nrf_drv_saadc.h"
#include "nrfx_gpiote.h"
#include "app_timer.h"
#include "nrf_drv_timer.h"
#include "nrf_delay.h"
#include "nrf_drv_ppi.h"
#include "ada2200_spi.h"
#include "ble_nus.h"
#include "fstorage.h"
#include "measurements.h"
#include "meas_pd_voltage_custom.h"
#include "mcp4725_i2c.h"
#include "ad5272_i2c.h"
#include "main_timer.h"
#include "battery_saadc.h"
#include "main.h"
#include "app_raw_main.h"
#define CUSTOM_REF_VOLTAGE_IN_MILLIVOLTS 600.0f /**< Reference voltage (in milli volts) used by ADC while doing conversion. */
#define CUSTOM_PRE_SCALING_COMPENSATION 6.0f /**< The ADC is configured to use VDD with 1/3 prescaling as input. And hence the result of conversion is to be multiplied by 3 to get the actual value of the battery voltage.*/
#define CUSTOM_ADC_RES_10BITS 1024.0f /**< Maximum digital value for 10-bit ADC conversion. */
#define st_c_max 20
/**@brief Macro to convert the result of ADC conversion in millivolts.
*
* @param[in] ADC_VALUE ADC result.
*
* @retval Result converted to millivolts.
*/
#define CUSTOM_VOUT_IN_MILLI_VOLTS(ADC_VALUE)\
(((((ADC_VALUE) * CUSTOM_REF_VOLTAGE_IN_MILLIVOLTS) / CUSTOM_ADC_RES_10BITS) * CUSTOM_PRE_SCALING_COMPENSATION)*2)
uint8_t custom_samples_in_buffer = 8;
uint32_t s_cnt;
uint8_t LED_list_custom[5];
uint8_t PD_list_custom[4];
uint8_t led_custom_list_a[5] = {2,3,4,5,6};
uint8_t pd_custom_list_a[4] = {5,7,8,10};
uint8_t led_custom_list_b[5] = {20,21,22,23,24};
uint8_t pd_custom_list_b[4] = {16,14,13,11};
int32_t c_max;
extern volatile bool processing;
extern volatile bool data_tx_in_progress;
extern volatile bool ble_connection_st;
uint32_t c_cnt;
static int8_t pd_no = -1;
static int8_t led_no = -1;
static int8_t buf_no = 0;
//static int8_t c_max = 5;
static int32_t t_ms = 0;
double custom_cycle_buff[36][CUSTOM_CYCLE_CNT] =
{
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //0
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //1
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //2
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //3
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //4
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //5
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //6
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //7
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //8
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //9
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //10
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //11
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //12
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //13
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //14
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //15
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //16
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //17
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //18
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //19
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //20
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //21
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //22
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //23
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //24
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //25
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //26
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //27
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //28
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //29
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //30
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //31
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //32
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //33
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //34
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //35
};
double custom_cycle_send_buff[CUSTOM_LED_NO][CUSTOM_PD_NO] =
{
{0, 0, 0, 0},
{0, 0, 0, 0},
{0, 0, 0, 0},
{0, 0, 0, 0},
{0, 0, 0, 0}
};
#define SAMPLES_IN_BUFFER 4095+32
static nrf_saadc_value_t pd_custom_adc_buf[2][SAMPLES_IN_BUFFER];
bool pd_adc_custom_a_start = false;
bool pd_adc_custom_b_start = false;
bool pd_adc_custom_c_start = false;
bool pd_adc_custom_d_start = false;
bool pd_adc_custom_end = false;
bool pd_adc_custom_start = false;
bool custom_testing = false;
//
bool custom_add_data;
extern bool motion_raw_data_enabled;
extern char ble_tx_buffer[BLE_NUS_MAX_DATA_LEN];
//add imu
char custom_tx_buffer[BLE_NUS_MAX_DATA_LEN];
char custom_tx_d_buffer_0[st_c_max][BLE_NUS_MAX_DATA_LEN];
char custom_tx_d_buffer_1[st_c_max][BLE_NUS_MAX_DATA_LEN];
char custom_tx_d_buffer_2[st_c_max][BLE_NUS_MAX_DATA_LEN];
char custom_tx_d_buffer_3[st_c_max][BLE_NUS_MAX_DATA_LEN];
char custom_tx_d_buffer_4[st_c_max][BLE_NUS_MAX_DATA_LEN];
char custom_tx_d_buffer_5[st_c_max][BLE_NUS_MAX_DATA_LEN];
char custom_tx_d_buffer_6[st_c_max][BLE_NUS_MAX_DATA_LEN];
char custom_tx_d_buffer_7[st_c_max][BLE_NUS_MAX_DATA_LEN];
char custom_tx_d_buffer_8[st_c_max][BLE_NUS_MAX_DATA_LEN];
char custom_tx_d_buffer_9[st_c_max][BLE_NUS_MAX_DATA_LEN];
extern which_cmd_t cmd_type_t;
APP_TIMER_DEF(m_custom_check_loop_timer_id);
APP_TIMER_DEF(m_custom_send_loop_timer_id);
#if FEATURE_DELAY
#define CUSTOM_SEND_LOOP_INTERVAL 500
#else
#define CUSTOM_SEND_LOOP_INTERVAL 100
#endif
#define CUSTOM_CHECK_LOOP_INTERVAL 1
#if FEATURE_DEBUG_REPEAT_TEST
extern uint32_t rpt_cnt;
#endif
#if FEATURE_PRINTF
APP_TIMER_DEF(m_custom_loop_timer_id);
#define CUSTOM_LOOP_INTERVAL 1
void custom_timer_loop(void * p_context)
{
UNUSED_PARAMETER(p_context);
ret_code_t err_code = nrf_drv_saadc_sample();
APP_ERROR_CHECK(err_code);
}
void custom_timer_start(void)
{
APP_ERROR_CHECK(app_timer_start(m_custom_loop_timer_id, APP_TIMER_TICKS(CUSTOM_LOOP_INTERVAL), NULL));
}
void custom_timer_stop(void)
{
APP_ERROR_CHECK(app_timer_stop(m_custom_loop_timer_id));
}
void custom_timer_init(void)
{
APP_ERROR_CHECK(app_timer_create(&m_custom_loop_timer_id, APP_TIMER_MODE_REPEATED, custom_timer_loop));
}
#else
static nrf_ppi_channel_t m_ppi_channel;
#endif
#if !FEATURE_PRINTF
void custom_ppi_init(void)
{
ret_code_t err_code;
err_code = nrf_drv_ppi_init();
APP_ERROR_CHECK(err_code);
uint32_t gpiote_event_addr = nrf_drv_gpiote_in_event_addr_get(ADA2200_SYNCO_PIN);
uint32_t saadc_sample_task_addr = nrf_drv_saadc_sample_task_get();
/* setup ppi channel so that timer compare event is triggering sample task in SAADC */
err_code = nrf_drv_ppi_channel_alloc(&m_ppi_channel);
APP_ERROR_CHECK(err_code);
err_code = nrf_drv_ppi_channel_assign(m_ppi_channel,
gpiote_event_addr,
saadc_sample_task_addr);
APP_ERROR_CHECK(err_code);
}
void custom_ppi_uninit(void)
{
ret_code_t err_code;
err_code = nrf_drv_ppi_uninit();
APP_ERROR_CHECK(err_code);
}
void custom_sampling_event_enable(void)
{
ret_code_t err_code = nrf_drv_ppi_channel_enable(m_ppi_channel);
APP_ERROR_CHECK(err_code);
}
void custom_sampling_event_disable(void)
{
ret_code_t err_code = nrf_drv_ppi_channel_disable(m_ppi_channel);
APP_ERROR_CHECK(err_code);
}
#endif
/**@brief Function for handling the ADC interrupt.
*
* @details This function will fetch the conversion result from the ADC, convert the value into
* percentage and send it to peer.
*/
static void custom_voltage_handler(nrf_drv_saadc_evt_t const * p_event) /* PD Voltage reading */
{
ret_code_t err_code;
double sum = 0.0f;
uint32_t custom_clk_delay = m_config.pd_delay_us/16;
if(ble_connection_st == 0) {
custom_adc_end();
custom_send_timer_stop();
printf("Custom ADC STOP 1\r\n");
}
else{
if (p_event->type == NRF_DRV_SAADC_EVT_DONE)
{
err_code = nrf_drv_saadc_buffer_convert(p_event->data.done.p_buffer, custom_samples_in_buffer + custom_clk_delay);
APP_ERROR_CHECK(err_code);
if(led_no == -1) {
led_no = 0;
pd_no = 0;
led_on(LED_list_custom[led_no]);
led_pd_matching_value_set(LED_list_custom[led_no]); /* MCP4725 DAC setting and PD on */
} else {
for(uint16_t i = custom_clk_delay; i < custom_clk_delay + custom_samples_in_buffer; i++){
custom_cycle_buff[buf_no][i-custom_clk_delay] = (CUSTOM_VOUT_IN_MILLI_VOLTS(p_event->data.done.p_buffer[i])) * -1;
}
#if FEATURE_PRINTF
printf("-----------------Read ADC // led_no = %d(%d), pd_no = %d(%d), buf_no = %d\r\n\r\n", led_no, LED_list_custom[led_no], pd_no, PD_list_custom[pd_no], buf_no);
#endif
buf_no++;
if(pd_no < CUSTOM_PD_NO - 1) {
pd_no++;
led_pd_matching_value_set(LED_list_custom[led_no]); /* MCP4725 DAC setting and PD on */
}else if(pd_no >= CUSTOM_PD_NO - 1) {
pd_no = 0;
#if FEATURE_PRINTF
printf("\r\n\r\n");
#endif
if(led_no < CUSTOM_LED_NO - 1) {
led_no++;
led_on(LED_list_custom[led_no]);
led_pd_matching_value_set(LED_list_custom[led_no]); /* MCP4725 DAC setting and PD on */
} else if(led_no >= CUSTOM_LED_NO - 1) {
pd_no = -1;
led_no = -1;
#if FEATURE_PRINTF
printf("\r\nEnded\r\n");
#endif
custom_adc_end();
#if FEATURE_DETAIL_VALUE_CUSTOM
sum = 0;
printf("\r\nCustom_============custom_cycle_buff =\r\n");
for(uint16_t i = 0; i < 36; i++){
for(uint16_t j = 0; j < custom_samples_in_buffer; j++){
printf("%lf\r\n", custom_cycle_buff[i][j]);
}
for(uint16_t k = 0; k < custom_samples_in_buffer; k++){
sum += custom_cycle_buff[i][k];
}
printf("\t%lf\r\n", sum);
sum = 0;
}
printf("\r\n");
#endif
///////////////////////////////////////////////////////////////////////////////////////////
uint8_t k =0;
sum = 0;
for(uint16_t i = 0; i < 20; i++){
for(uint16_t j = 0; j < custom_samples_in_buffer; j++){
sum += custom_cycle_buff[i][j];
}
custom_cycle_send_buff[i/4][k++] = sum;
sum = 0;
if(k >= 4) k = 0;
}
///////////////////////////////////////////////////////////////////////////////////////////
/* Send data */
/*********************/
if(cmd_type_t == CMD_UART) {
printf("S%dTi%d,\t%lf,\t%lf,\t%lf,\t%lf,\r\n",c_cnt, LED_list_custom[0], custom_cycle_send_buff[0][0], custom_cycle_send_buff[0][1], custom_cycle_send_buff[0][2], custom_cycle_send_buff[0][3]);//, custom_cycle_send_buff[0][4], custom_cycle_send_buff[0][5]);
printf("Ti%d,\t%lf,\t%lf,\t%lf,\t%lf,\r\n", LED_list_custom[1], custom_cycle_send_buff[1][0], custom_cycle_send_buff[1][1], custom_cycle_send_buff[1][2], custom_cycle_send_buff[1][3]);//, custom_cycle_send_buff[1][4], custom_cycle_send_buff[1][5]);
printf("Ti%d,\t%lf,\t%lf,\t%lf,\t%lf,\r\n", LED_list_custom[2], custom_cycle_send_buff[2][0], custom_cycle_send_buff[2][1], custom_cycle_send_buff[2][2], custom_cycle_send_buff[2][3]);//, custom_cycle_send_buff[2][4], custom_cycle_send_buff[2][5]);
printf("Ti%d,\t%lf,\t%lf,\t%lf,\t%lf,\r\n", LED_list_custom[3], custom_cycle_send_buff[3][0], custom_cycle_send_buff[3][1], custom_cycle_send_buff[3][2], custom_cycle_send_buff[3][3]);//, custom_cycle_send_buff[3][4], custom_cycle_send_buff[3][5]);
printf("Ti%d,\t%lf,\t%lf,\t%lf,\t%lf,\r\n", LED_list_custom[4], custom_cycle_send_buff[4][0], custom_cycle_send_buff[4][1], custom_cycle_send_buff[4][2], custom_cycle_send_buff[4][3]);//, custom_cycle_send_buff[4][4], custom_cycle_send_buff[4][5]);
printf("\r\n");
} else if(cmd_type_t == CMD_BLE ) {
if(pd_adc_custom_a_start == true ) {
sprintf(custom_tx_d_buffer_0[c_cnt], "M%d,Ti%d,\t%lf,\t%lf,\t%lf,\t%lf,\r\n",c_cnt, LED_list_custom[0], custom_cycle_send_buff[0][0], custom_cycle_send_buff[0][1], custom_cycle_send_buff[0][2], custom_cycle_send_buff[0][3]);
sprintf(custom_tx_d_buffer_1[c_cnt], "M%d,Ti%d,\t%lf,\t%lf,\t%lf,\t%lf,\r\n",c_cnt, LED_list_custom[1], custom_cycle_send_buff[1][0], custom_cycle_send_buff[1][1], custom_cycle_send_buff[1][2], custom_cycle_send_buff[1][3]);
sprintf(custom_tx_d_buffer_2[c_cnt], "M%d,Ti%d,\t%lf,\t%lf,\t%lf,\t%lf,\r\n",c_cnt, LED_list_custom[2], custom_cycle_send_buff[2][0], custom_cycle_send_buff[2][1], custom_cycle_send_buff[2][2], custom_cycle_send_buff[2][3]);
sprintf(custom_tx_d_buffer_3[c_cnt], "M%d,Ti%d,\t%lf,\t%lf,\t%lf,\t%lf,\r\n",c_cnt, LED_list_custom[3], custom_cycle_send_buff[3][0], custom_cycle_send_buff[3][1], custom_cycle_send_buff[3][2], custom_cycle_send_buff[3][3]);
sprintf(custom_tx_d_buffer_4[c_cnt], "M%d,Ti%d,\t%lf,\t%lf,\t%lf,\t%lf,\r\n",c_cnt, LED_list_custom[4], custom_cycle_send_buff[4][0], custom_cycle_send_buff[4][1], custom_cycle_send_buff[4][2], custom_cycle_send_buff[4][3]);
}else if(pd_adc_custom_b_start == true) {
sprintf(custom_tx_d_buffer_5[c_cnt], "M%d,Ti%d,\t%lf,\t%lf,\t%lf,\t%lf\r\n",c_cnt, LED_list_custom[0], custom_cycle_send_buff[0][0], custom_cycle_send_buff[0][1], custom_cycle_send_buff[0][2], custom_cycle_send_buff[0][3]);
sprintf(custom_tx_d_buffer_6[c_cnt], "M%d,Ti%d,\t%lf,\t%lf,\t%lf,\t%lf\r\n",c_cnt, LED_list_custom[1], custom_cycle_send_buff[1][0], custom_cycle_send_buff[1][1], custom_cycle_send_buff[1][2], custom_cycle_send_buff[1][3]);
sprintf(custom_tx_d_buffer_7[c_cnt], "M%d,Ti%d,\t%lf,\t%lf,\t%lf,\t%lf\r\n",c_cnt, LED_list_custom[2], custom_cycle_send_buff[2][0], custom_cycle_send_buff[2][1], custom_cycle_send_buff[2][2], custom_cycle_send_buff[2][3]);
sprintf(custom_tx_d_buffer_8[c_cnt], "M%d,Ti%d,\t%lf,\t%lf,\t%lf,\t%lf\r\n",c_cnt, LED_list_custom[3], custom_cycle_send_buff[3][0], custom_cycle_send_buff[3][1], custom_cycle_send_buff[3][2], custom_cycle_send_buff[3][3]);
sprintf(custom_tx_d_buffer_9[c_cnt], "M%d,Ti%d,\t%lf,\t%lf,\t%lf,\t%lf\r\n",c_cnt, LED_list_custom[4], custom_cycle_send_buff[4][0], custom_cycle_send_buff[4][1], custom_cycle_send_buff[4][2], custom_cycle_send_buff[4][3]);
}
}
/*********************/
buf_no = 0;
if(ble_connection_st == 0) {
custom_adc_end();
custom_send_timer_stop();
printf("Custom ADC STOP 1");
}
else if(pd_adc_custom_a_start == true) { // B mode
pd_adc_custom_a_start = false;
pd_adc_custom_b_start = true;
custom_adc_start();
}else if(pd_adc_custom_b_start == true) { // Completed
pd_adc_custom_b_start = false;
// }
// else if(pd_adc_custom_a_start == true) { // Completed
// pd_adc_custom_a_start = false;
if(cmd_type_t == CMD_UART) {
custom_send_timer_stop();
}else if(cmd_type_t == CMD_BLE) {
}
// if(ble_connection_st == 1) {
// battery_timer_start();
// }
led_off(99);
pd_off(99);
custom_adc_total_start();
}
}
}
}
}
}
}
void custom_check_loop(void * p_context)
{
UNUSED_PARAMETER(p_context);
custom_check_timer_stop();
if ( custom_testing == false)
{
printf("%d ms \r\n",t_ms);
sprintf(custom_tx_buffer, "Measure Time :%d ms \r\n",t_ms);
}
else
{
t_ms++;
custom_check_timer_start();
}
}
void custom_send_loop(void * p_context) /* For x ms */
{
UNUSED_PARAMETER(p_context);
custom_send_timer_stop();
if(ble_connection_st){
if (data_tx_in_progress==true) {
// Data transmission is still in progress
printf("skip \r\n");
return;
}
static uint8_t order = 0;
switch(order) {
case 0:
data_tx_handler(custom_tx_d_buffer_0[s_cnt]);
break;
case 1:
data_tx_handler(custom_tx_d_buffer_1[s_cnt]);
break;
case 2:
data_tx_handler(custom_tx_d_buffer_2[s_cnt]);
break;
case 3:
data_tx_handler(custom_tx_d_buffer_3[s_cnt]);
break;
case 4:
data_tx_handler(custom_tx_d_buffer_4[s_cnt]);
break;
case 5:
data_tx_handler(custom_tx_d_buffer_5[s_cnt]);
break;
case 6:
data_tx_handler(custom_tx_d_buffer_6[s_cnt]);
break;
case 7:
data_tx_handler(custom_tx_d_buffer_7[s_cnt]);
break;
case 8:
data_tx_handler(custom_tx_d_buffer_8[s_cnt]);
break;
case 9:
data_tx_handler(custom_tx_d_buffer_9[s_cnt]);
order = 0;
custom_send_start();
#if FEATURE_PRINTF
printf("custom_send Completed\r\n");
#endif
return;
default:
break;
}
if(ble_connection_st == 0) {
custom_send_timer_stop();
order = 0;
printf("Custom ADC STOP 2\r\n");}
else{
order++;
custom_send_timer_start();
}
}
}
void custom_send_start(void)
{
s_cnt++;
if (s_cnt>c_max)
{
custom_send_timer_stop();
data_tx_handler(ble_tx_buffer);
data_tx_handler(custom_tx_buffer);
battery_timer_start();
}
else
{
custom_send_timer_start();
}
}
void custom_adc_total_start(void)
{
if (pd_adc_custom_start==true)
{
// custom_testing = false;
// motion_raw_data_enabled = true;
// custom_add_data = true;
// icm42670_main();
//
// data_tx_handler(ble_tx_buffer);
t_ms=0;
custom_testing = true;
custom_check_timer_start();
c_cnt=0;
pd_adc_custom_start=false;
pd_adc_custom_a_start=true;
custom_adc_start();
c_cnt++;
}
else if (c_cnt<c_max)
{
pd_adc_custom_a_start=true;
custom_adc_start();
c_cnt++;
}
else if (c_cnt==c_max)
{
custom_testing = false;
motion_raw_data_enabled = true;
custom_add_data = true;
icm42670_main();
if(cmd_type_t == CMD_BLE){
s_cnt=0;
custom_send_start();
}
c_cnt++;
printf ("FINISH SEND\r\n");
processing = false;
}
}
void custom_adc_start(void)
{
pd_no = -1;
led_no = -1;
buf_no = 0;
if(pd_adc_custom_a_start == true) {
#if FEATURE_PRINTF
printf("\r\n===== Custom_A start ====================\r\n");
printf("LED : ");
#endif
for(uint8_t i =0; i < CUSTOM_LED_NO; i++) {
LED_list_custom[i] = led_custom_list_a[i];
#if FEATURE_PRINTF
printf("%d ", LED_list_custom[i]);
#endif
}
#if FEATURE_PRINTF
printf("\r\n");
printf("PD : ");
#endif
for(uint8_t i =0; i < CUSTOM_PD_NO; i++) {
PD_list_custom[i] = pd_custom_list_a[i];
#if FEATURE_PRINTF
printf("%d ", PD_list_custom[i]);
#endif
}
#if FEATURE_PRINTF
printf("\r\n\r\n");
#endif
}
if(pd_adc_custom_b_start == true) {
#if FEATURE_PRINTF
printf("\r\n===== Custom_B start ====================\r\n");
printf("LED : ");
#endif
for(uint8_t i =0; i < CUSTOM_LED_NO; i++) {
LED_list_custom[i] = led_custom_list_b[i];
#if FEATURE_PRINTF
printf("%d ", LED_list_custom[i]);
#endif
}
#if FEATURE_PRINTF
printf("\r\n");
printf("PD : ");
#endif
for(uint8_t i =0; i < CUSTOM_PD_NO; i++) {
PD_list_custom[i] = pd_custom_list_b[i];
#if FEATURE_PRINTF
printf("%d ", PD_list_custom[i]);
#endif
}
#if FEATURE_PRINTF
printf("\r\n\r\n");
#endif
}
// if(pd_adc_custom_c_start == true) {
//#if FEATURE_PRINTF
// printf("\r\n===== Custom_C start ====================\r\n");
// printf("LED : ");
//#endif
// for(uint8_t i =0; i < CUSTOM_LED_NO; i++) {
// LED_list_custom[i] = led_custom_list_c[i];
//#if FEATURE_PRINTF
// printf("%d ", LED_list_custom[i]);
//#endif
// }
//
//#if FEATURE_PRINTF
// printf("\r\n");
// printf("PD : ");
//#endif
// for(uint8_t i =0; i < CUSTOM_PD_NO; i++) {
// PD_list_custom[i] = pd_custom_list_c[i];
//#if FEATURE_PRINTF
// printf("%d ", PD_list_custom[i]);
//#endif
// }
//#if FEATURE_PRINTF
// printf("\r\n\r\n");
//#endif
// }
// if(pd_adc_custom_d_start == true) {
//#if FEATURE_PRINTF
// printf("\r\n===== Custom_D start ====================\r\n");
// printf("LED : ");
//#endif
// for(uint8_t i =0; i < CUSTOM_LED_NO; i++) {
// LED_list_custom[i] = led_custom_list_d[i];
//#if FEATURE_PRINTF
// printf("%d ", LED_list_custom[i]);
//#endif
// }
//
//#if FEATURE_PRINTF
// printf("\r\n");
// printf("PD : ");
//#endif
// for(uint8_t i =0; i < CUSTOM_PD_NO; i++) {
// PD_list_custom[i] = pd_custom_list_d[i];
//#if FEATURE_PRINTF
// printf("%d ", PD_list_custom[i]);
//#endif
// }
//#if FEATURE_PRINTF
// printf("\r\n\r\n");
//#endif
// }
for(uint16_t i = 0; i < 72; i++) {
for(uint16_t j = 0; j < CUSTOM_CYCLE_CNT; j++) {
custom_cycle_buff[i][j] = 0.0f;
}
}
for(uint8_t i = 0; i < CUSTOM_LED_NO; i++) {
for(uint8_t j = 0; j < CUSTOM_PD_NO; j++) {
custom_cycle_send_buff[i][j] = 0.0f;
}
}
custom_adc_start2();
}
void custom_adc_start2(void)
{
custom_adc_init();
#if FEATURE_PRINTF
custom_timer_init();
custom_timer_start();
#else
custom_irq_init();
custom_ppi_init();
custom_sampling_event_enable();
#endif
}
void custom_adc_end(void)
{
#if FEATURE_PRINTF
printf("custom_adc_end\r\n");
custom_timer_stop();
#endif
#if !FEATURE_PRINTF
custom_sampling_event_disable();
custom_irq_uninit();
custom_ppi_uninit();
#endif
custom_adc_uninit();
}
void custom_adc_end_2(void)
{
#if FEATURE_PRINTF
printf("custom_adc_end\r\n");
custom_timer_stop();
#endif
#if !FEATURE_PRINTF
custom_sampling_event_disable();
custom_irq_uninit();
custom_ppi_uninit();
#endif
custom_adc_uninit();
}
void custom_adc_init(void)
{
#if FEATURE_PRINTF
printf("custom_adc_init\r\n");
#endif
static nrfx_saadc_config_t default_config;
default_config.resolution = (nrf_saadc_resolution_t)NRFX_SAADC_CONFIG_RESOLUTION; /* Resolution is 10bits */
default_config.oversample = (nrf_saadc_oversample_t)NRFX_SAADC_CONFIG_OVERSAMPLE; /* Over Sampling Disabled */
default_config.interrupt_priority = NRFX_SAADC_CONFIG_IRQ_PRIORITY; /* Interrupt Priority is 0(Highest) */
default_config.low_power_mode = NRFX_SAADC_CONFIG_LP_MODE; /* Low Power Mode is Disabled */
static nrf_saadc_channel_config_t config;
config.resistor_p = NRF_SAADC_RESISTOR_DISABLED;
config.resistor_n = NRF_SAADC_RESISTOR_DISABLED;
config.gain = NRF_SAADC_GAIN1_6;
config.reference = NRF_SAADC_REFERENCE_INTERNAL;
config.acq_time = NRF_SAADC_ACQTIME_3US;
config.mode = NRF_SAADC_MODE_DIFFERENTIAL;
config.burst = NRF_SAADC_BURST_DISABLED;
config.pin_p = (nrf_saadc_input_t)(NRF_SAADC_INPUT_AIN0);
config.pin_n = (nrf_saadc_input_t)(NRF_SAADC_INPUT_AIN1);
ret_code_t err_code = nrf_drv_saadc_init(&default_config, custom_voltage_handler);
APP_ERROR_CHECK(err_code);
err_code = nrf_drv_saadc_channel_init(0, &config);
APP_ERROR_CHECK(err_code);
err_code = nrf_drv_saadc_buffer_convert(pd_custom_adc_buf[0], custom_samples_in_buffer + m_config.pd_delay_us/16);
APP_ERROR_CHECK(err_code);
}
void custom_adc_uninit(void)
{
#if FEATURE_PRINTF
printf("pd_custom_adc_uninit\r\n");
#endif
nrf_drv_saadc_uninit();
nrf_drv_saadc_channel_uninit(0);
}
#if !FEATURE_PRINTF
void custom_irq_init(void)
{
ret_code_t err_code;
/* Initialize int pin */
if (!nrfx_gpiote_is_init())
{
err_code = nrfx_gpiote_init();
APP_ERROR_CHECK(err_code);
}
nrfx_gpiote_in_config_t in_config = NRFX_GPIOTE_CONFIG_IN_SENSE_LOTOHI(true);
in_config.pull = NRF_GPIO_PIN_PULLDOWN;
err_code = nrfx_gpiote_in_init(ADA2200_SYNCO_PIN, &in_config, NULL);
APP_ERROR_CHECK(err_code);
nrfx_gpiote_in_event_enable(ADA2200_SYNCO_PIN, true);
}
void custom_irq_uninit(void)
{
nrfx_gpiote_in_event_disable(ADA2200_SYNCO_PIN);
nrfx_gpiote_in_uninit(ADA2200_SYNCO_PIN);
}
#endif
void custom_send_timer_start(void)
{
APP_ERROR_CHECK(app_timer_start(m_custom_send_loop_timer_id, APP_TIMER_TICKS(CUSTOM_SEND_LOOP_INTERVAL), NULL));
}
void custom_send_timer_stop(void)
{
APP_ERROR_CHECK(app_timer_stop(m_custom_send_loop_timer_id));
}
void custom_send_timer_init(void)
{
APP_ERROR_CHECK(app_timer_create(&m_custom_send_loop_timer_id, APP_TIMER_MODE_SINGLE_SHOT, custom_send_loop));
}
void custom_check_timer_start(void)
{
APP_ERROR_CHECK(app_timer_start(m_custom_check_loop_timer_id, APP_TIMER_TICKS(CUSTOM_CHECK_LOOP_INTERVAL), NULL));
}
void custom_check_timer_stop(void)
{
APP_ERROR_CHECK(app_timer_stop(m_custom_check_loop_timer_id));
}
void custom_check_timer_init(void)
{
APP_ERROR_CHECK(app_timer_create(&m_custom_check_loop_timer_id, APP_TIMER_MODE_SINGLE_SHOT, custom_check_loop));
}

58
project/ble_peripheral/ble_app_bladder_patch/meas_pd_voltage_custom.h
View File

@@ -1,58 +0,0 @@
/*******************************************************************************
* @file meas_pd_voltage_custom.h
******************************************************************************/
#ifndef _MEAS_PD_VOLTAGE_CUSTOM_H__
#define _MEAS_PD_VOLTAGE_CUSTOM_H__
#include "sdk_common.h"
#include "nrf_drv_saadc.h"
#define ADA2200_SYNCO_PIN NRF_GPIO_PIN_MAP(0,17)
#define CUSTOM_PD_NO 4
#define CUSTOM_LED_NO 5
#define CUSTOM_CYCLE_CNT 32
void custom_ppi_init(void);
void custom_ppi_uninit(void);
void custom_sampling_event_enable(void);
void custom_sampling_event_disable(void);
/**@brief Function for handling the ADC interrupt.
*
* @details This function will fetch the conversion result from the ADC, convert the value into
* percentage and send it to peer.
*/
static void imm_voltage_handler(nrf_drv_saadc_evt_t const * p_event); /* PD Voltage reading */
void custom_adc_start(void);
void custom_adc_start2(void);
void custom_adc_total_start(void);
void custom_adc_end(void);
void custom_adc_end_2(void);
void custom_adc_init(void);
void custom_adc_uninit(void);
#if !FEATURE_PRINTF
void custom_irq_init(void);
void custom_irq_uninit(void);
#endif
void custom_send_start(void);
void custom_send_loop(void * p_context); /* For x ms */
void custom_send_timer_start(void);
void custom_send_timer_stop(void);;
void custom_send_timer_init(void);
void custom_check_loop(void * p_context);
void custom_check_timer_start(void);
void custom_check_timer_stop(void);;
void custom_check_timer_init(void);
#endif /* _MEAS_PD_VOLTAGE_CUSTOM_H__ */

944
project/ble_peripheral/ble_app_bladder_patch/meas_pd_voltage_full.c
View File

@@ -1,944 +0,0 @@
/*******************************************************************************
TEST medi50 Dec 23
******************************************************************************/
#include "sdk_common.h"
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include "nrf.h"
#include "boards.h"
#include "app_error.h"
#include "nrf_drv_saadc.h"
#include "nrfx_gpiote.h"
#include "app_timer.h"
#include "nrf_drv_timer.h"
#include "nrf_delay.h"
#include "nrf_drv_ppi.h"
#include "ada2200_spi.h"
#include "ble_nus.h"
//#include "fstorage.h"
#include "measurements.h"
#include "meas_pd_voltage_full.h"
#include "mcp4725_i2c.h"
#include "ad5272_i2c.h"
#include "main_timer.h"
#include "battery_saadc.h"
#include "main.h"
#define FULL_REF_VOLTAGE_IN_MILLIVOLTS 600.0f /**< Reference voltage (in milli volts) used by ADC while doing conversion. */
#define FULL_PRE_SCALING_COMPENSATION 6.0f /**< The ADC is configured to use VDD with 1/3 prescaling as input. And hence the result of conversion is to be multiplied by 3 to get the actual value of the battery voltage.*/
#define FULL_ADC_RES_10BITS 1024.0f /**< Maximum digital value for 10-bit ADC conversion. */
/**@brief Macro to convert the result of ADC conversion in millivolts.
*
* @param[in] ADC_VALUE ADC result.
*
* @retval Result converted to millivolts.
*/
#define FULL_VOUT_IN_MILLI_VOLTS(ADC_VALUE)\
(((((ADC_VALUE) * FULL_REF_VOLTAGE_IN_MILLIVOLTS) / FULL_ADC_RES_10BITS) * FULL_PRE_SCALING_COMPENSATION)*2)
//nrfjprog --family NRF52 --erasepag 0x27000-0xF7000
static const uint8_t pd_full_type0[1] = {0};
static const uint8_t pd_full_type1[1] = {1};
//static const uint8_t pd_full_type2[1] = {2};
//static const uint8_t led_full_list_type0[24] = {0,1,2,3,4,5,10,11,12,13,14,15,20,21,22,23,24,25,30,31,32,33,34,35};
static const uint8_t led_full_list_type0[24] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23};
//static const uint8_t led_full_list_type1[24] = {40,41,42,43,44,45,50,51,52,53,54,55,60,61,62,63,64,65,70,71,72,73,74,75};
//static const uint8_t led_full_list_type3[24] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23};
static const uint8_t led_full_list_type1[24] = {24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47};
//static const uint16_t delay_pd_led[3][50] = { {50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,500,500,500,500,500,500,500,500,500,50,50,50,50,500,500,50,50,50,50,50,50,50,50,500,50}
// ,{4000,4000,4000,4000,4000,4000,500,500,500,50,50,50,50,500,500,50,50,50,50,50,50,50,50,500,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50}
// ,{100,50,50,200,50,50,50,50,50,50,50,50,50,500,500,1000,500,50,50,50,500,50,500,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50}
// };
bool full_testing = false;
bool full_testing_result = false;
static int32_t t_ms = 0;
uint8_t full_samples_in_buffer = 8;
uint8_t add_cycle = 0;
uint8_t LED_list_full[24];
uint8_t PD_list_full[1];
//uint8_t led_full_list_a[25] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24};
uint8_t led_full_list_a[24];
uint8_t pd_full_list_a[1];
uint8_t led_full_list_b[24];
uint8_t pd_full_list_b[1];
//uint8_t led_full_list_c[25] = {25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49};
//uint8_t pd_full_list_c[1] = {2};
extern volatile uint8_t Sj_type;
extern volatile bool processing;
//static int8_t pd_no = -1;
static int8_t PD_list_full_nameA=0;
static int8_t PD_list_full_nameB=0;
static int8_t led_no = -1;
static int8_t buf_no = 0;
uint16_t buf_cnt = 0;
uint8_t full_bin_buffer[BLE_NUS_MAX_DATA_LEN];
static uint8_t order = 0;
char full_tx_buffer[BLE_NUS_MAX_DATA_LEN];
extern uint8_t ble_bin_buffer[BLE_NUS_MAX_DATA_LEN] ;
double full_cycle_buff[24][FULL_CYCLE_CNT] =
{
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //0
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //1
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //2
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //3
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //4
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //5
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //6
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //7
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //8
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //9
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //10
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //11
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //12
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //13
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //14
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //15
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //16
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //17
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //18
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //19
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //20
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //21
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //22
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //23
};
int16_t bi_full_cycle_buff[24][FULL_CYCLE_CNT] =
{
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //0
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //1
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //2
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //3
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //4
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //5
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //6
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //7
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //8
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //9
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //10
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //11
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //12
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //13
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //14
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //15
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //16
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //17
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //18
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //19
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //20
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //21
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //22
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //23
};
double full_cycle_send_buff[FULL_LED_NO] =
{
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};
int16_t bi_full_cycle_send_buff[FULL_LED_NO] =
{
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};
uint16_t bi_full_cycle_send_buff_total[48] =
{
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};
#define SAMPLES_IN_BUFFER 4095+32
static nrf_saadc_value_t pd_full_adc_buf[2][SAMPLES_IN_BUFFER];
bool pd_adc_full_a_start = false;
bool pd_adc_full_b_start = false;
bool pd_adc_full_c_start = false;
bool pd_adc_full_d_start = false;
bool pd_adc_full_end = false;
char full_tx_buffer_0[BLE_NUS_MAX_DATA_LEN];
char full_tx_buffer_1[BLE_NUS_MAX_DATA_LEN];
char full_tx_buffer_2[BLE_NUS_MAX_DATA_LEN];
char full_tx_buffer_3[BLE_NUS_MAX_DATA_LEN];
char full_tx_buffer_4[BLE_NUS_MAX_DATA_LEN];
char full_tx_buffer_5[BLE_NUS_MAX_DATA_LEN];
extern which_cmd_t cmd_type_t;
extern uint16_t m_pd_delay_us;
APP_TIMER_DEF(m_full_send_loop_timer_id);
#if FEATURE_DELAY
#define FULL_SEND_LOOP_INTERVAL 500 /* BLE Send Timer, Full_Mode Processing은 PPI로!!! */
#else
#define FULL_SEND_LOOP_INTERVAL 100
#endif
extern volatile bool ble_connection_st;
APP_TIMER_DEF(m_full_check_loop_timer_id);
#define FULL_CHECK_LOOP_INTERVAL 1
#if FEATURE_PRINTF
APP_TIMER_DEF(m_full_loop_timer_id);
#define FULL_LOOP_INTERVAL 1
void full_timer_loop(void * p_context)
{
UNUSED_PARAMETER(p_context);
ret_code_t err_code = nrf_drv_saadc_sample();
APP_ERROR_CHECK(err_code);
}
void full_timer_start(void)
{
APP_ERROR_CHECK(app_timer_start(m_full_loop_timer_id, APP_TIMER_TICKS(FULL_LOOP_INTERVAL), NULL));
}
void full_timer_stop(void)
{
APP_ERROR_CHECK(app_timer_stop(m_full_loop_timer_id));
}
void full_timer_init(void)
{
APP_ERROR_CHECK(app_timer_create(&m_full_loop_timer_id, APP_TIMER_MODE_REPEATED, full_timer_loop));
}
#else
static nrf_ppi_channel_t m_ppi_channel;
#endif
#if !FEATURE_PRINTF
void full_ppi_init(void)
{
ret_code_t err_code;
err_code = nrf_drv_ppi_init();
APP_ERROR_CHECK(err_code);
uint32_t gpiote_event_addr = nrf_drv_gpiote_in_event_addr_get(ADA2200_SYNCO_PIN);
uint32_t saadc_sample_task_addr = nrf_drv_saadc_sample_task_get();
/* setup ppi channel so that timer compare event is triggering sample task in SAADC */
err_code = nrf_drv_ppi_channel_alloc(&m_ppi_channel);
APP_ERROR_CHECK(err_code);
err_code = nrf_drv_ppi_channel_assign(m_ppi_channel,
gpiote_event_addr,
saadc_sample_task_addr);
APP_ERROR_CHECK(err_code);
}
void full_check_loop(void * p_context)
{
UNUSED_PARAMETER(p_context);
full_check_timer_stop();
if ( full_testing == false)
{
// printf("%d ms \r\n",t_ms);
// sprintf(full_tx_buffer, "Measure Time :%d ms \r\n",t_ms);
// data_tx_handler(full_tx_buffer);
}
else
{
t_ms++;
full_check_timer_start();
}
}
void full_ppi_uninit(void)
{
ret_code_t err_code;
err_code = nrf_drv_ppi_uninit();
APP_ERROR_CHECK(err_code);
}
void full_sampling_event_enable(void)
{
ret_code_t err_code = nrf_drv_ppi_channel_enable(m_ppi_channel);
APP_ERROR_CHECK(err_code);
}
void full_sampling_event_disable(void)
{
ret_code_t err_code = nrf_drv_ppi_channel_disable(m_ppi_channel);
APP_ERROR_CHECK(err_code);
}
#endif
/**@brief Function for handling the ADC interrupt.
*
* @details This function will fetch the conversion result from the ADC, convert the value into
* percentage and send it to peer.
*/
static void full_voltage_handler(nrf_drv_saadc_evt_t const * p_event) /* PD Voltage reading */
{
ret_code_t err_code;
double sum = 0.0f;
int16_t bi_sum = 0;
uint32_t full_clk_delay;
//full_clk_delay = delay_pd_led[PD_list_full[pd_no]][LED_list_full[led_no]];
//printf("index %d,%d, %d \r\n",PD_list_full[pd_no],LED_list_full[led_no],led_no);
full_clk_delay = m_pd_delay_us/16;
// printf("m: %d \r\n",full_clk_delay);
if (p_event->type == NRF_DRV_SAADC_EVT_DONE)
{
err_code = nrf_drv_saadc_buffer_convert(p_event->data.done.p_buffer, full_samples_in_buffer + full_clk_delay);
// err_code = nrf_drv_saadc_buffer_convert(p_event->data.done.p_buffer, full_samples_in_buffer );
APP_ERROR_CHECK(err_code);
//buf_cnt++;
if(led_no == -1) {
//pd_no = 0;
// printf("WHY %d\r\n",led_no);
led_no = 0;
led_on(LED_list_full[led_no]);
led_pd_matching_value_set(LED_list_full[led_no]); /* MCP4725 DAC setting and PD on */
nrf_delay_ms(5);
} else {
for(uint16_t i = full_clk_delay; i < full_clk_delay + full_samples_in_buffer; i++){
bi_full_cycle_buff[buf_no][i-full_clk_delay] =(p_event->data.done.p_buffer[i]) * 1; //-1
full_cycle_buff[buf_no][i-full_clk_delay] = (FULL_VOUT_IN_MILLI_VOLTS(p_event->data.done.p_buffer[i])) * 1; //-1
//printf("buff %d\r\n",sizeof(p_event->data.done.p_buffer));
//printf("BUFF ,%f,%f,%d,%d, %d %d\r\n", FULL_VOUT_IN_MILLI_VOLTS(p_event->data.done.p_buffer[i]),FULL_VOUT_IN_MILLI_VOLTS(p_event->data.done.p_buffer[full_clk_delay]),buf_no,i-full_clk_delay,i,full_clk_delay);
if(i-full_clk_delay ==7)
{
// nrf_delay_us(1);
// printf("\r\n");
if(buf_no==0)
{
// full_testing = false;
// printf("BUFF ,%f,%d,%d,%d, %d %d\r\n", FULL_VOUT_IN_MILLI_VOLTS(p_event->data.done.p_buffer[i]),p_event->data.done.p_buffer[i],buf_no,i-full_clk_delay,i,full_clk_delay);
}
}
}
buf_no++;
//if(pd_no >= FULL_PD_NO -1) {
//pd_no = 0;
#if FEATURE_PRINTF
printf("\r\n\r\n");
#endif
if(led_no < FULL_LED_NO-1 ) {
led_no++;
led_on(LED_list_full[led_no]);
led_pd_matching_value_set(LED_list_full[led_no]); /* MCP4725 DAC setting and PD on */
} else if(led_no >= FULL_LED_NO -1) {
//pd_no = -1;
led_no = -1;
printf("noled\r\n");
#if FEATURE_PRINTF
printf("\r\nEnded\r\n");
#endif
full_adc_end();
// uint8_t k =0;
sum = 0;
for(uint16_t i = 0; i < 24; i++){
for(uint16_t j = 0; j < full_samples_in_buffer; j++){
sum += full_cycle_buff[i][j];
}
full_cycle_send_buff[i] = sum;
sum = 0;
}
///////////////////////////////////////////////////////////////////////////////////////////
bi_sum = 0;
for(uint16_t i = 0; i < 24; i++){
for(uint16_t j = 0; j < full_samples_in_buffer; j++){
bi_sum += bi_full_cycle_buff[i][j];
}
bi_full_cycle_send_buff[i] = bi_sum;
bi_sum = 0;
}
/* Send data */
/*********************/
if(cmd_type_t == CMD_UART) {
printf("Tj%d,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf\r\n", PD_list_full[0], full_cycle_send_buff[0],full_cycle_send_buff[1],full_cycle_send_buff[2],full_cycle_send_buff[3],full_cycle_send_buff[4],full_cycle_send_buff[5],full_cycle_send_buff[6],full_cycle_send_buff[7],full_cycle_send_buff[8],full_cycle_send_buff[9],full_cycle_send_buff[10],
full_cycle_send_buff[11],full_cycle_send_buff[12],full_cycle_send_buff[13],full_cycle_send_buff[14],full_cycle_send_buff[15],full_cycle_send_buff[16],full_cycle_send_buff[17],full_cycle_send_buff[18],full_cycle_send_buff[19],full_cycle_send_buff[20],
full_cycle_send_buff[21],full_cycle_send_buff[22],full_cycle_send_buff[23]);
printf("\r\n");
} else if(cmd_type_t == CMD_BLE) {
if(pd_adc_full_a_start == true) {
for(uint8_t i=0 ; i<24 ;i++)
{
bi_full_cycle_send_buff_total[i] = (uint16_t)bi_full_cycle_send_buff[i];
}
sprintf(full_tx_buffer_0,"Tj%d,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf\r\n", PD_list_full_nameA, full_cycle_send_buff[0],full_cycle_send_buff[1],full_cycle_send_buff[2],full_cycle_send_buff[3],full_cycle_send_buff[4],full_cycle_send_buff[5],full_cycle_send_buff[6],full_cycle_send_buff[7],full_cycle_send_buff[8],full_cycle_send_buff[9],full_cycle_send_buff[10],
full_cycle_send_buff[11]);
if(Sj_type==0){
sprintf(full_tx_buffer_1,"%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%1f,\r\n", full_cycle_send_buff[12],full_cycle_send_buff[13],full_cycle_send_buff[14],full_cycle_send_buff[15],full_cycle_send_buff[16],full_cycle_send_buff[17],full_cycle_send_buff[18],full_cycle_send_buff[19],full_cycle_send_buff[20],
full_cycle_send_buff[21],full_cycle_send_buff[22],full_cycle_send_buff[23]);
}
else if(Sj_type==1){
sprintf(full_tx_buffer_1,"%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%1fend\r\n", full_cycle_send_buff[12],full_cycle_send_buff[13],full_cycle_send_buff[14],full_cycle_send_buff[15],full_cycle_send_buff[16],full_cycle_send_buff[17],full_cycle_send_buff[18],full_cycle_send_buff[19],full_cycle_send_buff[20],
full_cycle_send_buff[21],full_cycle_send_buff[22],full_cycle_send_buff[23]);
}
}
else if(pd_adc_full_b_start == true){
for(uint8_t i=0 ; i<24 ;i++)
{
bi_full_cycle_send_buff_total[i+24] = (uint16_t)bi_full_cycle_send_buff[i];
}
sprintf(full_tx_buffer_2,"Tj%d,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf\r\n", PD_list_full_nameB, full_cycle_send_buff[0],full_cycle_send_buff[1],full_cycle_send_buff[2],full_cycle_send_buff[3],full_cycle_send_buff[4],full_cycle_send_buff[5],full_cycle_send_buff[6],full_cycle_send_buff[7],full_cycle_send_buff[8],full_cycle_send_buff[9],full_cycle_send_buff[10],
full_cycle_send_buff[11]);
sprintf(full_tx_buffer_3,"%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%1fend\r\n", full_cycle_send_buff[12],full_cycle_send_buff[13],full_cycle_send_buff[14],full_cycle_send_buff[15],full_cycle_send_buff[16],full_cycle_send_buff[17],full_cycle_send_buff[18],full_cycle_send_buff[19],full_cycle_send_buff[20],
full_cycle_send_buff[21],full_cycle_send_buff[22],full_cycle_send_buff[23]);
// }else if(pd_adc_full_c_start == true) {
// sprintf(full_tx_buffer_4,"Tj%d,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf\r\n", PD_list_full[0], full_cycle_send_buff[0],full_cycle_send_buff[1],full_cycle_send_buff[2],full_cycle_send_buff[3],full_cycle_send_buff[4],full_cycle_send_buff[5],full_cycle_send_buff[6],full_cycle_send_buff[7],full_cycle_send_buff[8],full_cycle_send_buff[9],full_cycle_send_buff[10],
// full_cycle_send_buff[11]);
// sprintf(full_tx_buffer_5,"%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%1f,\t%1f\r\n", full_cycle_send_buff[12],full_cycle_send_buff[13],full_cycle_send_buff[14],full_cycle_send_buff[15],full_cycle_send_buff[16],full_cycle_send_buff[17],full_cycle_send_buff[18],full_cycle_send_buff[19],full_cycle_send_buff[20],
// full_cycle_send_buff[21],full_cycle_send_buff[22],full_cycle_send_buff[23],full_cycle_send_buff[24]);
}
/*********************/
buf_no =0;
}
if(cmd_type_t == CMD_UART) {
full_send_timer_stop();
}else if(cmd_type_t == CMD_BLE) {
printf("Send\r\n");
printf("Tj%d,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf\r\n", PD_list_full[0], full_cycle_send_buff[0],full_cycle_send_buff[1],full_cycle_send_buff[2],full_cycle_send_buff[3],full_cycle_send_buff[4],full_cycle_send_buff[5],full_cycle_send_buff[6],full_cycle_send_buff[7],full_cycle_send_buff[8],full_cycle_send_buff[9],full_cycle_send_buff[10],
full_cycle_send_buff[11],full_cycle_send_buff[12],full_cycle_send_buff[13],full_cycle_send_buff[14],full_cycle_send_buff[15],full_cycle_send_buff[16],full_cycle_send_buff[17],full_cycle_send_buff[18],full_cycle_send_buff[19],full_cycle_send_buff[20],
full_cycle_send_buff[21],full_cycle_send_buff[22],full_cycle_send_buff[23]);
printf("\r\n");
printf("Tj%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d\r\n",
PD_list_full[0],
bi_full_cycle_send_buff[0], bi_full_cycle_send_buff[1], bi_full_cycle_send_buff[2], bi_full_cycle_send_buff[3],
bi_full_cycle_send_buff[4], bi_full_cycle_send_buff[5], bi_full_cycle_send_buff[6], bi_full_cycle_send_buff[7],
bi_full_cycle_send_buff[8], bi_full_cycle_send_buff[9], bi_full_cycle_send_buff[10], bi_full_cycle_send_buff[11],
bi_full_cycle_send_buff[12], bi_full_cycle_send_buff[13], bi_full_cycle_send_buff[14], bi_full_cycle_send_buff[15],
bi_full_cycle_send_buff[16], bi_full_cycle_send_buff[17], bi_full_cycle_send_buff[18], bi_full_cycle_send_buff[19],
bi_full_cycle_send_buff[20], bi_full_cycle_send_buff[21], bi_full_cycle_send_buff[22], bi_full_cycle_send_buff[23]);
printf("\r\n");
//full_send_timer_start();
}
if(pd_adc_full_a_start == true) { // A mode
pd_adc_full_a_start = false;
// if(Sj_type == 0){
// full_adc_start();}
// else{pd_adc_full_end = true;}
if(Sj_type==0){
pd_adc_full_b_start = true;
full_adc_start();
}
else
{ pd_adc_full_b_start = false;
pd_adc_full_end = true;}
}else if(pd_adc_full_b_start == true) { // B mode
pd_adc_full_b_start = false;
pd_adc_full_end = true;
if(ble_connection_st == 1) {
battery_timer_start();
}
led_off(99);
pd_off(99);
format_data(full_bin_buffer, "rsj:", bi_full_cycle_send_buff_total, 96);
binary_tx_handler(full_bin_buffer,50);
processing = false;
}
}
// }
}
}
}
void full_send_loop(void * p_context) /* For x ms */
{
UNUSED_PARAMETER(p_context);
full_send_timer_stop();
switch(order) {
case 0:
data_tx_handler(full_tx_buffer_0);
break;
case 1:
data_tx_handler(full_tx_buffer_1);
if(Sj_type == 1)
{order = 5;
// full_testing = false;
//return;
break;}
else{
break;
}
case 2:
if(Sj_type == 0)
{data_tx_handler(full_tx_buffer_2);}
break;
case 3:
if(Sj_type == 0)
{data_tx_handler(full_tx_buffer_3);}
order = 5;
break;
// sprintf(full_tx_buffer, "Measure Time :%d ms \r\n",t_ms);
// data_tx_handler(full_tx_buffer);
//
//full_testing = false;
// return;}
case 4:
//data_tx_handler(full_tx_buffer_4);
break;
case 5:
//data_tx_handler(full_tx_buffer_5);
// order = 0;
case 6:
printf("Measure Time : %d ms \r\n",t_ms);
//sprintf(full_tx_buffer, "Measure Time :%d ms \r\n",t_ms);
// data_tx_handler(full_tx_buffer);
order = 0;
return;
#if FEATURE_PRINTF
printf("full_send Completed\r\n");
#endif
default:
break;
}
order++;
if(ble_connection_st == BLE_DISCONNECTED_ST) {
// order=0;
// full_send_timer_stop();
// printf("Full ADC STOP 2\r\n");
}
else{
full_send_timer_start();
}
}
void full_adc_start_first(uint8_t type,uint8_t PD_PICK ,uint8_t LED_PICK)
{
switch(type){
case 0:
pd_full_list_a[0] = pd_full_type0[0];
pd_full_list_b[0] = pd_full_type1[0];
PD_list_full_nameA = 0;
PD_list_full_nameB = 1;
Sj_type =0;
for (uint8_t i=0 ; i<24 ;i++)
{
led_full_list_a[i]= led_full_list_type0[i];
led_full_list_b[i]= led_full_list_type1[i];
}
break;
case 1:
pd_full_list_a[0] = pd_full_type0[0];
pd_full_list_b[0] = pd_full_type0[0];
Sj_type =1;
PD_list_full_nameA = 0;
PD_list_full_nameB = 0;
for (uint8_t i=0 ; i<24 ;i++)
{
led_full_list_a[i]= led_full_list_type1[i];
led_full_list_b[i]= led_full_list_type1[i];
}
break;
case 2:
pd_full_list_a[0] = pd_full_type1[0];
pd_full_list_b[0] = pd_full_type1[0];
Sj_type =1;
PD_list_full_nameA = 1;
PD_list_full_nameB = 1;
for (uint8_t i=0 ; i<24 ;i++)
{
led_full_list_a[i]= led_full_list_type0[i];
led_full_list_b[i]= led_full_list_type0[i];
}
break;
case 4:
pd_full_list_a[0] =PD_PICK;
pd_full_list_b[0] =PD_PICK;
Sj_type =0;
PD_list_full_nameA = PD_PICK*10;
PD_list_full_nameB = PD_PICK*10+1;
for (uint8_t i=0 ; i<24 ;i++)
{
led_full_list_a[i]= LED_PICK;
led_full_list_b[i]= LED_PICK;
}
break;
default:
pd_full_list_a[0] = pd_full_type1[0];
pd_full_list_b[0] = pd_full_type0[0];
Sj_type =0;
PD_list_full_nameA = 1;
PD_list_full_nameB = 0;
for (uint8_t i=0 ; i<24 ;i++)
{
led_full_list_a[i]= led_full_list_type0[i];
led_full_list_b[i]= led_full_list_type1[i];
}
break;
}
full_adc_start();
}
void full_adc_start()
{
t_ms=0;
full_check_timer_start();
full_testing =true;
//pd_no = 0;
led_no = -1;
buf_no = 0;
if(pd_adc_full_a_start == true) {
#if FEATURE_PRINTF
printf("\r\n===== Full_A start ====================\r\n");
printf("LED : ");
#endif
for(uint8_t i =0; i < FULL_LED_NO; i++) {
LED_list_full[i] = led_full_list_a[i];
#if FEATURE_PRINTF
printf("%d ", LED_list_full[i]);
#endif
}
#if FEATURE_PRINTF
printf("\r\n");
printf("PD : ");
#endif
// for(uint8_t i =0; i < FULL_PD_NO; i++) {
PD_list_full[0] = pd_full_list_a[0];
#if FEATURE_PRINTF
printf("%d ", PD_list_full[i]);
#endif
}
#if FEATURE_PRINTF
printf("\r\n\r\n");
#endif
// }
if(pd_adc_full_b_start == true) {
#if FEATURE_PRINTF
printf("\r\n===== Full_B start ====================\r\n");
printf("LED : ");
#endif
for(uint8_t i =0; i < FULL_LED_NO; i++) {
LED_list_full[i] = led_full_list_b[i];
#if FEATURE_PRINTF
printf("%d ", LED_list_full[i]);
#endif
}
#if FEATURE_PRINTF
printf("\r\n");
printf("PD : ");
#endif
// for(uint8_t i =0; i < FULL_PD_NO; i++) {
PD_list_full[0] = pd_full_list_b[0];
#if FEATURE_PRINTF
printf("%d ", PD_list_full[i]);
#endif
}
for(uint16_t i = 0; i < 24; i++) {
for(uint16_t j = 0; j < FULL_CYCLE_CNT; j++) {
full_cycle_buff[i][j] = 0.0f;
}
}
for(uint8_t i = 0; i < FULL_LED_NO; i++) {
full_cycle_send_buff[i] = 0.0f;
}
for(uint16_t i = 0; i < 24; i++) {
for(uint16_t j = 0; j < FULL_CYCLE_CNT; j++) {
bi_full_cycle_buff[i][j] = 0;
}
}
for(uint8_t i = 0; i < FULL_LED_NO; i++) {
bi_full_cycle_send_buff[i] = 0;
}
full_adc_start2();
order = 0;
}
void full_adc_start2(void)
{
full_adc_init();
#if FEATURE_PRINTF
full_timer_start();
#else
full_irq_init();
full_ppi_init();
full_sampling_event_enable();
#endif
}
void full_adc_end(void)
{
#if FEATURE_PRINTF
printf("full_adc_end\r\n");
full_timer_stop();
#endif
#if !FEATURE_PRINTF
full_sampling_event_disable();
full_irq_uninit();
full_ppi_uninit();
#endif
full_adc_uninit();
full_testing = false;
}
void full_adc_init(void)
{
#if FEATURE_PRINTF
printf("full_adc_init\r\n");
#endif
static nrfx_saadc_config_t default_config;
default_config.resolution = (nrf_saadc_resolution_t)NRFX_SAADC_CONFIG_RESOLUTION; /* Resolution is 10bits */
default_config.oversample = (nrf_saadc_oversample_t)NRFX_SAADC_CONFIG_OVERSAMPLE; /* Over Sampling Disabled */
default_config.interrupt_priority = NRFX_SAADC_CONFIG_IRQ_PRIORITY; /* Interrupt Priority is 0(Highest) */
default_config.low_power_mode = NRFX_SAADC_CONFIG_LP_MODE; /* Low Power Mode is Disabled */
static nrf_saadc_channel_config_t config;
config.resistor_p = NRF_SAADC_RESISTOR_DISABLED;
config.resistor_n = NRF_SAADC_RESISTOR_DISABLED;
config.gain = NRF_SAADC_GAIN1_6;
config.reference = NRF_SAADC_REFERENCE_INTERNAL;
config.acq_time = NRF_SAADC_ACQTIME_3US; //3-->20
config.mode = NRF_SAADC_MODE_DIFFERENTIAL;
config.burst = NRF_SAADC_BURST_DISABLED;
config.pin_p = (nrf_saadc_input_t)(NRF_SAADC_INPUT_AIN0);
config.pin_n = (nrf_saadc_input_t)(NRF_SAADC_INPUT_AIN1);
ret_code_t err_code = nrf_drv_saadc_init(&default_config, full_voltage_handler);
APP_ERROR_CHECK(err_code);
err_code = nrf_drv_saadc_channel_init(0, &config);
APP_ERROR_CHECK(err_code);
err_code = nrf_drv_saadc_buffer_convert(pd_full_adc_buf[0], full_samples_in_buffer + m_pd_delay_us/16);//16
APP_ERROR_CHECK(err_code);
//printf("init");
}
void full_adc_uninit(void)
{
#if FEATURE_PRINTF
printf("pd_full_adc_uninit\r\n");
#endif
nrf_drv_saadc_uninit();
nrf_drv_saadc_channel_uninit(0);
}
#if !FEATURE_PRINTF
void full_irq_init(void)
{
ret_code_t err_code;
/* Initialize int pin */
if (!nrfx_gpiote_is_init())
{
err_code = nrfx_gpiote_init();
APP_ERROR_CHECK(err_code);
}
nrfx_gpiote_in_config_t in_config = NRFX_GPIOTE_CONFIG_IN_SENSE_LOTOHI(true);
in_config.pull = NRF_GPIO_PIN_PULLDOWN;
err_code = nrfx_gpiote_in_init(ADA2200_SYNCO_PIN, &in_config, NULL);
APP_ERROR_CHECK(err_code);
nrfx_gpiote_in_event_enable(ADA2200_SYNCO_PIN, true);
}
void full_irq_uninit(void)
{
nrfx_gpiote_in_event_disable(ADA2200_SYNCO_PIN);
nrfx_gpiote_in_uninit(ADA2200_SYNCO_PIN);
}
#endif
void full_send_timer_start(void)
{
APP_ERROR_CHECK(app_timer_start(m_full_send_loop_timer_id, APP_TIMER_TICKS(FULL_SEND_LOOP_INTERVAL), NULL));
}
void full_send_timer_stop(void)
{
APP_ERROR_CHECK(app_timer_stop(m_full_send_loop_timer_id));
}
void full_send_timer_init(void)
{
APP_ERROR_CHECK(app_timer_create(&m_full_send_loop_timer_id, APP_TIMER_MODE_SINGLE_SHOT, full_send_loop));
}
void full_check_timer_start(void)
{
APP_ERROR_CHECK(app_timer_start(m_full_check_loop_timer_id, APP_TIMER_TICKS(FULL_CHECK_LOOP_INTERVAL), NULL));
}
void full_check_timer_stop(void)
{
APP_ERROR_CHECK(app_timer_stop(m_full_check_loop_timer_id));
}
void full_check_timer_init(void)
{
APP_ERROR_CHECK(app_timer_create(&m_full_check_loop_timer_id, APP_TIMER_MODE_SINGLE_SHOT, full_check_loop));
}

64
project/ble_peripheral/ble_app_bladder_patch/meas_pd_voltage_full.h
View File

@@ -1,64 +0,0 @@
/*******************************************************************************
* @file meas_pd_voltage_full.h
* @author CandyPops Co.
* @version V1.0.0
* @date 2022-09-05
* @brief
******************************************************************************/
#ifndef _MEAS_PD_VOLTAGE_FULL_H__
#define _MEAS_PD_VOLTAGE_FULL_H__
#include "sdk_common.h"
#include "nrf_drv_saadc.h"
#define ADA2200_SYNCO_PIN NRF_GPIO_PIN_MAP(0,17)
#define FULL_PD_NO 1
#define FULL_LED_NO 24
#define FULL_CYCLE_CNT 32 /* Dummy=65535/16us(Max Delay), Cycle_Max_Cnt=32*/
#if FEATURE_PRINTF
void full_timer_loop(void * p_context);
void full_timer_start(void);
void full_timer_stop(void);
void full_timer_init(void);
#endif
void full_ppi_init(void);
void full_ppi_uninit(void);
void full_sampling_event_enable(void);
void full_sampling_event_disable(void);
/**@brief Function for handling the ADC interrupt.
*
* @details This function will fetch the conversion result from the ADC, convert the value into
* percentage and send it to peer.
*/
static void full_voltage_handler(nrf_drv_saadc_evt_t const * p_event); /* PD Voltage reading */
void full_adc_start_first(uint8_t type,uint8_t PD_PICK ,uint8_t LED_PICK);
void full_adc_start(void);
void full_adc_start2(void);
void full_adc_end(void);
void full_adc_init(void);
void full_adc_uninit(void);
#if !FEATURE_PRINTF
void full_irq_init(void);
void full_irq_uninit(void);
#endif
void ble_Tx_process(void);
void full_send_loop(void * p_context); /* For x ms */
void full_send_timer_start(void);
void full_send_timer_stop(void);;
void full_send_timer_init(void);
void full_check_loop(void * p_context);
void full_check_timer_start(void);
void full_check_timer_stop(void);;
void full_check_timer_init(void);
#endif /* _MEAS_PD_VOLTAGE_FULL_H__ */

836
project/ble_peripheral/ble_app_bladder_patch/meas_pd_voltage_half.c
View File

@@ -1,836 +0,0 @@
/*******************************************************************************
TEST medi50 Dec 23
******************************************************************************/
#include "sdk_common.h"
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include "nrf.h"
#include "boards.h"
#include "app_error.h"
#include "nrf_drv_saadc.h"
#include "nrfx_gpiote.h"
#include "app_timer.h"
#include "nrf_drv_timer.h"
#include "nrf_delay.h"
#include "nrf_drv_ppi.h"
#include "ada2200_spi.h"
#include "ble_nus.h"
#include "fstorage.h"
#include "measurements.h"
#include "meas_pd_voltage_half.h"
#include "mcp4725_i2c.h"
#include "ad5272_i2c.h"
#include "main_timer.h"
#include "battery_saadc.h"
#include "main.h"
#include "power_control.h"
#define HALF_REF_VOLTAGE_IN_MILLIVOLTS 600.0f /**< Reference voltage (in milli volts) used by ADC while doing conversion. */
#define HALF_PRE_SCALING_COMPENSATION 6.0f /**< The ADC is configured to use VDD with 1/3 prescaling as input. And hence the result of conversion is to be multiplied by 3 to get the actual value of the battery voltage.*/
#define HALF_ADC_RES_10BITS 1024.0f /**< Maximum digital value for 10-bit ADC conversion. */
/**@brief Macro to convert the result of ADC conversion in millivolts.
*
* @param[in] ADC_VALUE ADC result.
*
* @retval Result converted to millivolts.
*/
#define HALF_VOUT_IN_MILLI_VOLTS(ADC_VALUE)\
(((((ADC_VALUE) * HALF_REF_VOLTAGE_IN_MILLIVOLTS) / HALF_ADC_RES_10BITS) * HALF_PRE_SCALING_COMPENSATION)*2)
uint8_t half_samples_in_buffer = 8;
uint8_t LED_list_half[6];
uint8_t PD_list_half[6];
uint8_t led_half_list_a[6] = {1,2,3,4,5,6};
uint8_t pd_half_list_a[6] = {5,6,7,8,9,10};
uint8_t led_half_list_b[6] = {7,8,9,10,11,12};
uint8_t pd_half_list_b[6] = {6,5,4,3,2,1};
uint8_t led_half_list_c[6] = {13,14,15,16,17,18};
uint8_t pd_half_list_c[6] = {15,16,17,18,19,20};
uint8_t led_half_list_d[6] = {19,20,21,22,23,24};
uint8_t pd_half_list_d[6] = {16,15,14,13,12,11};
bool prestatus;
static int8_t pd_no = -1;
static int8_t led_no = -1;
static int8_t buf_no = 0;
static uint8_t order = 0;
double half_cycle_buff[36][HALF_CYCLE_CNT] =
{
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //0
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //1
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //2
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //3
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //4
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //5
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //6
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //7
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //8
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //9
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //10
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //11
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //12
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //13
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //14
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //15
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //16
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //17
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //18
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //19
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //20
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //21
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //22
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //23
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //24
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //25
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //26
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //27
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //28
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //29
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //30
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //31
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //32
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //33
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //34
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, //35
};
double half_cycle_send_buff[HALF_LED_NO][HALF_PD_NO] =
{
{0, 0, 0, 0, 0, 0},
{0, 0, 0, 0, 0, 0},
{0, 0, 0, 0, 0, 0},
{0, 0, 0, 0, 0, 0},
{0, 0, 0, 0, 0, 0},
{0, 0, 0, 0, 0, 0}
};
#define SAMPLES_IN_BUFFER 4095+32
static nrf_saadc_value_t pd_half_adc_buf[2][SAMPLES_IN_BUFFER];
bool pd_adc_half_a_start = false;
bool pd_adc_half_b_start = false;
bool pd_adc_half_c_start = false;
bool pd_adc_half_d_start = false;
bool pd_adc_half_end = false;
char half_tx_buffer_0[BLE_NUS_MAX_DATA_LEN];
char half_tx_buffer_1[BLE_NUS_MAX_DATA_LEN];
char half_tx_buffer_2[BLE_NUS_MAX_DATA_LEN];
char half_tx_buffer_3[BLE_NUS_MAX_DATA_LEN];
char half_tx_buffer_4[BLE_NUS_MAX_DATA_LEN];
char half_tx_buffer_5[BLE_NUS_MAX_DATA_LEN];
char half_tx_buffer_6[BLE_NUS_MAX_DATA_LEN];
char half_tx_buffer_7[BLE_NUS_MAX_DATA_LEN];
char half_tx_buffer_8[BLE_NUS_MAX_DATA_LEN];
char half_tx_buffer_9[BLE_NUS_MAX_DATA_LEN];
char half_tx_buffer_10[BLE_NUS_MAX_DATA_LEN];
char half_tx_buffer_11[BLE_NUS_MAX_DATA_LEN];
char half_tx_buffer_12[BLE_NUS_MAX_DATA_LEN];
char half_tx_buffer_13[BLE_NUS_MAX_DATA_LEN];
char half_tx_buffer_14[BLE_NUS_MAX_DATA_LEN];
char half_tx_buffer_15[BLE_NUS_MAX_DATA_LEN];
char half_tx_buffer_16[BLE_NUS_MAX_DATA_LEN];
char half_tx_buffer_17[BLE_NUS_MAX_DATA_LEN];
char half_tx_buffer_18[BLE_NUS_MAX_DATA_LEN];
char half_tx_buffer_19[BLE_NUS_MAX_DATA_LEN];
char half_tx_buffer_20[BLE_NUS_MAX_DATA_LEN];
char half_tx_buffer_21[BLE_NUS_MAX_DATA_LEN];
char half_tx_buffer_22[BLE_NUS_MAX_DATA_LEN];
char half_tx_buffer_23[BLE_NUS_MAX_DATA_LEN];
extern which_cmd_t cmd_type_t;
APP_TIMER_DEF(m_half_send_loop_timer_id);
#if FEATURE_DELAY
#define HALF_SEND_LOOP_INTERVAL 500
#else
#define HALF_SEND_LOOP_INTERVAL 100
#endif
extern volatile bool ble_connection_st;
#if FEATURE_DEBUG_REPEAT_TEST
extern uint32_t rpt_cnt;
#endif
#if FEATURE_PRINTF
APP_TIMER_DEF(m_half_loop_timer_id);
#define HALF_LOOP_INTERVAL 1
void half_timer_loop(void * p_context)
{
UNUSED_PARAMETER(p_context);
ret_code_t err_code = nrf_drv_saadc_sample();
APP_ERROR_CHECK(err_code);
}
void half_timer_start(void)
{
APP_ERROR_CHECK(app_timer_start(m_half_loop_timer_id, APP_TIMER_TICKS(HALF_LOOP_INTERVAL), NULL));
}
void half_timer_stop(void)
{
APP_ERROR_CHECK(app_timer_stop(m_half_loop_timer_id));
}
void half_timer_init(void)
{
APP_ERROR_CHECK(app_timer_create(&m_half_loop_timer_id, APP_TIMER_MODE_REPEATED, half_timer_loop));
}
#else
static nrf_ppi_channel_t m_ppi_channel;
#endif
#if !FEATURE_PRINTF
void half_ppi_init(void)
{
ret_code_t err_code;
err_code = nrf_drv_ppi_init();
APP_ERROR_CHECK(err_code);
uint32_t gpiote_event_addr = nrf_drv_gpiote_in_event_addr_get(ADA2200_SYNCO_PIN);
uint32_t saadc_sample_task_addr = nrf_drv_saadc_sample_task_get();
/* setup ppi channel so that timer compare event is triggering sample task in SAADC */
err_code = nrf_drv_ppi_channel_alloc(&m_ppi_channel);
APP_ERROR_CHECK(err_code);
err_code = nrf_drv_ppi_channel_assign(m_ppi_channel,
gpiote_event_addr,
saadc_sample_task_addr);
APP_ERROR_CHECK(err_code);
}
void half_ppi_uninit(void)
{
ret_code_t err_code;
err_code = nrf_drv_ppi_uninit();
APP_ERROR_CHECK(err_code);
}
void half_sampling_event_enable(void)
{
ret_code_t err_code = nrf_drv_ppi_channel_enable(m_ppi_channel);
APP_ERROR_CHECK(err_code);
}
void half_sampling_event_disable(void)
{
ret_code_t err_code = nrf_drv_ppi_channel_disable(m_ppi_channel);
APP_ERROR_CHECK(err_code);
}
#endif
/**@brief Function for handling the ADC interrupt.
*
* @details This function will fetch the conversion result from the ADC, convert the value into
* percentage and send it to peer.
*/
static void half_voltage_handler(nrf_drv_saadc_evt_t const * p_event) /* PD Voltage reading */
{
ret_code_t err_code;
double sum = 0.0f;
uint32_t half_clk_delay = m_config.pd_delay_us/16;
if (prestatus==true)
{ half_clk_delay =10;}
if(ble_connection_st == 0) {
half_adc_end();
half_send_timer_stop();
printf("Half ADC STOP 1\r\n");
}
else{
if (p_event->type == NRF_DRV_SAADC_EVT_DONE)
{
err_code = nrf_drv_saadc_buffer_convert(p_event->data.done.p_buffer, half_samples_in_buffer + half_clk_delay);
APP_ERROR_CHECK(err_code);
if(led_no == -1) {
led_no = 0;
pd_no = 0;
led_on(LED_list_half[led_no]);
led_pd_matching_value_set(LED_list_half[led_no], PD_list_half[pd_no]); /* MCP4725 DAC setting and PD on */
} else {
#if FEATURE_FOR_SCOPE
nrf_gpio_pin_set(ADC_CLK_18);
nrf_gpio_pin_clear(ADC_CLK_18);
#endif
for(uint16_t i = half_clk_delay; i < half_clk_delay + half_samples_in_buffer; i++){
half_cycle_buff[buf_no][i-half_clk_delay] = (HALF_VOUT_IN_MILLI_VOLTS(p_event->data.done.p_buffer[i])) * -1;
}
#if FEATURE_PRINTF
printf("-----------------Read ADC // led_no = %d(%d), pd_no = %d(%d), buf_no = %d\r\n\r\n", led_no, LED_list_half[led_no], pd_no, PD_list_half[pd_no], buf_no);
#endif
buf_no++;
if(pd_no < HALF_PD_NO - 1) {
pd_no++;
led_pd_matching_value_set(LED_list_half[led_no], PD_list_half[pd_no]); /* MCP4725 DAC setting and PD on */
}else if(pd_no >= HALF_PD_NO - 1) {
pd_no = 0;
#if FEATURE_PRINTF
printf("\r\n\r\n");
#endif
if(led_no < HALF_LED_NO - 1) {
led_no++;
led_on(LED_list_half[led_no]);
led_pd_matching_value_set(LED_list_half[led_no], PD_list_half[pd_no]); /* MCP4725 DAC setting and PD on */
} else if(led_no >= HALF_LED_NO - 1) {
pd_no = -1;
led_no = -1;
#if FEATURE_PRINTF
printf("\r\nEnded\r\n");
#endif
half_adc_end();
#if FEATURE_DETAIL_VALUE_HALF
sum = 0;
printf("\r\nHalf_============half_cycle_buff =\r\n");
for(uint16_t i = 0; i < 36; i++){
for(uint16_t j = 0; j < half_samples_in_buffer; j++){
printf("%lf\r\n", half_cycle_buff[i][j]);
}
for(uint16_t k = 0; k < half_samples_in_buffer; k++){
sum += half_cycle_buff[i][k];
}
printf("\t%lf\r\n", sum);
sum = 0;
}
printf("\r\n");
#endif
///////////////////////////////////////////////////////////////////////////////////////////
uint8_t k =0;
sum = 0;
for(uint16_t i = 0; i < 36; i++){
for(uint16_t j = 0; j < half_samples_in_buffer; j++){
sum += half_cycle_buff[i][j];
}
half_cycle_send_buff[i/6][k++] = sum;
sum = 0;
if(k >= 6) k = 0;
}
///////////////////////////////////////////////////////////////////////////////////////////
/* Send data */
/*********************/
if(cmd_type_t == CMD_UART && prestatus==false) {
printf("Ti%d,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf\r\n", LED_list_half[0], half_cycle_send_buff[0][0], half_cycle_send_buff[0][1], half_cycle_send_buff[0][2], half_cycle_send_buff[0][3], half_cycle_send_buff[0][4], half_cycle_send_buff[0][5]);
printf("Ti%d,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf\r\n", LED_list_half[1], half_cycle_send_buff[1][0], half_cycle_send_buff[1][1], half_cycle_send_buff[1][2], half_cycle_send_buff[1][3], half_cycle_send_buff[1][4], half_cycle_send_buff[1][5]);
printf("Ti%d,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf\r\n", LED_list_half[2], half_cycle_send_buff[2][0], half_cycle_send_buff[2][1], half_cycle_send_buff[2][2], half_cycle_send_buff[2][3], half_cycle_send_buff[2][4], half_cycle_send_buff[2][5]);
printf("Ti%d,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf\r\n", LED_list_half[3], half_cycle_send_buff[3][0], half_cycle_send_buff[3][1], half_cycle_send_buff[3][2], half_cycle_send_buff[3][3], half_cycle_send_buff[3][4], half_cycle_send_buff[3][5]);
printf("Ti%d,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf\r\n", LED_list_half[4], half_cycle_send_buff[4][0], half_cycle_send_buff[4][1], half_cycle_send_buff[4][2], half_cycle_send_buff[4][3], half_cycle_send_buff[4][4], half_cycle_send_buff[4][5]);
printf("Ti%d,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf\r\n", LED_list_half[5], half_cycle_send_buff[5][0], half_cycle_send_buff[5][1], half_cycle_send_buff[5][2], half_cycle_send_buff[5][3], half_cycle_send_buff[5][4], half_cycle_send_buff[5][5]);
printf("\r\n");
} else if(cmd_type_t == CMD_BLE && prestatus==false) {
if(pd_adc_half_a_start == true) {
sprintf(half_tx_buffer_0, "Ti%d,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf\r\n", LED_list_half[0], half_cycle_send_buff[0][0], half_cycle_send_buff[0][1], half_cycle_send_buff[0][2], half_cycle_send_buff[0][3], half_cycle_send_buff[0][4], half_cycle_send_buff[0][5]);
sprintf(half_tx_buffer_1, "Ti%d,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf\r\n", LED_list_half[1], half_cycle_send_buff[1][0], half_cycle_send_buff[1][1], half_cycle_send_buff[1][2], half_cycle_send_buff[1][3], half_cycle_send_buff[1][4], half_cycle_send_buff[1][5]);
sprintf(half_tx_buffer_2, "Ti%d,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf\r\n", LED_list_half[2], half_cycle_send_buff[2][0], half_cycle_send_buff[2][1], half_cycle_send_buff[2][2], half_cycle_send_buff[2][3], half_cycle_send_buff[2][4], half_cycle_send_buff[2][5]);
sprintf(half_tx_buffer_3, "Ti%d,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf\r\n", LED_list_half[3], half_cycle_send_buff[3][0], half_cycle_send_buff[3][1], half_cycle_send_buff[3][2], half_cycle_send_buff[3][3], half_cycle_send_buff[3][4], half_cycle_send_buff[3][5]);
sprintf(half_tx_buffer_4, "Ti%d,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf\r\n", LED_list_half[4], half_cycle_send_buff[4][0], half_cycle_send_buff[4][1], half_cycle_send_buff[4][2], half_cycle_send_buff[4][3], half_cycle_send_buff[4][4], half_cycle_send_buff[4][5]);
sprintf(half_tx_buffer_5, "Ti%d,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf\r\n", LED_list_half[5], half_cycle_send_buff[5][0], half_cycle_send_buff[5][1], half_cycle_send_buff[5][2], half_cycle_send_buff[5][3], half_cycle_send_buff[5][4], half_cycle_send_buff[5][5]);
}else if(pd_adc_half_b_start == true) {
sprintf(half_tx_buffer_6, "Ti%d,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf\r\n", LED_list_half[0], half_cycle_send_buff[0][0], half_cycle_send_buff[0][1], half_cycle_send_buff[0][2], half_cycle_send_buff[0][3], half_cycle_send_buff[0][4], half_cycle_send_buff[0][5]);
sprintf(half_tx_buffer_7, "Ti%d,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf\r\n", LED_list_half[1], half_cycle_send_buff[1][0], half_cycle_send_buff[1][1], half_cycle_send_buff[1][2], half_cycle_send_buff[1][3], half_cycle_send_buff[1][4], half_cycle_send_buff[1][5]);
sprintf(half_tx_buffer_8, "Ti%d,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf\r\n", LED_list_half[2], half_cycle_send_buff[2][0], half_cycle_send_buff[2][1], half_cycle_send_buff[2][2], half_cycle_send_buff[2][3], half_cycle_send_buff[2][4], half_cycle_send_buff[2][5]);
sprintf(half_tx_buffer_9, "Ti%d,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf\r\n", LED_list_half[3], half_cycle_send_buff[3][0], half_cycle_send_buff[3][1], half_cycle_send_buff[3][2], half_cycle_send_buff[3][3], half_cycle_send_buff[3][4], half_cycle_send_buff[3][5]);
sprintf(half_tx_buffer_10, "Ti%d,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf\r\n", LED_list_half[4], half_cycle_send_buff[4][0], half_cycle_send_buff[4][1], half_cycle_send_buff[4][2], half_cycle_send_buff[4][3], half_cycle_send_buff[4][4], half_cycle_send_buff[4][5]);
sprintf(half_tx_buffer_11, "Ti%d,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf\r\n", LED_list_half[5], half_cycle_send_buff[5][0], half_cycle_send_buff[5][1], half_cycle_send_buff[5][2], half_cycle_send_buff[5][3], half_cycle_send_buff[5][4], half_cycle_send_buff[5][5]);
}else if(pd_adc_half_c_start == true) {
sprintf(half_tx_buffer_12, "Ti%d,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf\r\n", LED_list_half[0], half_cycle_send_buff[0][0], half_cycle_send_buff[0][1], half_cycle_send_buff[0][2], half_cycle_send_buff[0][3], half_cycle_send_buff[0][4], half_cycle_send_buff[0][5]);
sprintf(half_tx_buffer_13, "Ti%d,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf\r\n", LED_list_half[1], half_cycle_send_buff[1][0], half_cycle_send_buff[1][1], half_cycle_send_buff[1][2], half_cycle_send_buff[1][3], half_cycle_send_buff[1][4], half_cycle_send_buff[1][5]);
sprintf(half_tx_buffer_14, "Ti%d,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf\r\n", LED_list_half[2], half_cycle_send_buff[2][0], half_cycle_send_buff[2][1], half_cycle_send_buff[2][2], half_cycle_send_buff[2][3], half_cycle_send_buff[2][4], half_cycle_send_buff[2][5]);
sprintf(half_tx_buffer_15, "Ti%d,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf\r\n", LED_list_half[3], half_cycle_send_buff[3][0], half_cycle_send_buff[3][1], half_cycle_send_buff[3][2], half_cycle_send_buff[3][3], half_cycle_send_buff[3][4], half_cycle_send_buff[3][5]);
sprintf(half_tx_buffer_16, "Ti%d,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf\r\n", LED_list_half[4], half_cycle_send_buff[4][0], half_cycle_send_buff[4][1], half_cycle_send_buff[4][2], half_cycle_send_buff[4][3], half_cycle_send_buff[4][4], half_cycle_send_buff[4][5]);
sprintf(half_tx_buffer_17, "Ti%d,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf\r\n", LED_list_half[5], half_cycle_send_buff[5][0], half_cycle_send_buff[5][1], half_cycle_send_buff[5][2], half_cycle_send_buff[5][3], half_cycle_send_buff[5][4], half_cycle_send_buff[5][5]);
}else if(pd_adc_half_d_start == true) {
sprintf(half_tx_buffer_18, "Ti%d,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf\r\n", LED_list_half[0], half_cycle_send_buff[0][0], half_cycle_send_buff[0][1], half_cycle_send_buff[0][2], half_cycle_send_buff[0][3], half_cycle_send_buff[0][4], half_cycle_send_buff[0][5]);
sprintf(half_tx_buffer_19, "Ti%d,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf\r\n", LED_list_half[1], half_cycle_send_buff[1][0], half_cycle_send_buff[1][1], half_cycle_send_buff[1][2], half_cycle_send_buff[1][3], half_cycle_send_buff[1][4], half_cycle_send_buff[1][5]);
sprintf(half_tx_buffer_20, "Ti%d,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf\r\n", LED_list_half[2], half_cycle_send_buff[2][0], half_cycle_send_buff[2][1], half_cycle_send_buff[2][2], half_cycle_send_buff[2][3], half_cycle_send_buff[2][4], half_cycle_send_buff[2][5]);
sprintf(half_tx_buffer_21, "Ti%d,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf\r\n", LED_list_half[3], half_cycle_send_buff[3][0], half_cycle_send_buff[3][1], half_cycle_send_buff[3][2], half_cycle_send_buff[3][3], half_cycle_send_buff[3][4], half_cycle_send_buff[3][5]);
sprintf(half_tx_buffer_22, "Ti%d,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf\r\n", LED_list_half[4], half_cycle_send_buff[4][0], half_cycle_send_buff[4][1], half_cycle_send_buff[4][2], half_cycle_send_buff[4][3], half_cycle_send_buff[4][4], half_cycle_send_buff[4][5]);
sprintf(half_tx_buffer_23, "Ti%d,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf,\t%lf\r\n", LED_list_half[5], half_cycle_send_buff[5][0], half_cycle_send_buff[5][1], half_cycle_send_buff[5][2], half_cycle_send_buff[5][3], half_cycle_send_buff[5][4], half_cycle_send_buff[5][5]);
}
}
/*********************/
buf_no = 0;
if(ble_connection_st == 0) {
half_adc_end();
half_send_timer_stop();
printf("Half ADC STOP 1\r\n");
}
else if(pd_adc_half_a_start == true) { // B mode
pd_adc_half_a_start = false;
pd_adc_half_b_start = true;
half_adc_start();
}else if(pd_adc_half_b_start == true) { // C mode
pd_adc_half_b_start = false;
pd_adc_half_c_start = true;
half_adc_start();
}else if(pd_adc_half_c_start == true) { // D mode
pd_adc_half_c_start = false;
pd_adc_half_d_start = true;
half_adc_start();
}else if(pd_adc_half_d_start == true) { // Completed
pd_adc_half_d_start = false;
if(cmd_type_t == CMD_UART && prestatus==false) {
half_send_timer_stop();
}else if(cmd_type_t == CMD_BLE && prestatus==false) {
half_send_timer_start();
}
if(ble_connection_st == BLE_CONNECTED_ST) {
battery_timer_start();
}
led_off(99);
pd_off(99);
}
}
}
}
}
}
}
void half_send_loop(void * p_context) /* For x ms */
{
UNUSED_PARAMETER(p_context);
half_send_timer_stop();
switch(order) {
case 0:
data_tx_handler(half_tx_buffer_0);
break;
case 1:
data_tx_handler(half_tx_buffer_1);
break;
case 2:
data_tx_handler(half_tx_buffer_2);
break;
case 3:
data_tx_handler(half_tx_buffer_3);
break;
case 4:
data_tx_handler(half_tx_buffer_4);
break;
case 5:
data_tx_handler(half_tx_buffer_5);
break;
case 6:
data_tx_handler(half_tx_buffer_6);
break;
case 7:
data_tx_handler(half_tx_buffer_7);
break;
case 8:
data_tx_handler(half_tx_buffer_8);
break;
case 9:
data_tx_handler(half_tx_buffer_9);
break;
case 10:
data_tx_handler(half_tx_buffer_10);
break;
case 11:
data_tx_handler(half_tx_buffer_11);
break;
case 12:
data_tx_handler(half_tx_buffer_12);
break;
case 13:
data_tx_handler(half_tx_buffer_13);
break;
case 14:
data_tx_handler(half_tx_buffer_14);
break;
case 15:
data_tx_handler(half_tx_buffer_15);
break;
case 16:
data_tx_handler(half_tx_buffer_16);
break;
case 17:
data_tx_handler(half_tx_buffer_17);
break;
case 18:
data_tx_handler(half_tx_buffer_18);
break;
case 19:
data_tx_handler(half_tx_buffer_19);
break;
case 20:
data_tx_handler(half_tx_buffer_20);
break;
case 21:
data_tx_handler(half_tx_buffer_21);
break;
case 22:
data_tx_handler(half_tx_buffer_22);
break;
case 23:
data_tx_handler(half_tx_buffer_23);
order = 0;
#if FEATURE_PRINTF
printf("half_send Completed\r\n");
#endif
return;
default:
break;
}
order++;
if(ble_connection_st == 0) {
half_send_timer_stop();
order = 0;
printf("Half ADC STOP 2\r\n");}
else{
half_send_timer_start();
}
}
void half_adc_start(void)
{
pd_no = -1;
led_no = -1;
buf_no = 0;
if(pd_adc_half_a_start == true) {
#if FEATURE_PRINTF
printf("\r\n===== Half_A start ====================\r\n");
printf("LED : ");
#endif
for(uint8_t i =0; i < HALF_LED_NO; i++) {
LED_list_half[i] = led_half_list_a[i];
#if FEATURE_PRINTF
printf("%d ", LED_list_half[i]);
#endif
}
#if FEATURE_PRINTF
printf("\r\n");
printf("PD : ");
#endif
for(uint8_t i =0; i < HALF_PD_NO; i++) {
PD_list_half[i] = pd_half_list_a[i];
#if FEATURE_PRINTF
printf("%d ", PD_list_half[i]);
#endif
}
#if FEATURE_PRINTF
printf("\r\n\r\n");
#endif
}
if(pd_adc_half_b_start == true) {
#if FEATURE_PRINTF
printf("\r\n===== Half_B start ====================\r\n");
printf("LED : ");
#endif
for(uint8_t i =0; i < HALF_LED_NO; i++) {
LED_list_half[i] = led_half_list_b[i];
#if FEATURE_PRINTF
printf("%d ", LED_list_half[i]);
#endif
}
#if FEATURE_PRINTF
printf("\r\n");
printf("PD : ");
#endif
for(uint8_t i =0; i < HALF_PD_NO; i++) {
PD_list_half[i] = pd_half_list_b[i];
#if FEATURE_PRINTF
printf("%d ", PD_list_half[i]);
#endif
}
#if FEATURE_PRINTF
printf("\r\n\r\n");
#endif
}
if(pd_adc_half_c_start == true) {
#if FEATURE_PRINTF
printf("\r\n===== Half_C start ====================\r\n");
printf("LED : ");
#endif
for(uint8_t i =0; i < HALF_LED_NO; i++) {
LED_list_half[i] = led_half_list_c[i];
#if FEATURE_PRINTF
printf("%d ", LED_list_half[i]);
#endif
}
#if FEATURE_PRINTF
printf("\r\n");
printf("PD : ");
#endif
for(uint8_t i =0; i < HALF_PD_NO; i++) {
PD_list_half[i] = pd_half_list_c[i];
#if FEATURE_PRINTF
printf("%d ", PD_list_half[i]);
#endif
}
#if FEATURE_PRINTF
printf("\r\n\r\n");
#endif
}
if(pd_adc_half_d_start == true) {
#if FEATURE_PRINTF
printf("\r\n===== Half_D start ====================\r\n");
printf("LED : ");
#endif
for(uint8_t i =0; i < HALF_LED_NO; i++) {
LED_list_half[i] = led_half_list_d[i];
#if FEATURE_PRINTF
printf("%d ", LED_list_half[i]);
#endif
}
#if FEATURE_PRINTF
printf("\r\n");
printf("PD : ");
#endif
for(uint8_t i =0; i < HALF_PD_NO; i++) {
PD_list_half[i] = pd_half_list_d[i];
#if FEATURE_PRINTF
printf("%d ", PD_list_half[i]);
#endif
}
#if FEATURE_PRINTF
printf("\r\n\r\n");
#endif
}
for(uint16_t i = 0; i < 72; i++) {
for(uint16_t j = 0; j < HALF_CYCLE_CNT; j++) {
half_cycle_buff[i][j] = 0.0f;
}
}
for(uint8_t i = 0; i < HALF_LED_NO; i++) {
for(uint8_t j = 0; j < HALF_PD_NO; j++) {
half_cycle_send_buff[i][j] = 0.0f;
}
}
half_adc_start2();
order =0;
}
void half_adc_start2(void)
{
half_adc_init();
#if FEATURE_PRINTF
half_timer_init();
half_timer_start();
#else
half_irq_init();
half_ppi_init();
half_sampling_event_enable();
//ada2200_start();
#endif
}
void half_adc_end(void)
{
#if FEATURE_PRINTF
printf("half_adc_end\r\n");
half_timer_stop();
#endif
#if !FEATURE_PRINTF
half_sampling_event_disable();
half_irq_uninit();
half_ppi_uninit();
#endif
half_adc_uninit();
//ada2200_stop();
nrf_delay_ms(5);
if(prestatus == true){
printf("1st\r\n");
if(device_activated() == 0)
{printf("2nd\r\n");
}
}
}
void half_adc_init(void)
{
#if FEATURE_PRINTF
printf("half_adc_init\r\n");
#endif
static nrfx_saadc_config_t default_config;
default_config.resolution = (nrf_saadc_resolution_t)NRFX_SAADC_CONFIG_RESOLUTION; /* Resolution is 10bits */
default_config.oversample = (nrf_saadc_oversample_t)NRFX_SAADC_CONFIG_OVERSAMPLE; /* Over Sampling Disabled */
default_config.interrupt_priority = NRFX_SAADC_CONFIG_IRQ_PRIORITY; /* Interrupt Priority is 0(Highest) */
default_config.low_power_mode = NRFX_SAADC_CONFIG_LP_MODE; /* Low Power Mode is Disabled */
static nrf_saadc_channel_config_t config;
config.resistor_p = NRF_SAADC_RESISTOR_DISABLED;
config.resistor_n = NRF_SAADC_RESISTOR_DISABLED;
config.gain = NRF_SAADC_GAIN1_6;
config.reference = NRF_SAADC_REFERENCE_INTERNAL;
config.acq_time = NRF_SAADC_ACQTIME_3US;
config.mode = NRF_SAADC_MODE_DIFFERENTIAL;
config.burst = NRF_SAADC_BURST_DISABLED;
config.pin_p = (nrf_saadc_input_t)(NRF_SAADC_INPUT_AIN0);
config.pin_n = (nrf_saadc_input_t)(NRF_SAADC_INPUT_AIN1);
ret_code_t err_code = nrf_drv_saadc_init(&default_config, half_voltage_handler);
APP_ERROR_CHECK(err_code);
err_code = nrf_drv_saadc_channel_init(0, &config);
APP_ERROR_CHECK(err_code);
if (prestatus==true)
{
err_code = nrf_drv_saadc_buffer_convert(pd_half_adc_buf[0], half_samples_in_buffer + 10);
}
else
{
err_code = nrf_drv_saadc_buffer_convert(pd_half_adc_buf[0], half_samples_in_buffer + m_config.pd_delay_us/16);
}
APP_ERROR_CHECK(err_code);
}
void half_adc_uninit(void)
{
#if FEATURE_PRINTF
printf("pd_half_adc_uninit\r\n");
#endif
nrf_drv_saadc_uninit();
nrf_drv_saadc_channel_uninit(0);
}
#if !FEATURE_PRINTF
void half_irq_init(void)
{
ret_code_t err_code;
/* Initialize int pin */
if (!nrfx_gpiote_is_init())
{
err_code = nrfx_gpiote_init();
APP_ERROR_CHECK(err_code);
}
nrfx_gpiote_in_config_t in_config = NRFX_GPIOTE_CONFIG_IN_SENSE_LOTOHI(true);
in_config.pull = NRF_GPIO_PIN_PULLDOWN;
err_code = nrfx_gpiote_in_init(ADA2200_SYNCO_PIN, &in_config, NULL);
APP_ERROR_CHECK(err_code);
nrfx_gpiote_in_event_enable(ADA2200_SYNCO_PIN, true);
}
void half_irq_uninit(void)
{
nrfx_gpiote_in_event_disable(ADA2200_SYNCO_PIN);
nrfx_gpiote_in_uninit(ADA2200_SYNCO_PIN);
}
#endif
void half_send_timer_start(void)
{
APP_ERROR_CHECK(app_timer_start(m_half_send_loop_timer_id, APP_TIMER_TICKS(HALF_SEND_LOOP_INTERVAL), NULL));
}
void half_send_timer_stop(void)
{
APP_ERROR_CHECK(app_timer_stop(m_half_send_loop_timer_id));
}
void half_send_timer_init(void)
{
APP_ERROR_CHECK(app_timer_create(&m_half_send_loop_timer_id, APP_TIMER_MODE_SINGLE_SHOT, half_send_loop));
}

49
project/ble_peripheral/ble_app_bladder_patch/meas_pd_voltage_half.h
View File

@@ -1,49 +0,0 @@
/*******************************************************************************
* @file meas_pd_voltage_half.h
* @author CandyPops Co.
* @version V1.0.0
* @date 2022-09-05
* @brief
******************************************************************************/
#ifndef _MEAS_PD_VOLTAGE_HALF_H__
#define _MEAS_PD_VOLTAGE_HALF_H__
#include "sdk_common.h"
#include "nrf_drv_saadc.h"
#define ADA2200_SYNCO_PIN NRF_GPIO_PIN_MAP(0,17)
#define HALF_PD_NO 6
#define HALF_LED_NO 6
#define HALF_CYCLE_CNT 32
void half_ppi_init(void);
void half_ppi_uninit(void);
void half_sampling_event_enable(void);
void half_sampling_event_disable(void);
/**@brief Function for handling the ADC interrupt.
*
* @details This function will fetch the conversion result from the ADC, convert the value into
* percentage and send it to peer.
*/
static void half_voltage_handler(nrf_drv_saadc_evt_t const * p_event); /* PD Voltage reading */
void half_adc_start(void);
void half_adc_start2(void);
void half_adc_end(void);
void half_adc_init(void);
void half_adc_uninit(void);
#if !FEATURE_PRINTF
void half_irq_init(void);
void half_irq_uninit(void);
#endif
void half_send_loop(void * p_context); /* For x ms */
void half_send_timer_start(void);
void half_send_timer_stop(void);;
void half_send_timer_init(void);
#endif /* _MEAS_PD_VOLTAGE_HALF_H__ */

421
project/ble_peripheral/ble_app_bladder_patch/meas_pd_voltage_simple.c
View File

@@ -1,421 +0,0 @@
/*******************************************************************************
TEST medi50 Dec 23
if(resetCount>=3) return true; 3 COUNT 25/11/04 CJ CHUN
******************************************************************************/
#include "sdk_common.h"
#include <stdlib.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include "nrf.h"
#include "boards.h"
#include "app_error.h"
#include "nrf_drv_saadc.h"
#include "app_timer.h"
#include "nrfx_gpiote.h"
#include "nrf_drv_gpiote.h"
#include "nrf_drv_ppi.h"
#include "nrf_drv_timer.h"
#include "nrf_delay.h"
#include "ada2200_spi.h"
#include "battery_saadc.h"
#include "ble_nus.h"
#include "meas_pd_voltage_simple.h"
#include "main.h"
#include <cmd_parse.h>
//#include "fstorage.h"
#include "power_control.h"
#include "debug_print.h"
#define PD_REF_VOLTAGE_IN_MILLIVOLTS 600.0f /**< Reference voltage (in milli volts) used by ADC while doing conversion. */
#define PD_PRE_SCALING_COMPENSATION 6.0f /**< The ADC is configured to use VDD with 1/3 prescaling as input. And hence the result of conversion is to be multiplied by 3 to get the actual value of the battery voltage.*/
#define PD_ADC_RES_10BITS 1023.0f /**< Maximum digital value for 10-bit ADC conversion. */
// remark for avoid warning error
// static nrf_saadc_value_t pressure_adc_buf[2]; // chanul 2ea for simple each 1ea
/**@brief Macro to convert the result of ADC conversion in millivolts.
*
* @param[in] ADC_VALUE ADC result.
*
* @retval Result converted to millivolts.
*/
#define PD_VOUT_IN_MILLI_VOLTS(ADC_VALUE)\
(((((ADC_VALUE) * PD_REF_VOLTAGE_IN_MILLIVOLTS) / PD_ADC_RES_10BITS) * PD_PRE_SCALING_COMPENSATION)*2)
#define SIM_SAMPLES_IN_BUFFER 128
static nrf_saadc_value_t pd_adc_buf[2][SIM_SAMPLES_IN_BUFFER];
uint8_t simple_samples_in_buffer = 8;
#define SAMPLE_CYCLE_CNT 128
float simple_cycle_buff[SAMPLE_CYCLE_CNT]; /* For Cycle-8, Cycle-16, Cycle-24, Cycle-32 */
float simple_cycle_send_buff = 0.0f;
int16_t bi_simple_cycle_buff[SAMPLE_CYCLE_CNT];
uint16_t ubi_simple_cycle_buff[SAMPLE_CYCLE_CNT];/* For Cycle-8, Cycle-16, Cycle-24, Cycle-32 */
int16_t bi_simple_cycle_send_buff = 0;
extern uint8_t ble_bin_buffer[BLE_NUS_MAX_DATA_LEN] ;
static nrf_ppi_channel_t m_ppi_channel;
extern uint8_t m_pd_adc_cnt;
extern char ble_tx_buffer[BLE_NUS_MAX_DATA_LEN];
extern bool lock_check;
extern which_cmd_t cmd_type_t;
#if FEATURE_CHAMBER_AUTO_TEST
extern auto_meas_mode_t auto_test_mode;
#endif
extern volatile bool ble_connection_st;
extern bool ble_got_new_data;
bool con_single;
uint8_t rep = 0;
extern uint8_t resetCount; //cj add
//APP_TIMER_DEF(m_simple_send_loop_timer_id);
//#define SIMPLE_SEND_LOOP_INTERVAL 100
#define PATTERN_LENGTH 8
#define NORMAL_AMPLITUDE_THRESHOLD 40 // values above ~50 in magnitude are normal
bool is_lockin_pattern(int16_t *pattern, uint8_t length) {
int16_t avg_amplitude = 0;
uint8_t positive_count = 0;
uint8_t negative_count = 0;
// Calculate average amplitude and count positives/negatives
for (uint8_t i = 0; i < length; i++) {
int16_t value = pattern[i];
avg_amplitude += abs(value);
if (value >= 0) {
positive_count++;
} else {
negative_count++;
}
}
avg_amplitude /= length;
DBG_PRINTF("lock avg amplitude=%d,p_c=%d,n_c=%d\r\n\r\n", avg_amplitude,positive_count,negative_count);
// Check conditions:
// - Large enough average amplitude
// - Exactly 1 positive and (length - 1) negative values
if(resetCount>=3) return true;
if (avg_amplitude > NORMAL_AMPLITUDE_THRESHOLD &&
positive_count == 1 && negative_count == (length - 1)) {
return true; // lock-in (normal) pattern
} else {
return false; // abnormal pattern
}
}
void simple_ppi_init(void)
{
ret_code_t err_code;
err_code = nrf_drv_ppi_init();
APP_ERROR_CHECK(err_code);
uint32_t gpiote_event_addr = nrf_drv_gpiote_in_event_addr_get(ADA2200_SYNCO_PIN);
uint32_t saadc_sample_task_addr = nrf_drv_saadc_sample_task_get();
/* setup ppi channel so that timer compare event is triggering sample task in SAADC */
err_code = nrf_drv_ppi_channel_alloc(&m_ppi_channel);
APP_ERROR_CHECK(err_code);
err_code = nrf_drv_ppi_channel_assign(m_ppi_channel,
gpiote_event_addr,
saadc_sample_task_addr);
APP_ERROR_CHECK(err_code);
}
void simple_ppi_uninit(void)
{
ret_code_t err_code;
err_code = nrf_drv_ppi_uninit();
APP_ERROR_CHECK(err_code);
}
void simple_sampling_event_enable(void)
{
ret_code_t err_code = nrf_drv_ppi_channel_enable(m_ppi_channel);
APP_ERROR_CHECK(err_code);
}
void simple_sampling_event_disable(void)
{
ret_code_t err_code = nrf_drv_ppi_channel_disable(m_ppi_channel);
APP_ERROR_CHECK(err_code);
}
/**@brief Function for handling the ADC interrupt.
*
* @details This function will fetch the conversion result from the ADC, convert the value into
* percentage and send it to peer.
*/
static void simple_voltage_handler(nrf_drv_saadc_evt_t const * p_event)
{
ret_code_t err_code;
if (p_event->type == NRF_DRV_SAADC_EVT_DONE)
{
// ? ??? ??
err_code = nrf_drv_saadc_buffer_convert(p_event->data.done.p_buffer, simple_samples_in_buffer);
APP_ERROR_CHECK(err_code);
for(uint8_t i = 0; i < simple_samples_in_buffer; i++) {
bi_simple_cycle_buff[i] = p_event->data.done.p_buffer[i];
}
simple_mesurement_stop();
simple_cycle_send_buff = 0;
bi_simple_cycle_send_buff = 0;
for(uint8_t i = 0; i < simple_samples_in_buffer; i++) {
simple_cycle_buff[i] = PD_VOUT_IN_MILLI_VOLTS(bi_simple_cycle_buff[i]);
bi_simple_cycle_send_buff += bi_simple_cycle_buff[i];
simple_cycle_send_buff += simple_cycle_buff[i];
}
// ? BLE ?? (if? ??? ??!)
if(cmd_type_t == CMD_UART) {
DBG_PRINTF("Th%f\r\n\r\n", simple_cycle_send_buff);
DBG_PRINTF("MOD: %f,%f,%f,%f,%f,%f,%f,%f\r\n",
simple_cycle_buff[0], simple_cycle_buff[1],
simple_cycle_buff[2], simple_cycle_buff[3],
simple_cycle_buff[4], simple_cycle_buff[5],
simple_cycle_buff[6], simple_cycle_buff[7]);
} else if(cmd_type_t == CMD_BLE) {
DBG_PRINTF("Th%f\r\n\r\n", simple_cycle_send_buff);
DBG_PRINTF("MOD: %f,%f,%f,%f,%f,%f,%f,%f\r\n",
simple_cycle_buff[0], simple_cycle_buff[1],
simple_cycle_buff[2], simple_cycle_buff[3],
simple_cycle_buff[4], simple_cycle_buff[5],
simple_cycle_buff[6], simple_cycle_buff[7]);
// ? BLE ??
for(uint8_t i = 0; i < simple_samples_in_buffer; i++) {
ubi_simple_cycle_buff[i] = (uint16_t)bi_simple_cycle_buff[i];
}
format_data(ble_bin_buffer, "rsh:", ubi_simple_cycle_buff, (m_pd_adc_cnt*2));
binary_tx_handler(ble_bin_buffer, (m_pd_adc_cnt+2));
}
// ? Lock-in ?? ??
if (lock_check == true) {
if (is_lockin_pattern(bi_simple_cycle_buff, 8) == false) {
if(device_reactivated() == 0) {
DBG_PRINTF("reset!!\r\n");
}
}
resetCount++;
DBG_PRINTF("Reset Count :%d\r\n", resetCount);
}
} // ? if (NRF_DRV_SAADC_EVT_DONE) ??? ??
}
/*
static void simple_voltage_handler(nrf_drv_saadc_evt_t const * p_event)
{
ret_code_t err_code;
if (p_event->type == NRF_DRV_SAADC_EVT_DONE)
{
err_code = nrf_drv_saadc_buffer_convert(p_event->data.done.p_buffer, simple_samples_in_buffer);
APP_ERROR_CHECK(err_code);
for(uint8_t i = 0; i < simple_samples_in_buffer; i++) {
bi_simple_cycle_buff[i] = p_event->data.done.p_buffer[i];
}
simple_mesurement_stop();
simple_cycle_send_buff = 0;
bi_simple_cycle_send_buff = 0;
for(uint8_t i = 0; i < simple_samples_in_buffer; i++) {
simple_cycle_buff[i] = PD_VOUT_IN_MILLI_VOLTS(bi_simple_cycle_buff[i]);
//simple_cycle_buff[i] = simple_cycle_buff[i] * -1;
bi_simple_cycle_send_buff += bi_simple_cycle_buff[i];
simple_cycle_send_buff += simple_cycle_buff[i];
}
}
if(con_single==true)
{
//return;
}
else
{
if(cmd_type_t == CMD_UART) {
DBG_PRINTF("Th%f\r\n\r\n", simple_cycle_send_buff);
DBG_PRINTF( "MOD: %f,%f,%f,%f,%f,%f,%f,%f\r\n", simple_cycle_buff[0], simple_cycle_buff[1], simple_cycle_buff[2], simple_cycle_buff[3], simple_cycle_buff[4]
, simple_cycle_buff[5], simple_cycle_buff[6], simple_cycle_buff[7]);
} else if(cmd_type_t == CMD_BLE) {
// if(lock_check == true){
DBG_PRINTF("Th%f\r\n\r\n", simple_cycle_send_buff);
DBG_PRINTF( "MOD: %f,%f,%f,%f,%f,%f,%f,%f\r\n", simple_cycle_buff[0], simple_cycle_buff[1], simple_cycle_buff[2], simple_cycle_buff[3], simple_cycle_buff[4]
, simple_cycle_buff[5], simple_cycle_buff[6], simple_cycle_buff[7]);
for(uint8_t i = 0; i < simple_samples_in_buffer; i++) {
ubi_simple_cycle_buff[i] = (uint16_t)bi_simple_cycle_buff[i];
}
format_data(ble_bin_buffer, "rsh:", ubi_simple_cycle_buff, (m_pd_adc_cnt*2));
binary_tx_handler(ble_bin_buffer,(m_pd_adc_cnt+2));
}
}
if (lock_check == true) {
if (is_lockin_pattern(bi_simple_cycle_buff,8) == false){
if(device_reactivated() == 0)
{
DBG_PRINTF("reset!!\r\n");
}
}
resetCount++;
DBG_PRINTF("Reset Count :%d \r\n",resetCount);
}
else
{
}
}
*/
void simple_adc_init(void)
{
static nrfx_saadc_config_t default_config;
default_config.resolution = (nrf_saadc_resolution_t)NRFX_SAADC_CONFIG_RESOLUTION; /* Resolution is 10bits */
default_config.oversample = (nrf_saadc_oversample_t)NRFX_SAADC_CONFIG_OVERSAMPLE; /* Over Sampling Disabled */
default_config.interrupt_priority = NRFX_SAADC_CONFIG_IRQ_PRIORITY; /* Interrupt Priority is 0(Highest) */
default_config.low_power_mode = NRFX_SAADC_CONFIG_LP_MODE; /* Low Power Mode is Disabled */
static nrf_saadc_channel_config_t config;
config.resistor_p = NRF_SAADC_RESISTOR_DISABLED;
config.resistor_n = NRF_SAADC_RESISTOR_DISABLED;
config.gain = NRF_SAADC_GAIN1_6;
config.reference = NRF_SAADC_REFERENCE_INTERNAL;
config.acq_time = NRF_SAADC_ACQTIME_3US;
config.mode = NRF_SAADC_MODE_DIFFERENTIAL;
config.burst = NRF_SAADC_BURST_DISABLED;
config.pin_p = (nrf_saadc_input_t)(NRF_SAADC_INPUT_AIN0);
config.pin_n = (nrf_saadc_input_t)(NRF_SAADC_INPUT_AIN1);
ret_code_t err_code = nrf_drv_saadc_init(&default_config, simple_voltage_handler);
APP_ERROR_CHECK(err_code);
err_code = nrf_drv_saadc_channel_init(0, &config);
APP_ERROR_CHECK(err_code);
if(con_single==true){
err_code = nrf_drv_saadc_buffer_convert(pd_adc_buf[0], SIM_SAMPLES_IN_BUFFER);
APP_ERROR_CHECK(err_code);
}
else{
err_code = nrf_drv_saadc_buffer_convert(pd_adc_buf[0], simple_samples_in_buffer);
APP_ERROR_CHECK(err_code);
}
}
void simple_adc_uninit(void)
{
nrf_drv_saadc_uninit();
nrf_drv_saadc_channel_uninit(0);
}
void simple_irq_init(void){
ret_code_t err_code;
/* Initialize int pin */
if (!nrfx_gpiote_is_init())
{
err_code = nrfx_gpiote_init();
APP_ERROR_CHECK(err_code);
}
nrfx_gpiote_in_config_t in_config = NRFX_GPIOTE_CONFIG_IN_SENSE_LOTOHI(true);
in_config.pull = NRF_GPIO_PIN_PULLDOWN;
err_code = nrfx_gpiote_in_init(ADA2200_SYNCO_PIN, &in_config, NULL);
APP_ERROR_CHECK(err_code);
nrfx_gpiote_in_event_enable(ADA2200_SYNCO_PIN, true);
}
void simple_irq_uninit(void){
nrfx_gpiote_in_event_disable(ADA2200_SYNCO_PIN);
nrfx_gpiote_in_uninit(ADA2200_SYNCO_PIN);
}
void simple_mesurement_start(void){
battery_timer_stop();
nrf_delay_ms(10);
memset(simple_cycle_buff, 0, SAMPLE_CYCLE_CNT);
nrf_delay_ms(10);
simple_irq_init();
nrf_delay_ms(10);
simple_adc_init();
nrf_delay_ms(10);
simple_ppi_init();
nrf_delay_ms(10);
simple_sampling_event_enable();
nrf_delay_ms(10);
}
void simple_mesurement_stop(void){
if(ble_connection_st == 1) {
battery_timer_start();
}
simple_sampling_event_disable();
simple_adc_uninit();
simple_ppi_uninit();
simple_irq_uninit();
}

34
project/ble_peripheral/ble_app_bladder_patch/meas_pd_voltage_simple.h
View File

@@ -1,34 +0,0 @@
/*******************************************************************************
* @file meas_pd_voltage_simple.h
* @author CandyPops Co.
* @version V1.0.0
* @date 2022-09-05
* @brief
******************************************************************************/
#ifndef _MEAS_PD_VOLTAGE_SIMPLE_H__
#define _MEAS_PD_VOLTAGE_SIMPLE_H__
#include "sdk_common.h"
#define ADA2200_SYNCO_PIN NRF_GPIO_PIN_MAP(0,17)
void simple_ppi_init(void);
void simple_ppi_uninit(void);
void simple_sampling_event_enable(void);
void simple_sampling_event_disable(void);
void simple_adc_init(void);
void simple_adc_uninit(void);
void simple_irq_init(void);
void simple_irq_uninit(void);
void simple_mesurement_start(void);
void simple_mesurement_stop(void);
void simple_send_loop(void * p_context); /* For x ms */
void simple_send_timer_start(void);
void simple_send_timer_stop(void);;
void simple_send_timer_init(void);
#endif /* _MEAS_PD_VOLTAGE_SIMPLE_H__ */

867
project/ble_peripheral/ble_app_bladder_patch/measurements.c
View File

@@ -1,867 +0,0 @@
/*******************************************************************************
* @file measurements.c
* @author CandyPops Co.
* @version V1.0.0
* @date 2022-09-05
* @brief
******************************************************************************/
#include "sdk_common.h"
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include "nrf.h"
#include "nrf_drv_gpiote.h"
#include "nrf_drv_spi.h"
#include "nrf_drv_saadc.h"
#include "nrf_drv_ppi.h"
#include "nrf_drv_timer.h"
#include "boards.h"
#include "bsp.h"
#include "app_error.h"
#include "nrf_delay.h"
#include "app_util_platform.h"
#include "nrf_pwr_mgmt.h"
#include "nrf_log.h"
#include "ble_nus.h"
#include "LED_Parse.h"
#include "app_timer.h"
#include "measurements.h"
#include "main.h"
//#include "fstorage.h"
#include "ad5272_i2c.h"
#include "mcp4725_i2c.h"
#include <cmd_parse.h>
#include "debug_print.h"
#include "i2c_manager.h"
//#define trig_18 NRF_GPIO_PIN_MAP(0,18)
//#define tris_18_CONFIG() nrf_gpio_cfg_output(trig_18)
//#define trig_on() nrf_gpio_pin_set(trig_18)
//#define trig_off() nrf_gpio_pin_clear(trig_18)
#define LED_NUM 24 //
uint8_t activated_led = 99;
uint8_t activated_pd = 99;
APP_TIMER_DEF(m_mea_send_loop_timer_id);
static uint8_t cnt =0;
#define MEA_SEND_LOOP_INTERVAL 100
char mea_tx_buffer[BLE_NUS_MAX_DATA_LEN];
extern volatile bool processing;
/* Default Value before initialized. Set value for Default!!! */ /* 초기값 설정 */
/* 0번은 사용하지 않음 = NULL, 1 ~ 24까지 사용 */
/*AD5272 DP에 쓸수 있는 값 범위는 0 ~ 1023 */
//uint16_t led_power_dp[LED_NUM] = {
//
// 0,25,25,18,19,24,24,25,25,18,19,25,23,25,25,18,19,24,24,25,25,19,20,25
//};
//uint16_t led_power_dp[48] =
// {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47};
//
/*LED0 = NULL 사용하지 않음, LED1, LED2, LED3, LED4, LED5, LED6, LED7, LED8, LED9, LED10, LED11, LED12, LED13, LED14, LED15, LED16, LED17, LED18, LED19, LED20, LED21, LED22, LED23, LED24 */
/*MCP4725 를 0.1V(125) ~ 1.1V(1366) 값을 사용 */
//uint16_t led_pd_dac_v[LED_NUM] =
// {1000, 1000, 1000, 1000, 1000, 1000, 1000,1000, 1000, 1000, 1000, 1000, 1000, 1000,1000, 1000, 1000, 1000, 1000, 1000, 1000,1000, 1000, 1000, /* PD0 */
// 1000, 1000, 1000, 1000, 1000, 1000, 1000,1000, 1000, 1000, 1000, 1000, 1000, 1000,1000, 1000, 1000, 1000, 1000, 1000, 1000,1000, 1000, 1000}; /* PD1 */
//
uint16_t led_pd_dac_v[LED_NUM] =
{1000, 1000, 1000, 1000, 1000, 1000, 1000,1000, 1000, 1000, 1000, 1000, 1000, 1000,1000, 1000, 1000, 1000, 1000, 1000, 1000,1000, 1000, 1000}; /* PD0 */ // 48 에서 24 변경 cj chun
uint16_t led_off_dac_v =1360;
uint8_t led_off_pd = 0;
/*ello Annapalu
As Wojtek already stated you cannot use the nrf_gpio_pin_read to read a pin set as an output. If you look at figure 21, page 112 in the nRF52832 product specification you can see the PIN(0).IN register, it is this register that is read by the gpio_pin_read function. When a pin is set as an output the PIN(0).CNF.DIR switch will close on the output side and open on the input side, meaning it is physically impossible to read the actual output value of the pin with the input register.
Wojtek is also correct that the NRF_GPIO->OUT only shows whether you have set the register, and not the actual pin state.
To achieve what you want you could connect a second GPIO, configured as an input, to the same circuit. This would tell you whether the voltage is high or low.
If you need to see a more accurate reading of the voltage level, to detect deviation, you could use the ADC or Comparator.
EDIT: 23.03.17 14:40
I have looked further into this and it seems I was a bit hasty in my reply. The product specification shows the control signal of the two above mentioned switches are different. PIN(0).CNF.DIR for the output and PIN(0).CNF.INPUT for the input buffer.So it seems it is possible to read the output value (high or low) of an output pin using the nrf_gpio_pin_read function, if you both set the direction of the pin to output, and connect the input buffer. This can be done with the nrf_gpio_cfg() function. Note that the nrf_gpio_cfg_output() function disconnects the input buffer.
I have tested it on the PCA10040 both with a led toggling based on it's own pin_read value, and with 4 leds switching based on the input value of one of the other led pins, all are configured as outputs.
*/
void led_pd_gain_array_printout(void)
{
cnt=0;
mea_send_timer_start();
}
void mea_send_loop(void * p_context) /* For x ms */
{
UNUSED_PARAMETER(p_context);
DBG_PRINTF("\r\n1CNT =%d\r\n",cnt);
mea_send_timer_stop();
if (cnt < 6)
{
uint8_t i = (int)(cnt);
if (cnt<3){
// sprintf(mea_tx_buffer, "Tag-Currrnt %d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d\r\n", i, led_pd_dac_v[i][0], led_pd_dac_v[i][1], led_pd_dac_v[i][2], led_pd_dac_v[i][3], led_pd_dac_v[i][4], led_pd_dac_v[i][5], led_pd_dac_v[i][6], led_pd_dac_v[i][7],led_pd_dac_v[i][8], led_pd_dac_v[i][9], led_pd_dac_v[i][10],
// led_pd_dac_v[i][11], led_pd_dac_v[i][12], led_pd_dac_v[i][13], led_pd_dac_v[i][14], led_pd_dac_v[i][15], led_pd_dac_v[i][16], led_pd_dac_v[i][17],led_pd_dac_v[i][18], led_pd_dac_v[i][19], led_pd_dac_v[i][20], led_pd_dac_v[i][21],led_pd_dac_v[i][22], led_pd_dac_v[i][23]);
// data_tx_handler(mea_tx_buffer); }
sprintf(mea_tx_buffer, "Tag-Currrnt %d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d\r\n", i, led_pd_dac_v[0], led_pd_dac_v[1], led_pd_dac_v[2], led_pd_dac_v[3], led_pd_dac_v[4], led_pd_dac_v[5], led_pd_dac_v[6], led_pd_dac_v[7],led_pd_dac_v[8], led_pd_dac_v[9], led_pd_dac_v[10],
led_pd_dac_v[11], led_pd_dac_v[12], led_pd_dac_v[13], led_pd_dac_v[14], led_pd_dac_v[15], led_pd_dac_v[16], led_pd_dac_v[17],led_pd_dac_v[18], led_pd_dac_v[19], led_pd_dac_v[20], led_pd_dac_v[21],led_pd_dac_v[22], led_pd_dac_v[23]);
data_tx_handler(mea_tx_buffer); }
else{
}
DBG_PRINTF("\r\n2CNT =%d\r\n",cnt);
mea_send_timer_start();
// switch(cnt){
// case 0:
// break;
// case 1:
// sprintf(mea_tx_buffer, "Tag-Currrnt %d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d\r\n", i, 0,led_pd_dac_v_led_1[1], led_pd_dac_v_led_2[1], led_pd_dac_v_led_3[1], led_pd_dac_v_led_4[1], led_pd_dac_v_led_5[1], led_pd_dac_v_led_6[1], led_pd_dac_v_led_7[1], led_pd_dac_v_led_8[1],
// led_pd_dac_v_led_9[1], led_pd_dac_v_led_10[1], led_pd_dac_v_led_11[1], led_pd_dac_v_led_12[1], led_pd_dac_v_led_13[1], led_pd_dac_v_led_14[1], led_pd_dac_v_led_15[1], led_pd_dac_v_led_16[1], led_pd_dac_v_led_17[1],led_pd_dac_v_led_18[1],
// led_pd_dac_v_led_19[1], led_pd_dac_v_led_20[1],led_pd_dac_v_led_21[1], led_pd_dac_v_led_22[1],led_pd_dac_v_led_23[1], led_pd_dac_v_led_24[1]);
// break;
// case 2:
// sprintf(mea_tx_buffer, "Tag-Currrnt %d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d\r\n", i, 0, led_pd_dac_v_led_1[1], led_pd_dac_v_led_2[1], led_pd_dac_v_led_3[1], led_pd_dac_v_led_4[1], led_pd_dac_v_led_5[1], led_pd_dac_v_led_6[1], led_pd_dac_v_led_7[1], led_pd_dac_v_led_8[1],
// led_pd_dac_v_led_9[1], led_pd_dac_v_led_10[1], led_pd_dac_v_led_11[1], led_pd_dac_v_led_12[1], led_pd_dac_v_led_13[1], led_pd_dac_v_led_14[1], led_pd_dac_v_led_15[1], led_pd_dac_v_led_16[1], led_pd_dac_v_led_17[1],led_pd_dac_v_led_18[1],
// led_pd_dac_v_led_19[1], led_pd_dac_v_led_20[1],led_pd_dac_v_led_21[1], led_pd_dac_v_led_22[1],led_pd_dac_v_led_23[1], led_pd_dac_v_led_24[1]);
// break;
// case 3:
// sprintf(mea_tx_buffer, "Tag-Currrnt %d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d\r\n", i,0, led_pd_dac_v_led_1[1], led_pd_dac_v_led_2[1], led_pd_dac_v_led_3[1], led_pd_dac_v_led_4[1], led_pd_dac_v_led_5[1], led_pd_dac_v_led_6[1], led_pd_dac_v_led_7[1], led_pd_dac_v_led_8[1],
// led_pd_dac_v_led_9[1], led_pd_dac_v_led_10[1], led_pd_dac_v_led_11[1], led_pd_dac_v_led_12[1], led_pd_dac_v_led_13[1], led_pd_dac_v_led_14[1], led_pd_dac_v_led_15[1], led_pd_dac_v_led_16[1], led_pd_dac_v_led_17[1],led_pd_dac_v_led_18[1],
// led_pd_dac_v_led_19[1], led_pd_dac_v_led_20[1],led_pd_dac_v_led_21[1], led_pd_dac_v_led_22[1],led_pd_dac_v_led_23[1], led_pd_dac_v_led_24[1]);
// break;
// default:
// break;
//// }
// sprintf(mea_tx_buffer,"CNT_%d\r\n",cnt);
// data_tx_handler(mea_tx_buffer);
//
// mea_send_timer_start();
}
else
{
//battery_timer_start();
// sprintf(mea_tx_buffer,"END \r\n");
// data_tx_handler(mea_tx_buffer);
// printf("\r\nLED-DP Gain Array =\r\n");
// for(uint16_t i = 0; i < LED_NUM; i++){
// printf("%d,\t", m_config.led_power_dp[i]);
// }
// printf("\r\n");
DBG_PRINTF("\r\nLED-PD Gain Array =\r\n");
// for(uint16_t i = 0; i < PD_NUM; i++){
for(uint16_t j = 0; j < LED_NUM; j++){
DBG_PRINTF("%d,\t", led_pd_dac_v[j]);
// }
// ///break;
// DBG_PRINTF("\r\n");
}
DBG_PRINTF("\r\n");
processing = false ;
}
cnt++;
}
ret_code_t led_on(uint8_t led_index)
{
uint32_t err_code = NRF_SUCCESS;
#if FEATURE_PRINTF
DBG_PRINTF("\tled_on, %d =====================\r\n", led_index);
#endif
// if((led_index >= 0)&&(led_index <= 49)){
if(led_index <= 100){
activated_led = led_index; //LED off 적용을 위해
/* LED켤때 파워 셋팅한후 켜는지 결정요 */
// if(NRF_SUCCESS != led_power_set(led_index)) {
// DBG_PRINTF("ERR!!! LED Power set\r\n");
// return NRF_ERROR_INTERNAL;
// }
//nrf_gpio_pin_set(trig_18);
trig_SW(true);
if(NRF_SUCCESS != led_select(led_index)){
DBG_PRINTF("ERR!!! LED Select\r\n");
return NRF_ERROR_INTERNAL;
}
// VCSEL_SW(true);
}else{
DBG_PRINTF("ERR!!! led_index Failed! %d\r\n", led_index);
return NRF_ERROR_INTERNAL;
}
return err_code;
}
ret_code_t led_off(uint8_t led_index)
{
uint32_t err_code = NRF_SUCCESS;
trig_SW(false);
#if FEATURE_PRINTF
DBG_PRINTF("led_off\r\n");
#endif
if(led_index == 99){
LED_ALLOFF();
activated_led = 99;
}
else if(led_index == 98){
LED99();
DBG_PRINTF("clear \r\n");
activated_led = 98;
}
else{
DBG_PRINTF("ERR!!! led_index Failed! %d\r\n", led_index);
return NRF_ERROR_INTERNAL;
}
uint32_t port_state0 = nrf_gpio_port_out_read(NRF_P0);
uint32_t port_state1 = nrf_gpio_port_out_read(NRF_P1);
// DBG_PRINTF("test : %d, %d \r\n",port_state0,port_state1);
// DBG_PRINTF("LIGHT ON1 : %d \r\n",port_state0>>22&1);
// DBG_PRINTF("LIGHT ON2 : %d \r\n",port_state0>>23&1);
// DBG_PRINTF("LED_SEL_SW1 : %d \r\n",port_state1>>4&1);
// DBG_PRINTF("LED_SEL_SW2 : %d \r\n",port_state1>>5&1);
// DBG_PRINTF("LED_SEL_SW3 : %d \r\n",port_state1>>6&1);
// DBG_PRINTF("LED_INDIV_SEL_SW1 : %d \r\n",port_state1>>1&1);
// DBG_PRINTF("LED_INDIV_SEL_SW2 : %d \r\n",port_state1>>2&1);
// DBG_PRINTF("LED_INDIV_SEL_SW3 : %d \r\n",port_state1>>3&1);
return err_code;
}
ret_code_t led_pd_mod_set(uint16_t mod_gain)
{
uint32_t err_code = NRF_SUCCESS;
// if(((led_index >= 0)&&(led_index <= 49))||((pd_index >= 0)&&(pd_index <= 2))){
if(mod_gain <= 2000){
sw_i2c_init_once();
mcp4725_writeFastMode( mod_gain);
if(NRF_SUCCESS != pd_on(2)){ //0~23 ==pd0 24~47 == pd1
DBG_PRINTF("ERR!!! MOD_on\r\n");
return NRF_ERROR_INTERNAL;
}
}else{
DBG_PRINTF("ERR!!! lockin Test Failed! \r\n");
return NRF_ERROR_INTERNAL;
}
return err_code;
}
ret_code_t led_pd_matching_value_set(uint8_t led_index)
{
uint32_t err_code = NRF_SUCCESS;
// if(((led_index >= 0)&&(led_index <= 49))||((pd_index >= 0)&&(pd_index <= 2))){
if(led_index <= 100){
if(NRF_SUCCESS != pd_gain_set(led_index)){
DBG_PRINTF("ERR!!! pd_gain_set\r\n");
return NRF_ERROR_INTERNAL;
}
uint8_t pd_index;
if(led_index<24)
{pd_index =0;
}
else if ((led_index<48) && (led_index>23) )
{pd_index =1;
}
else if (led_index==99)
{
pd_index = led_off_pd;
}
if(NRF_SUCCESS != pd_on(pd_index)){ //0~23 ==pd0 24~47 == pd1
DBG_PRINTF("ERR!!! pd_on\r\n");
return NRF_ERROR_INTERNAL;
}
}else{
DBG_PRINTF("ERR!!! led_indexFailed! %d\r\n", led_index);
return NRF_ERROR_INTERNAL;
}
return err_code;
}
ret_code_t pd_on(uint8_t pd_index)
{
uint32_t err_code = NRF_SUCCESS;
#if FEATURE_FOR_SCOPE
nrf_gpio_pin_set(PD_CLK_26);
nrf_gpio_pin_clear(PD_CLK_26);
#endif
#if FEATURE_PRINTF
DBG_PRINTF("pd_on, %d ===== \r\n", pd_index);
#endif
// if((pd_index >= 0)&&(pd_index <= 2)){
if(pd_index <= 3){
activated_pd = pd_index;
//DBG_PRINTF("pd_on %d\r\n", pd_index);
if(NRF_SUCCESS != pd_select(pd_index)){
DBG_PRINTF("ERR!!! pd_on Failed! %d\r\n", pd_index);
return NRF_ERROR_INTERNAL;
}
}else{
DBG_PRINTF("ERR!!! pd_index Failed! %d\r\n", pd_index);
return NRF_ERROR_INTERNAL;
}
return err_code;
}
ret_code_t pd_off(uint8_t pd_index)
{
uint32_t err_code = NRF_SUCCESS;
#if FEATURE_PRINTF
DBG_PRINTF("pd_off\r\n");
#endif
if(pd_index == 99){
PD_ALLOFF();
activated_pd = 99;
}else{
DBG_PRINTF("ERR!!! PD Off Failed! %d\r\n", pd_index);
return NRF_ERROR_INTERNAL;
}
return err_code;
}
void led_power_read_48(uint16_t *data)
{
for(uint8_t i = 0 ; i<24 ;i++){ //48 >24
data[i] = LED_READ_ROM(i);
nrf_delay_ms(1);
}
// nrf_delay_ms(20);
}
int16_t led_power_read(uint8_t led_index)
{
int16_t led_power;
// if((led_index >= 0)&&(led_index <= 49)){
if(led_index <= 47){
//led_power = led_power_dp[led_index];
led_power = LED_READ_ROM(led_index);
}else{
DBG_PRINTF("ERR!!! led_index Failed! %d\r\n", led_index);
return NRF_ERROR_INTERNAL;
}
return led_power;
}
ret_code_t led_power_save_mem(uint8_t led_index, int16_t led_power) /* 커맨드에 의해서 LED파워 값을 저장할때 */
{
uint32_t err_code = NRF_SUCCESS;
// if(((led_index >= 0)&&(led_index <= 49))||((led_power >= 0)&&(led_power <= 255))){
if((led_index <= 47)||(led_power <= 255)){
// led_power_dp[led_index] = led_power;
if(NRF_SUCCESS != LED_WRITE_ROM(led_index,led_power)){
DBG_PRINTF("ERR!!! DS3930 1\r\n");
err_code = NRF_ERROR_INTERNAL;
}
}else{
DBG_PRINTF("ERR!!! led_index || pd_index Failed! %d, %d\r\n", led_index, led_power);
return NRF_ERROR_INTERNAL;
}
return err_code;
}
ret_code_t led_power_save_mem_6(uint8_t led_index, int16_t led_power) /* 커맨드에 의해서 LED파워 값을 저장할때 */
{
uint32_t err_code = NRF_SUCCESS;
// if(((led_index >= 0)&&(led_index <= 49))||((led_power >= 0)&&(led_power <= 255))){
// if((led_index <= 47)||(led_power <= 255)){
// led_power_dp[led_index] = led_power;
// for(uint8_t i = 0 ; i<48 ;i++){
// if(NRF_SUCCESS != LED_WRITE_ROM(led_index,led_power)){
// DBG_PRINTF("ERR!!! DS3930 1\r\n");
// err_code = NRF_ERROR_INTERNAL;
for(uint8_t i = 0 ; i<48 ;i++){
// led_power_dp[i] = led_power; Fstorage garbage
if(NRF_SUCCESS != LED_WRITE_ROM(i,led_power)){
DBG_PRINTF("ERR!!! DS3930 1\r\n");
err_code = NRF_ERROR_INTERNAL;
}
// nrf_delay_ms(20);
else{
// DBG_PRINTF("ERR!!! led_index Failed! %d\r\n", led_index);
// return NRF_ERROR_INTERNAL;
}
nrf_delay_ms(10);
}
return err_code;
}
ret_code_t led_power_save_mem_48(uint8_t *led_power) /* 커맨드에 의해서 LED파워 값을 저장할때 */
{
uint32_t err_code = NRF_SUCCESS;
// if(((led_index >= 0)&&(led_index <= 49))||((led_power >= 0)&&(led_power <= 255))){
// if((led_index <= 47)||(led_power <= 255)){
// led_power_dp[led_index] = led_power;
// for(uint8_t i = 0 ; i<48 ;i++){
// if(NRF_SUCCESS != LED_WRITE_ROM(led_index,led_power)){
// DBG_PRINTF("ERR!!! DS3930 1\r\n");
// err_code = NRF_ERROR_INTERNAL;
for(uint8_t i = 0 ; i<48 ;i++){
//led_power_dp[i] = led_power;
if(NRF_SUCCESS != LED_WRITE_ROM(i,(int16_t)(led_power[i]))){
DBG_PRINTF("ERR!!! DS3930 1\r\n");
err_code = NRF_ERROR_INTERNAL;
}
// nrf_delay_ms(20);
else{
// DBG_PRINTF("ERR!!! led_index Failed! %d\r\n", led_index);
// return NRF_ERROR_INTERNAL;
}
nrf_delay_ms(10);
}
return err_code;
}
//void led_power_span(uint8_t led_index)
//{
// uint32_t err_code = NRF_SUCCESS;
//
// for(uint8_t i= 0 ;i<255 ;i++){
// if(NRF_SUCCESS != LED_WRITE_ROM(led_index,i)){
// DBG_PRINTF("ERR!!! DS3930 1\r\n");
// err_code = NRF_ERROR_INTERNAL;
// }
// nrf_delay_ms(20);
// }
// DBG_PRINTF("DS3930 1\r\n");
// }
ret_code_t led_power_set(uint8_t led_index) /* LED켤때 사용, 메모리 값을 디지털포텐셔미터에 입력 */
{
uint32_t err_code = NRF_SUCCESS;
// int16_t led_power; //no need
// if((led_index >= 1)&&(led_index <= 24)){
// led_power = led_power_dp[led_index];
// if(NRF_SUCCESS != ad5272_write_rdac(led_power)) { /* LED를 켜기전에 메모리에 저장된 파워값을 DAC에 설정 */
// DBG_PRINTF("ERR!!! ad5272_write_rdac 2\r\n");
// err_code = NRF_ERROR_INTERNAL;
// }
// }else{
// DBG_PRINTF("ERR!!! led_index Failed! %d\r\n", led_index);
// return NRF_ERROR_INTERNAL;
// }
return err_code;
}
ret_code_t pd_gain_set(uint8_t activated_led) /* LED와 PD 매칭 값으로 On */
{
uint32_t err_code = NRF_SUCCESS;
#if FEATURE_PRINTF
DBG_PRINTF("<<pd_gain_set L%d, P%d>>\r\n",activated_led ,pd_index);
#endif
// if(((activated_led >= 0)&&(activated_led <= 49))||((pd_index >= 0)&&(pd_index <= 2))){
if((activated_led <= 47)){
sw_i2c_init_once();
mcp4725_writeFastMode( led_pd_dac_v[activated_led]); /* LED는 먼저 ON되어 있어 하며 그 LED번호와 PD배칭 값으로 DAC에 설정 */
//DBG_PRINTF("dac_v %d\r\n", led_pd_dac_v[pd_index][activated_led]);
}
else if(activated_led == 99){
mcp4725_writeFastMode( led_off_dac_v); /* LED_OFF 배칭 값으로 DAC에 설정 */
}
else{
DBG_PRINTF("ERR!!! led_index Failed! %d\r\n", activated_led);
return NRF_ERROR_INTERNAL;
}
return err_code;
}
ret_code_t imm_gain_set(uint16_t imm_dac) /* LED와 PD 매칭 값으로 On */
{
uint32_t err_code = NRF_SUCCESS;
if((imm_dac <= 2000)){
sw_i2c_init_once();//ad cj
mcp4725_writeFastMode( imm_dac); /* LED는 먼저 ON되어 있어 하며 그 LED번호와 PD배칭 값으로 DAC에 설정 */
DBG_PRINTF("dac_v %d\r\n", imm_dac);
}else{
DBG_PRINTF("ERR!!! range Failed! %d\r\n", activated_led);
return NRF_ERROR_INTERNAL;
}
return err_code;
}
ret_code_t led_select(uint8_t led_index)
{
uint32_t err_code = NRF_SUCCESS;
//LED_ALLOFF();
switch(led_index) {
case 0:
LED0();
break;
case 1:
LED1();
break;
case 2:
LED2();
break;
case 3:
LED3();
break;
case 4:
LED4();
break;
case 5:
LED5();
break;
case 6:
LED6();
break;
case 7:
LED7();
break;
case 8:
LED8();
break;
case 9:
LED9();
break;
case 10:
LED10();
break;
case 11:
LED11();
break;
case 12:
LED12();
break;
case 13:
LED13();
break;
case 14:
LED14();
break;
case 15:
LED15();
break;
case 16:
LED16();
break;
case 17:
LED17();
break;
case 18:
LED18();
break;
case 19:
LED19();
break;
case 20:
LED20();
break;
case 21:
LED21();
break;
case 22:
LED22();
break;
case 23:
LED23();
break;
case 24:
LED24();
break;
case 25:
LED25();
break;
case 26:
LED26();
break;
case 27:
LED27();
break;
case 28:
LED28();
break;
case 29:
LED29();
break;
case 30:
LED30();
break;
case 31:
LED31();
break;
case 32:
LED32();
break;
case 33:
LED33();
break;
case 34:
LED34();
break;
case 35:
LED35();
break;
case 36:
LED36();
break;
case 37:
LED37();
break;
case 38:
LED38();
break;
case 39:
LED39();
break;
case 40:
LED40();
break;
case 41:
LED41();
break;
case 42:
LED42();
break;
case 43:
LED43();
break;
case 44:
LED44();
break;
case 45:
LED45();
break;
case 46:
LED46();
break;
case 47:
LED47();
break;
case 99:
LED99();
break;
default:
err_code = NRF_ERROR_NOT_FOUND;
break;
}
nrf_delay_ms(1);
// DBG_PRINTF("LIGHT ON1 : %d \r\n",nrf_gpio_pin_read(LIGHT_ON1));
// DBG_PRINTF("LIGHT ON2 : %d \r\n",nrf_gpio_pin_read(LIGHT_ON2));
// DBG_PRINTF("LED_SEL_SW1 : %d \r\n",nrf_gpio_pin_read(LED_SEL_SW1));
// DBG_PRINTF("LED_SEL_SW2 : %d \r\n",nrf_gpio_pin_read(LED_SEL_SW2));
// DBG_PRINTF("LED_SEL_SW3 : %d \r\n",nrf_gpio_pin_read(LED_SEL_SW3));
// DBG_PRINTF("LED_INDIV_SEL_SW1 : %d \r\n",nrf_gpio_pin_read(LED_INDIV_SEL_SW1));
// DBG_PRINTF("LED_INDIV_SEL_SW2 : %d \r\n",nrf_gpio_pin_read(LED_INDIV_SEL_SW2));
// DBG_PRINTF("LED_INDIV_SEL_SW3 : %d \r\n",nrf_gpio_pin_read(LED_INDIV_SEL_SW3));
uint32_t port_state0 = nrf_gpio_port_out_read(NRF_P0);
uint32_t port_state1 = nrf_gpio_port_out_read(NRF_P1);
// DBG_PRINTF("test : %d, %d \r\n",port_state0,port_state1);
// DBG_PRINTF("LIGHT ON1 : %d \r\n",port_state0>>22&1);
// DBG_PRINTF("LIGHT ON2 : %d \r\n",port_state0>>23&1);
// DBG_PRINTF("LED_SEL_SW1 : %d \r\n",port_state1>>4&1);
// DBG_PRINTF("LED_SEL_SW2 : %d \r\n",port_state1>>5&1);
// DBG_PRINTF("LED_SEL_SW3 : %d \r\n",port_state1>>6&1);
// DBG_PRINTF("LED_INDIV_SEL_SW1 : %d \r\n",port_state1>>1&1);
// DBG_PRINTF("LED_INDIV_SEL_SW2 : %d \r\n",port_state1>>2&1);
// DBG_PRINTF("LED_INDIV_SEL_SW3 : %d \r\n",port_state1>>3&1);
return err_code;
}
ret_code_t pd_select(uint8_t pd_index)
{
uint32_t err_code = NRF_SUCCESS;
PD_ALLOFF();
switch(pd_index) {
case 0:
PD0();
break;
case 1:
PD1();
break;
case 2:
MOD();
break;
case 3:
MOD2();
break;
default:
err_code = NRF_ERROR_NOT_FOUND;
break;
}
return err_code;
}
void mea_send_timer_start(void)
{
APP_ERROR_CHECK(app_timer_start(m_mea_send_loop_timer_id, APP_TIMER_TICKS(MEA_SEND_LOOP_INTERVAL), NULL));
}
void mea_send_timer_stop(void)
{
APP_ERROR_CHECK(app_timer_stop(m_mea_send_loop_timer_id));
}
void mea_send_timer_init(void)
{
APP_ERROR_CHECK(app_timer_create(&m_mea_send_loop_timer_id, APP_TIMER_MODE_SINGLE_SHOT, mea_send_loop));
}

666
project/ble_peripheral/ble_app_bladder_patch/measurements.h
View File

@@ -1,666 +0,0 @@
/*******************************************************************************
* @file measurements.h
* @author CandyPops Co.
* @version V1.0.0
* @date 2022-09-05
* @brief
******************************************************************************/
#ifndef _MEASUREMENTS_H__
#define _MEASUREMENTS_H__
#include "sdk_common.h"
#include <stdbool.h>
#include "nrf.h"
#include "nrf_drv_gpiote.h"
#define trig_r NRF_GPIO_PIN_MAP(0,18)
#define trig_r_CONFIG() nrf_gpio_cfg_output(trig_r)
#define trig_SW(x) if(x == true) nrf_gpio_pin_set(trig_r);\
else if(x == false) nrf_gpio_pin_clear(trig_r)
/* For NIR LED */
//#define LIGHT_ON1 NRF_GPIO_PIN_MAP(0,28)
//#define LIGHT_ON2 NRF_GPIO_PIN_MAP(0,29)
//#define LIGHT_ON3 NRF_GPIO_PIN_MAP(0,31)
//#define LIGHT_ON4 NRF_GPIO_PIN_MAP(0,19)
//may work below.
//#define VCSEL_SW1 NRF_GPIO_PIN_MAP(1,1)
//#define VCSEL_SW2 NRF_GPIO_PIN_MAP(1,2)
//#define VCSEL_SW3 NRF_GPIO_PIN_MAP(1,3)
#define LIGHT_ON NRF_GPIO_PIN_MAP(0,22)
#define NIR_PART_SEL NRF_GPIO_PIN_MAP(1,7)
#define NIRLED_SEL0 NRF_GPIO_PIN_MAP(1,4)
#define NIRLED_SEL1 NRF_GPIO_PIN_MAP(1,5)
#define NIR_WAV_SEL0 NRF_GPIO_PIN_MAP(1,1)
#define NIR_WAV_SEL1 NRF_GPIO_PIN_MAP(1,2)
#define NIR_WAV_SEL2 NRF_GPIO_PIN_MAP(1,3)
//#define LED_CONFIG() nrf_gpio_cfg(LIGHT_ON1, NRF_GPIO_PIN_DIR_OUTPUT, NRF_GPIO_PIN_INPUT_CONNECT,NRF_GPIO_PIN_PULLUP, NRF_GPIO_PIN_S0D1,NRF_GPIO_PIN_NOSENSE);\
// nrf_gpio_cfg(LIGHT_ON2, NRF_GPIO_PIN_DIR_OUTPUT, NRF_GPIO_PIN_INPUT_CONNECT,NRF_GPIO_PIN_PULLUP, NRF_GPIO_PIN_S0D1,NRF_GPIO_PIN_NOSENSE);\
// nrf_gpio_cfg(LED_SEL_SW1, NRF_GPIO_PIN_DIR_OUTPUT, NRF_GPIO_PIN_INPUT_CONNECT,NRF_GPIO_PIN_PULLUP, NRF_GPIO_PIN_S0D1,NRF_GPIO_PIN_NOSENSE);\
// nrf_gpio_cfg(LED_SEL_SW2, NRF_GPIO_PIN_DIR_OUTPUT, NRF_GPIO_PIN_INPUT_CONNECT,NRF_GPIO_PIN_PULLUP, NRF_GPIO_PIN_S0D1,NRF_GPIO_PIN_NOSENSE);\
// nrf_gpio_cfg(LED_SEL_SW3, NRF_GPIO_PIN_DIR_OUTPUT, NRF_GPIO_PIN_INPUT_CONNECT,NRF_GPIO_PIN_PULLUP, NRF_GPIO_PIN_S0D1,NRF_GPIO_PIN_NOSENSE);\
// nrf_gpio_cfg(LED_INDIV_SEL_SW1, NRF_GPIO_PIN_DIR_OUTPUT, NRF_GPIO_PIN_INPUT_CONNECT,NRF_GPIO_PIN_PULLUP, NRF_GPIO_PIN_S0D1,NRF_GPIO_PIN_NOSENSE);\
// nrf_gpio_cfg(LED_INDIV_SEL_SW2, NRF_GPIO_PIN_DIR_OUTPUT, NRF_GPIO_PIN_INPUT_CONNECT,NRF_GPIO_PIN_PULLUP, NRF_GPIO_PIN_S0D1,NRF_GPIO_PIN_NOSENSE);\
// nrf_gpio_cfg(LED_INDIV_SEL_SW3, NRF_GPIO_PIN_DIR_OUTPUT, NRF_GPIO_PIN_INPUT_CONNECT,NRF_GPIO_PIN_PULLUP, NRF_GPIO_PIN_S0D1,NRF_GPIO_PIN_NOSENSE);
#define LED_CONFIG()nrf_gpio_cfg_output(LIGHT_ON);\
nrf_gpio_cfg_output(NIR_PART_SEL);\
nrf_gpio_cfg_output(NIRLED_SEL0);\
nrf_gpio_cfg_output(NIRLED_SEL1);\
nrf_gpio_cfg_output(NIR_WAV_SEL0);\
nrf_gpio_cfg_output(NIR_WAV_SEL1);\
nrf_gpio_cfg_output(NIR_WAV_SEL2)
// Macros for LEDs 0 to 5 ( LIGHT_ON -->0)
#define LED0() nrf_gpio_pin_clear(LIGHT_ON); \
nrf_gpio_pin_clear(NIR_PART_SEL); \
nrf_gpio_pin_clear(NIRLED_SEL0); \
nrf_gpio_pin_clear(NIRLED_SEL1); \
nrf_gpio_pin_clear(NIR_WAV_SEL0); \
nrf_gpio_pin_clear(NIR_WAV_SEL1); \
nrf_gpio_pin_clear(NIR_WAV_SEL2)
#define LED1() nrf_gpio_pin_clear(LIGHT_ON); \
nrf_gpio_pin_clear(NIR_PART_SEL); \
nrf_gpio_pin_clear(NIRLED_SEL0); \
nrf_gpio_pin_clear(NIRLED_SEL1); \
nrf_gpio_pin_set(NIR_WAV_SEL0); \
nrf_gpio_pin_clear(NIR_WAV_SEL1); \
nrf_gpio_pin_clear(NIR_WAV_SEL2)
#define LED2() nrf_gpio_pin_clear(LIGHT_ON); \
nrf_gpio_pin_clear(NIR_PART_SEL); \
nrf_gpio_pin_clear(NIRLED_SEL0); \
nrf_gpio_pin_clear(NIRLED_SEL1); \
nrf_gpio_pin_clear(NIR_WAV_SEL0); \
nrf_gpio_pin_set(NIR_WAV_SEL1); \
nrf_gpio_pin_clear(NIR_WAV_SEL2)
#define LED3() nrf_gpio_pin_clear(LIGHT_ON); \
nrf_gpio_pin_clear(NIR_PART_SEL); \
nrf_gpio_pin_clear(NIRLED_SEL0); \
nrf_gpio_pin_clear(NIRLED_SEL1); \
nrf_gpio_pin_set(NIR_WAV_SEL0); \
nrf_gpio_pin_set(NIR_WAV_SEL1); \
nrf_gpio_pin_clear(NIR_WAV_SEL2)
#define LED4() nrf_gpio_pin_clear(LIGHT_ON); \
nrf_gpio_pin_clear(NIR_PART_SEL); \
nrf_gpio_pin_clear(NIRLED_SEL0); \
nrf_gpio_pin_clear(NIRLED_SEL1); \
nrf_gpio_pin_clear(NIR_WAV_SEL0); \
nrf_gpio_pin_clear(NIR_WAV_SEL1); \
nrf_gpio_pin_set(NIR_WAV_SEL2)
#define LED5() nrf_gpio_pin_clear(LIGHT_ON); \
nrf_gpio_pin_clear(NIR_PART_SEL); \
nrf_gpio_pin_clear(NIRLED_SEL0); \
nrf_gpio_pin_clear(NIRLED_SEL1); \
nrf_gpio_pin_set(NIR_WAV_SEL0); \
nrf_gpio_pin_clear(NIR_WAV_SEL1); \
nrf_gpio_pin_set(NIR_WAV_SEL2)
// Macros for LEDs 10 to 15 ( LIGHT_ON -->0)
#define LED6() nrf_gpio_pin_clear(LIGHT_ON); \
nrf_gpio_pin_clear(NIR_PART_SEL); \
nrf_gpio_pin_set(NIRLED_SEL0); \
nrf_gpio_pin_clear(NIRLED_SEL1); \
nrf_gpio_pin_clear(NIR_WAV_SEL0); \
nrf_gpio_pin_clear(NIR_WAV_SEL1); \
nrf_gpio_pin_clear(NIR_WAV_SEL2)
#define LED7() nrf_gpio_pin_clear(LIGHT_ON); \
nrf_gpio_pin_clear(NIR_PART_SEL); \
nrf_gpio_pin_set(NIRLED_SEL0); \
nrf_gpio_pin_clear(NIRLED_SEL1); \
nrf_gpio_pin_set(NIR_WAV_SEL0); \
nrf_gpio_pin_clear(NIR_WAV_SEL1); \
nrf_gpio_pin_clear(NIR_WAV_SEL2)
#define LED8() nrf_gpio_pin_clear(LIGHT_ON); \
nrf_gpio_pin_clear(NIR_PART_SEL); \
nrf_gpio_pin_set(NIRLED_SEL0); \
nrf_gpio_pin_clear(NIRLED_SEL1); \
nrf_gpio_pin_clear(NIR_WAV_SEL0); \
nrf_gpio_pin_set(NIR_WAV_SEL1); \
nrf_gpio_pin_clear(NIR_WAV_SEL2)
#define LED9() nrf_gpio_pin_clear(LIGHT_ON); \
nrf_gpio_pin_clear(NIR_PART_SEL); \
nrf_gpio_pin_set(NIRLED_SEL0); \
nrf_gpio_pin_clear(NIRLED_SEL1); \
nrf_gpio_pin_set(NIR_WAV_SEL0); \
nrf_gpio_pin_set(NIR_WAV_SEL1); \
nrf_gpio_pin_clear(NIR_WAV_SEL2)
#define LED10() nrf_gpio_pin_clear(LIGHT_ON); \
nrf_gpio_pin_clear(NIR_PART_SEL); \
nrf_gpio_pin_set(NIRLED_SEL0); \
nrf_gpio_pin_clear(NIRLED_SEL1); \
nrf_gpio_pin_clear(NIR_WAV_SEL0); \
nrf_gpio_pin_clear(NIR_WAV_SEL1); \
nrf_gpio_pin_set(NIR_WAV_SEL2)
#define LED11() nrf_gpio_pin_clear(LIGHT_ON); \
nrf_gpio_pin_clear(NIR_PART_SEL); \
nrf_gpio_pin_set(NIRLED_SEL0); \
nrf_gpio_pin_clear(NIRLED_SEL1); \
nrf_gpio_pin_set(NIR_WAV_SEL0); \
nrf_gpio_pin_clear(NIR_WAV_SEL1); \
nrf_gpio_pin_set(NIR_WAV_SEL2)
// Macros for LEDs 20 to 25 ( LIGHT_ON -->0)
#define LED12() nrf_gpio_pin_clear(LIGHT_ON); \
nrf_gpio_pin_clear(NIR_PART_SEL); \
nrf_gpio_pin_clear(NIRLED_SEL0); \
nrf_gpio_pin_set(NIRLED_SEL1); \
nrf_gpio_pin_clear(NIR_WAV_SEL0); \
nrf_gpio_pin_clear(NIR_WAV_SEL1); \
nrf_gpio_pin_clear(NIR_WAV_SEL2)
#define LED13() nrf_gpio_pin_clear(LIGHT_ON); \
nrf_gpio_pin_clear(NIR_PART_SEL); \
nrf_gpio_pin_clear(NIRLED_SEL0); \
nrf_gpio_pin_set(NIRLED_SEL1); \
nrf_gpio_pin_set(NIR_WAV_SEL0); \
nrf_gpio_pin_clear(NIR_WAV_SEL1); \
nrf_gpio_pin_clear(NIR_WAV_SEL2)
#define LED14() nrf_gpio_pin_clear(LIGHT_ON); \
nrf_gpio_pin_clear(NIR_PART_SEL); \
nrf_gpio_pin_clear(NIRLED_SEL0); \
nrf_gpio_pin_set(NIRLED_SEL1); \
nrf_gpio_pin_clear(NIR_WAV_SEL0); \
nrf_gpio_pin_set(NIR_WAV_SEL1); \
nrf_gpio_pin_clear(NIR_WAV_SEL2)
#define LED15() nrf_gpio_pin_clear(LIGHT_ON); \
nrf_gpio_pin_clear(NIR_PART_SEL); \
nrf_gpio_pin_clear(NIRLED_SEL0); \
nrf_gpio_pin_set(NIRLED_SEL1); \
nrf_gpio_pin_set(NIR_WAV_SEL0); \
nrf_gpio_pin_set(NIR_WAV_SEL1); \
nrf_gpio_pin_clear(NIR_WAV_SEL2)
#define LED16() nrf_gpio_pin_clear(LIGHT_ON); \
nrf_gpio_pin_clear(NIR_PART_SEL); \
nrf_gpio_pin_clear(NIRLED_SEL0); \
nrf_gpio_pin_set(NIRLED_SEL1); \
nrf_gpio_pin_clear(NIR_WAV_SEL0); \
nrf_gpio_pin_clear(NIR_WAV_SEL1); \
nrf_gpio_pin_set(NIR_WAV_SEL2)
#define LED17() nrf_gpio_pin_clear(LIGHT_ON); \
nrf_gpio_pin_clear(NIR_PART_SEL); \
nrf_gpio_pin_clear(NIRLED_SEL0); \
nrf_gpio_pin_set(NIRLED_SEL1); \
nrf_gpio_pin_set(NIR_WAV_SEL0); \
nrf_gpio_pin_clear(NIR_WAV_SEL1); \
nrf_gpio_pin_set(NIR_WAV_SEL2)
// Macros for LEDs 30 to 35 ( LIGHT_ON -->0)
#define LED18() nrf_gpio_pin_clear(LIGHT_ON); \
nrf_gpio_pin_clear(NIR_PART_SEL); \
nrf_gpio_pin_set(NIRLED_SEL0); \
nrf_gpio_pin_set(NIRLED_SEL1); \
nrf_gpio_pin_clear(NIR_WAV_SEL0); \
nrf_gpio_pin_clear(NIR_WAV_SEL1); \
nrf_gpio_pin_clear(NIR_WAV_SEL2)
#define LED19() nrf_gpio_pin_clear(LIGHT_ON); \
nrf_gpio_pin_clear(NIR_PART_SEL); \
nrf_gpio_pin_set(NIRLED_SEL0); \
nrf_gpio_pin_set(NIRLED_SEL1); \
nrf_gpio_pin_set(NIR_WAV_SEL0); \
nrf_gpio_pin_clear(NIR_WAV_SEL1); \
nrf_gpio_pin_clear(NIR_WAV_SEL2)
#define LED20() nrf_gpio_pin_clear(LIGHT_ON); \
nrf_gpio_pin_clear(NIR_PART_SEL); \
nrf_gpio_pin_set(NIRLED_SEL0); \
nrf_gpio_pin_set(NIRLED_SEL1); \
nrf_gpio_pin_clear(NIR_WAV_SEL0); \
nrf_gpio_pin_set(NIR_WAV_SEL1); \
nrf_gpio_pin_clear(NIR_WAV_SEL2)
#define LED21() nrf_gpio_pin_clear(LIGHT_ON); \
nrf_gpio_pin_clear(NIR_PART_SEL); \
nrf_gpio_pin_set(NIRLED_SEL0); \
nrf_gpio_pin_set(NIRLED_SEL1); \
nrf_gpio_pin_set(NIR_WAV_SEL0); \
nrf_gpio_pin_set(NIR_WAV_SEL1); \
nrf_gpio_pin_clear(NIR_WAV_SEL2)
#define LED22() nrf_gpio_pin_clear(LIGHT_ON); \
nrf_gpio_pin_clear(NIR_PART_SEL); \
nrf_gpio_pin_set(NIRLED_SEL0); \
nrf_gpio_pin_set(NIRLED_SEL1); \
nrf_gpio_pin_clear(NIR_WAV_SEL0); \
nrf_gpio_pin_clear(NIR_WAV_SEL1); \
nrf_gpio_pin_set(NIR_WAV_SEL2)
#define LED23() nrf_gpio_pin_clear(LIGHT_ON); \
nrf_gpio_pin_clear(NIR_PART_SEL); \
nrf_gpio_pin_set(NIRLED_SEL0); \
nrf_gpio_pin_set(NIRLED_SEL1); \
nrf_gpio_pin_set(NIR_WAV_SEL0); \
nrf_gpio_pin_clear(NIR_WAV_SEL1); \
nrf_gpio_pin_set(NIR_WAV_SEL2)
// Macros for LEDs 40 to 45 ( LIGHT_ON -->0)
#define LED24() nrf_gpio_pin_clear(LIGHT_ON); \
nrf_gpio_pin_set(NIR_PART_SEL); \
nrf_gpio_pin_clear(NIRLED_SEL0); \
nrf_gpio_pin_clear(NIRLED_SEL1); \
nrf_gpio_pin_clear(NIR_WAV_SEL0); \
nrf_gpio_pin_clear(NIR_WAV_SEL1); \
nrf_gpio_pin_clear(NIR_WAV_SEL2)
#define LED25() nrf_gpio_pin_clear(LIGHT_ON); \
nrf_gpio_pin_set(NIR_PART_SEL); \
nrf_gpio_pin_clear(NIRLED_SEL0); \
nrf_gpio_pin_clear(NIRLED_SEL1); \
nrf_gpio_pin_set(NIR_WAV_SEL0); \
nrf_gpio_pin_clear(NIR_WAV_SEL1); \
nrf_gpio_pin_clear(NIR_WAV_SEL2)
#define LED26() nrf_gpio_pin_clear(LIGHT_ON); \
nrf_gpio_pin_set(NIR_PART_SEL); \
nrf_gpio_pin_clear(NIRLED_SEL0); \
nrf_gpio_pin_clear(NIRLED_SEL1); \
nrf_gpio_pin_clear(NIR_WAV_SEL0); \
nrf_gpio_pin_set(NIR_WAV_SEL1); \
nrf_gpio_pin_clear(NIR_WAV_SEL2)
#define LED27() nrf_gpio_pin_clear(LIGHT_ON); \
nrf_gpio_pin_set(NIR_PART_SEL); \
nrf_gpio_pin_clear(NIRLED_SEL0); \
nrf_gpio_pin_clear(NIRLED_SEL1); \
nrf_gpio_pin_set(NIR_WAV_SEL0); \
nrf_gpio_pin_set(NIR_WAV_SEL1); \
nrf_gpio_pin_clear(NIR_WAV_SEL2)
#define LED28() nrf_gpio_pin_clear(LIGHT_ON); \
nrf_gpio_pin_set(NIR_PART_SEL); \
nrf_gpio_pin_clear(NIRLED_SEL0); \
nrf_gpio_pin_clear(NIRLED_SEL1); \
nrf_gpio_pin_clear(NIR_WAV_SEL0); \
nrf_gpio_pin_clear(NIR_WAV_SEL1); \
nrf_gpio_pin_set(NIR_WAV_SEL2)
#define LED29() nrf_gpio_pin_clear(LIGHT_ON); \
nrf_gpio_pin_set(NIR_PART_SEL); \
nrf_gpio_pin_clear(NIRLED_SEL0); \
nrf_gpio_pin_clear(NIRLED_SEL1); \
nrf_gpio_pin_set(NIR_WAV_SEL0); \
nrf_gpio_pin_clear(NIR_WAV_SEL1); \
nrf_gpio_pin_set(NIR_WAV_SEL2)
// Macros for LEDs 50 to 55 ( LIGHT_ON -->0)
#define LED30() nrf_gpio_pin_clear(LIGHT_ON); \
nrf_gpio_pin_set(NIR_PART_SEL); \
nrf_gpio_pin_set(NIRLED_SEL0); \
nrf_gpio_pin_clear(NIRLED_SEL1); \
nrf_gpio_pin_clear(NIR_WAV_SEL0); \
nrf_gpio_pin_clear(NIR_WAV_SEL1); \
nrf_gpio_pin_clear(NIR_WAV_SEL2)
#define LED31() nrf_gpio_pin_clear(LIGHT_ON); \
nrf_gpio_pin_set(NIR_PART_SEL); \
nrf_gpio_pin_set(NIRLED_SEL0); \
nrf_gpio_pin_clear(NIRLED_SEL1); \
nrf_gpio_pin_set(NIR_WAV_SEL0); \
nrf_gpio_pin_clear(NIR_WAV_SEL1); \
nrf_gpio_pin_clear(NIR_WAV_SEL2)
#define LED32() nrf_gpio_pin_clear(LIGHT_ON); \
nrf_gpio_pin_set(NIR_PART_SEL); \
nrf_gpio_pin_set(NIRLED_SEL0); \
nrf_gpio_pin_clear(NIRLED_SEL1); \
nrf_gpio_pin_clear(NIR_WAV_SEL0); \
nrf_gpio_pin_set(NIR_WAV_SEL1); \
nrf_gpio_pin_clear(NIR_WAV_SEL2)
#define LED33() nrf_gpio_pin_clear(LIGHT_ON); \
nrf_gpio_pin_set(NIR_PART_SEL); \
nrf_gpio_pin_set(NIRLED_SEL0); \
nrf_gpio_pin_clear(NIRLED_SEL1); \
nrf_gpio_pin_set(NIR_WAV_SEL0); \
nrf_gpio_pin_set(NIR_WAV_SEL1); \
nrf_gpio_pin_clear(NIR_WAV_SEL2)
#define LED34() nrf_gpio_pin_clear(LIGHT_ON); \
nrf_gpio_pin_set(NIR_PART_SEL); \
nrf_gpio_pin_set(NIRLED_SEL0); \
nrf_gpio_pin_clear(NIRLED_SEL1); \
nrf_gpio_pin_clear(NIR_WAV_SEL0); \
nrf_gpio_pin_clear(NIR_WAV_SEL1); \
nrf_gpio_pin_set(NIR_WAV_SEL2)
#define LED35() nrf_gpio_pin_clear(LIGHT_ON); \
nrf_gpio_pin_set(NIR_PART_SEL); \
nrf_gpio_pin_set(NIRLED_SEL0); \
nrf_gpio_pin_clear(NIRLED_SEL1); \
nrf_gpio_pin_set(NIR_WAV_SEL0); \
nrf_gpio_pin_clear(NIR_WAV_SEL1); \
nrf_gpio_pin_set(NIR_WAV_SEL2)
// Macros for LEDs 60 to 65 ( LIGHT_ON -->0)
#define LED36() nrf_gpio_pin_clear(LIGHT_ON); \
nrf_gpio_pin_set(NIR_PART_SEL); \
nrf_gpio_pin_clear(NIRLED_SEL0); \
nrf_gpio_pin_set(NIRLED_SEL1); \
nrf_gpio_pin_clear(NIR_WAV_SEL0); \
nrf_gpio_pin_clear(NIR_WAV_SEL1); \
nrf_gpio_pin_clear(NIR_WAV_SEL2)
#define LED37() nrf_gpio_pin_clear(LIGHT_ON); \
nrf_gpio_pin_set(NIR_PART_SEL); \
nrf_gpio_pin_clear(NIRLED_SEL0); \
nrf_gpio_pin_set(NIRLED_SEL1); \
nrf_gpio_pin_set(NIR_WAV_SEL0); \
nrf_gpio_pin_clear(NIR_WAV_SEL1); \
nrf_gpio_pin_clear(NIR_WAV_SEL2)
#define LED38() nrf_gpio_pin_clear(LIGHT_ON); \
nrf_gpio_pin_set(NIR_PART_SEL); \
nrf_gpio_pin_clear(NIRLED_SEL0); \
nrf_gpio_pin_set(NIRLED_SEL1); \
nrf_gpio_pin_clear(NIR_WAV_SEL0); \
nrf_gpio_pin_set(NIR_WAV_SEL1); \
nrf_gpio_pin_clear(NIR_WAV_SEL2)
#define LED39() nrf_gpio_pin_clear(LIGHT_ON); \
nrf_gpio_pin_set(NIR_PART_SEL); \
nrf_gpio_pin_clear(NIRLED_SEL0); \
nrf_gpio_pin_set(NIRLED_SEL1); \
nrf_gpio_pin_set(NIR_WAV_SEL0); \
nrf_gpio_pin_set(NIR_WAV_SEL1); \
nrf_gpio_pin_clear(NIR_WAV_SEL2)
#define LED40() nrf_gpio_pin_clear(LIGHT_ON); \
nrf_gpio_pin_set(NIR_PART_SEL); \
nrf_gpio_pin_clear(NIRLED_SEL0); \
nrf_gpio_pin_set(NIRLED_SEL1); \
nrf_gpio_pin_clear(NIR_WAV_SEL0); \
nrf_gpio_pin_clear(NIR_WAV_SEL1); \
nrf_gpio_pin_set(NIR_WAV_SEL2)
#define LED41() nrf_gpio_pin_clear(LIGHT_ON); \
nrf_gpio_pin_set(NIR_PART_SEL); \
nrf_gpio_pin_clear(NIRLED_SEL0); \
nrf_gpio_pin_set(NIRLED_SEL1); \
nrf_gpio_pin_set(NIR_WAV_SEL0); \
nrf_gpio_pin_clear(NIR_WAV_SEL1); \
nrf_gpio_pin_set(NIR_WAV_SEL2)
// Macros for LEDs 70 to 75 ( LIGHT_ON -->0)
#define LED42() nrf_gpio_pin_clear(LIGHT_ON); \
nrf_gpio_pin_set(NIR_PART_SEL); \
nrf_gpio_pin_set(NIRLED_SEL0); \
nrf_gpio_pin_set(NIRLED_SEL1); \
nrf_gpio_pin_clear(NIR_WAV_SEL0); \
nrf_gpio_pin_clear(NIR_WAV_SEL1); \
nrf_gpio_pin_clear(NIR_WAV_SEL2)
#define LED43() nrf_gpio_pin_clear(LIGHT_ON); \
nrf_gpio_pin_set(NIR_PART_SEL); \
nrf_gpio_pin_set(NIRLED_SEL0); \
nrf_gpio_pin_set(NIRLED_SEL1); \
nrf_gpio_pin_set(NIR_WAV_SEL0); \
nrf_gpio_pin_clear(NIR_WAV_SEL1); \
nrf_gpio_pin_clear(NIR_WAV_SEL2)
#define LED44() nrf_gpio_pin_clear(LIGHT_ON); \
nrf_gpio_pin_set(NIR_PART_SEL); \
nrf_gpio_pin_set(NIRLED_SEL0); \
nrf_gpio_pin_set(NIRLED_SEL1); \
nrf_gpio_pin_clear(NIR_WAV_SEL0); \
nrf_gpio_pin_set(NIR_WAV_SEL1); \
nrf_gpio_pin_clear(NIR_WAV_SEL2)
#define LED45() nrf_gpio_pin_clear(LIGHT_ON); \
nrf_gpio_pin_set(NIR_PART_SEL); \
nrf_gpio_pin_set(NIRLED_SEL0); \
nrf_gpio_pin_set(NIRLED_SEL1); \
nrf_gpio_pin_set(NIR_WAV_SEL0); \
nrf_gpio_pin_set(NIR_WAV_SEL1); \
nrf_gpio_pin_clear(NIR_WAV_SEL2)
#define LED46() nrf_gpio_pin_clear(LIGHT_ON); \
nrf_gpio_pin_set(NIR_PART_SEL); \
nrf_gpio_pin_set(NIRLED_SEL0); \
nrf_gpio_pin_set(NIRLED_SEL1); \
nrf_gpio_pin_clear(NIR_WAV_SEL0); \
nrf_gpio_pin_clear(NIR_WAV_SEL1); \
nrf_gpio_pin_set(NIR_WAV_SEL2)
#define LED47() nrf_gpio_pin_clear(LIGHT_ON); \
nrf_gpio_pin_set(NIR_PART_SEL); \
nrf_gpio_pin_set(NIRLED_SEL0); \
nrf_gpio_pin_set(NIRLED_SEL1); \
nrf_gpio_pin_set(NIR_WAV_SEL0); \
nrf_gpio_pin_clear(NIR_WAV_SEL1); \
nrf_gpio_pin_set(NIR_WAV_SEL2)
#define LED_ALLOFF() nrf_gpio_pin_clear(LIGHT_ON); \
nrf_gpio_pin_clear(NIR_PART_SEL); \
nrf_gpio_pin_set(NIRLED_SEL0); \
nrf_gpio_pin_set(NIRLED_SEL1); \
nrf_gpio_pin_set(NIR_WAV_SEL0); \
nrf_gpio_pin_set(NIR_WAV_SEL1); \
nrf_gpio_pin_set(NIR_WAV_SEL2)
#define LED99() nrf_gpio_pin_clear(LIGHT_ON); \
nrf_gpio_pin_clear(NIR_PART_SEL); \
nrf_gpio_pin_set(NIRLED_SEL0); \
nrf_gpio_pin_set(NIRLED_SEL1); \
nrf_gpio_pin_set(NIR_WAV_SEL0); \
nrf_gpio_pin_set(NIR_WAV_SEL1); \
nrf_gpio_pin_set(NIR_WAV_SEL2)
/*
#define LED23() nrf_gpio_pin_set(LIGHT_ON1);\
nrf_gpio_pin_set(LIGHT_ON2);\
nrf_gpio_pin_set(LIGHT_ON3);\
nrf_gpio_pin_clear(LIGHT_ON4);\
nrf_gpio_pin_clear(VCSEL_SW1);\
nrf_gpio_pin_clear(VCSEL_SW2);\
nrf_gpio_pin_set(VCSEL_SW3)
#define LED24() nrf_gpio_pin_set(LIGHT_ON1);\
nrf_gpio_pin_set(LIGHT_ON2);\
nrf_gpio_pin_set(LIGHT_ON3);\
nrf_gpio_pin_clear(LIGHT_ON4);\
nrf_gpio_pin_set(VCSEL_SW1);\
nrf_gpio_pin_clear(VCSEL_SW2);\
nrf_gpio_pin_set(VCSEL_SW3)
#define LED_ALLOFF() nrf_gpio_pin_clear(LIGHT_ON1);\
nrf_gpio_pin_clear(LIGHT_ON2);\
nrf_gpio_pin_clear(LIGHT_ON3);\
nrf_gpio_pin_clear(LIGHT_ON4);\
nrf_gpio_pin_set(VCSEL_SW1);\
nrf_gpio_pin_set(VCSEL_SW2);\
nrf_gpio_pin_set(VCSEL_SW3)
*/
/* For Photo Diode */
//#define MUX_EN_RDATA1 NRF_GPIO_PIN_MAP(1,6)
//#define MUX_EN_RDATA2 NRF_GPIO_PIN_MAP(1,5)
//#define MUX_EN_RDATA3 NRF_GPIO_PIN_MAP(1,4)
//
//#define RDATA_SW1 NRF_GPIO_PIN_MAP(0,23)
//#define RDATA_SW2 NRF_GPIO_PIN_MAP(0,22)
//#define RDATA_SW3 NRF_GPIO_PIN_MAP(0,21)
#define PD_SEL0 NRF_GPIO_PIN_MAP(1,12)
#define PD_SEL1 NRF_GPIO_PIN_MAP(1,11)
//#define PD_SEL3 NRF_GPIO_PIN_MAP(1,10) no use
#define PD_CONFIG() nrf_gpio_cfg_output(PD_SEL0);\
nrf_gpio_cfg_output(PD_SEL1)
#define PD0() nrf_gpio_pin_clear(PD_SEL0);\
nrf_gpio_pin_clear(PD_SEL1)
#define PD1() nrf_gpio_pin_set(PD_SEL0);\
nrf_gpio_pin_clear(PD_SEL1)
#define MOD() nrf_gpio_pin_clear(PD_SEL0);\
nrf_gpio_pin_set(PD_SEL1)
#define MOD2() nrf_gpio_pin_set(PD_SEL0);\
nrf_gpio_pin_set(PD_SEL1)
/*
#define PD4() nrf_gpio_pin_clear(MUX_EN_RDATA1);\
nrf_gpio_pin_set(MUX_EN_RDATA2);\
nrf_gpio_pin_set(MUX_EN_RDATA3);\
nrf_gpio_pin_set(RDATA_SW1);\
nrf_gpio_pin_set(RDATA_SW2);\
nrf_gpio_pin_clear(RDATA_SW3);\
nrf_gpio_pin_clear(PD_SEL1);\
nrf_gpio_pin_clear(PD_SEL2);\
nrf_gpio_pin_clear(PD_SEL3)
#define PD5() nrf_gpio_pin_clear(MUX_EN_RDATA1);\
nrf_gpio_pin_set(MUX_EN_RDATA2);\
nrf_gpio_pin_set(MUX_EN_RDATA3);\
nrf_gpio_pin_clear(RDATA_SW1);\
nrf_gpio_pin_clear(RDATA_SW2);\
nrf_gpio_pin_set(RDATA_SW3);\
nrf_gpio_pin_clear(PD_SEL1);\
nrf_gpio_pin_clear(PD_SEL2);\
nrf_gpio_pin_clear(PD_SEL3)
#define PD_ALLOFF() nrf_gpio_pin_clear(MUX_EN_RDATA1);\
nrf_gpio_pin_clear(MUX_EN_RDATA2);\
nrf_gpio_pin_clear(MUX_EN_RDATA3);\
nrf_gpio_pin_clear(RDATA_SW1);\
nrf_gpio_pin_clear(RDATA_SW2);\
nrf_gpio_pin_clear(RDATA_SW3);\
nrf_gpio_pin_set(PD_SEL1);\
nrf_gpio_pin_set(PD_SEL2);\
nrf_gpio_pin_set(PD_SEL3)
*/
#define PD_ALLOFF() nrf_gpio_pin_set(PD_SEL0);\
nrf_gpio_pin_set(PD_SEL1)
/* For IC_NZP */ // No USE for 3.0
//#define VCSEL_EN_PIN NRF_GPIO_PIN_MAP(1,7)
//#define VCSEL_CONFIG() nrf_gpio_cfg_output(VCSEL_EN_PIN)
//#define VCSEL_SW(x) if(x == true) nrf_gpio_pin_set(VCSEL_EN_PIN);\
// else if(x == false) nrf_gpio_pin_clear(VCSEL_EN_PIN)
/* For AGC SW FSA5157L6X */
#define GAIN_SW_PIN NRF_GPIO_PIN_MAP(0,20)
#define GAIN_SW_CONFIG() nrf_gpio_cfg_output(GAIN_SW_PIN)
#define AGC_GAIN_SW(x) if(x == true) nrf_gpio_pin_set(GAIN_SW_PIN);\
else if(x == false) nrf_gpio_pin_clear(GAIN_SW_PIN)
void led_pd_gain_array_printout(void);
ret_code_t led_on(uint8_t led_index);
ret_code_t led_off(uint8_t led_index);
ret_code_t led_pd_matching_value_set(uint8_t led_index);
ret_code_t led_pd_mod_set(uint16_t mod_gain);
ret_code_t pd_on(uint8_t pd_index);
ret_code_t pd_off(uint8_t pd_index);
int16_t led_power_read(uint8_t led_index);
void led_power_read_48(uint16_t *data);
ret_code_t led_power_save_mem(uint8_t led_index, int16_t led_power);
ret_code_t led_power_save_mem_6(uint8_t led_index, int16_t led_power);
ret_code_t led_power_save_mem_48( uint8_t *led_power);
ret_code_t led_power_set(uint8_t led_index);
ret_code_t pd_gain_set(uint8_t activated_led); //version B change 2025.04.27
ret_code_t imm_gain_set(uint16_t imm_dac); //version B add 2025.05.07
ret_code_t led_select(uint8_t led_index);
ret_code_t pd_select(uint8_t pd_index);
void led_power_span(uint8_t led_index);
void mea_send_loop(void * p_context); /* For x ms */
void mea_send_timer_start(void);
void mea_send_timer_stop(void);
void mea_send_timer_init(void);
#endif //_MEASUREMENTS_H__

657
project/ble_peripheral/ble_app_bladder_patch/measurements_20.c
View File

@@ -1,657 +0,0 @@
/*******************************************************************************
* @file measurements.c
* @author CandyPops Co.
* @version V1.0.0
* @date 2022-09-05
* @brief
******************************************************************************/
#include "sdk_common.h"
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include "nrf.h"
#include "nrf_drv_gpiote.h"
#include "nrf_drv_spi.h"
#include "nrf_drv_saadc.h"
#include "nrf_drv_ppi.h"
#include "nrf_drv_timer.h"
#include "boards.h"
#include "bsp.h"
#include "app_error.h"
#include "nrf_delay.h"
#include "app_util_platform.h"
#include "nrf_pwr_mgmt.h"
#include "nrf_log.h"
#include "ble_nus.h"
#include "app_timer.h"
#include "measurements.h"
#include "main.h"
#include "fstorage.h"
#include "ad5272_i2c.h"
#include "mcp4725_i2c.h"
uint8_t activated_led = 99;
uint8_t activated_pd = 99;
APP_TIMER_DEF(m_mea_send_loop_timer_id);
static uint8_t cnt =0;
#define MEA_SEND_LOOP_INTERVAL 100
char mea_tx_buffer[BLE_NUS_MAX_DATA_LEN];
extern volatile bool processing;
/* Default Value before initialized. Set value for Default!!! */ /* 초기값 설정 */
/* 0번은 사용하지 않음 = NULL, 1 ~ 24까지 사용 */
/*AD5272 DP에 쓸수 있는 값 범위는 0 ~ 1023 */
//uint16_t led_power_dp[LED_NUM] = {
// //NULL, 42, 29, 41, 31, 28, 28, 42, 28, 39, 29, 27, 27, 42, 29, 40, 30, 28, 28, 40, 27, 38, 28, 25, 22
// 0,25,25,18,19,24,24,25,25,18,19,25,23,25,25,18,19,24,24,25,25,19,20,25,24
//};
/*LED0 = NULL 사용하지 않음, LED1, LED2, LED3, LED4, LED5, LED6, LED7, LED8, LED9, LED10, LED11, LED12, LED13, LED14, LED15, LED16, LED17, LED18, LED19, LED20, LED21, LED22, LED23, LED24 */
/*MCP4725 를 0.1V(125) ~ 1.1V(1366) 값을 사용 */
//uint16_t led_pd_dac_v[PD_NUM][LED_NUM] = {
// {NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL}, /*PD0 사용 않음 */
// {NULL, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}, /* PD1 */
// {NULL, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}, /* PD2 */
// {NULL, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}, /* PD3 */
// {NULL, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}, /* PD4 */
// {NULL, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}, /* PD5 */
// {NULL, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}, /* PD6 */
// {NULL, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}, /* PD7 */
// {NULL, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}, /* PD8 */
// {NULL, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}, /* PD9 */
// {NULL, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}, /* PD10 */
// {NULL, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}, /* PD11 */
// {NULL, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}, /* PD12 */
// {NULL, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}, /* PD13 */
// {NULL, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}, /* PD14 */
// {NULL, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}, /* PD15 */
// {NULL, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}, /* PD16 */
// {NULL, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}, /* PD17 */
// {NULL, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}, /* PD18 */
// {NULL, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}, /* PD19 */
// {NULL, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}, /* PD20 */
//};
void led_pd_gain_array_printout(void)
{
// printf("\r\nLED-DP Gain Array =\r\n");
// for(uint16_t i = 0; i < LED_NUM; i++){
// printf("%d,\t", led_power_dp[i]);
// }
// printf("\r\n");
// printf("\r\nLED-PD Gain Array =\r\n");
// for(uint16_t i = 0; i < PD_NUM; i++){
// for(uint16_t j = 0; j < LED_NUM; j++){
// printf("%d,\t", led_pd_dac_v[i][j]);
// }
// break;
// printf("\r\n");
// }
// printf("\r\n");
// nrf_delay_ms(5);
cnt=0;
mea_send_timer_start();
}
void mea_send_loop(void * p_context) /* For x ms */
{
UNUSED_PARAMETER(p_context);
printf("\r\n1CNT =%d\r\n",cnt);
mea_send_timer_stop();
if (cnt < 21)
{
uint8_t i = cnt;
sprintf(mea_tx_buffer, "Tag-Currrnt %d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d\r\n", i, m_config.led_pd_dac_v[i][0], m_config.led_pd_dac_v[i][1], m_config.led_pd_dac_v[i][2], m_config.led_pd_dac_v[i][3], m_config.led_pd_dac_v[i][4], m_config.led_pd_dac_v[i][5], m_config.led_pd_dac_v[i][6], m_config.led_pd_dac_v[i][7],m_config.led_pd_dac_v[i][8], m_config.led_pd_dac_v[i][9], m_config.led_pd_dac_v[i][10],
m_config.led_pd_dac_v[i][11], m_config.led_pd_dac_v[i][12], m_config.led_pd_dac_v[i][13], m_config.led_pd_dac_v[i][14], m_config.led_pd_dac_v[i][15], m_config.led_pd_dac_v[i][16], m_config.led_pd_dac_v[i][17],m_config.led_pd_dac_v[i][18], m_config.led_pd_dac_v[i][19], m_config.led_pd_dac_v[i][20], m_config.led_pd_dac_v[i][21],m_config.led_pd_dac_v[i][22], m_config.led_pd_dac_v[i][23], m_config.led_pd_dac_v[i][24]);
data_tx_handler(mea_tx_buffer);
printf("\r\n2CNT =%d\r\n",cnt);
mea_send_timer_start();
// switch(cnt){
// case 0:
// break;
// case 1:
// sprintf(mea_tx_buffer, "Tag-Currrnt %d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d\r\n", i, 0,m_config.led_pd_dac_v_led_1[1], m_config.led_pd_dac_v_led_2[1], m_config.led_pd_dac_v_led_3[1], m_config.led_pd_dac_v_led_4[1], m_config.led_pd_dac_v_led_5[1], m_config.led_pd_dac_v_led_6[1], m_config.led_pd_dac_v_led_7[1], m_config.led_pd_dac_v_led_8[1],
// m_config.led_pd_dac_v_led_9[1], m_config.led_pd_dac_v_led_10[1], m_config.led_pd_dac_v_led_11[1], m_config.led_pd_dac_v_led_12[1], m_config.led_pd_dac_v_led_13[1], m_config.led_pd_dac_v_led_14[1], m_config.led_pd_dac_v_led_15[1], m_config.led_pd_dac_v_led_16[1], m_config.led_pd_dac_v_led_17[1],m_config.led_pd_dac_v_led_18[1],
// m_config.led_pd_dac_v_led_19[1], m_config.led_pd_dac_v_led_20[1],m_config.led_pd_dac_v_led_21[1], m_config.led_pd_dac_v_led_22[1],m_config.led_pd_dac_v_led_23[1], m_config.led_pd_dac_v_led_24[1]);
// break;
// case 2:
// sprintf(mea_tx_buffer, "Tag-Currrnt %d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d\r\n", i, 0, m_config.led_pd_dac_v_led_1[1], m_config.led_pd_dac_v_led_2[1], m_config.led_pd_dac_v_led_3[1], m_config.led_pd_dac_v_led_4[1], m_config.led_pd_dac_v_led_5[1], m_config.led_pd_dac_v_led_6[1], m_config.led_pd_dac_v_led_7[1], m_config.led_pd_dac_v_led_8[1],
// m_config.led_pd_dac_v_led_9[1], m_config.led_pd_dac_v_led_10[1], m_config.led_pd_dac_v_led_11[1], m_config.led_pd_dac_v_led_12[1], m_config.led_pd_dac_v_led_13[1], m_config.led_pd_dac_v_led_14[1], m_config.led_pd_dac_v_led_15[1], m_config.led_pd_dac_v_led_16[1], m_config.led_pd_dac_v_led_17[1],m_config.led_pd_dac_v_led_18[1],
// m_config.led_pd_dac_v_led_19[1], m_config.led_pd_dac_v_led_20[1],m_config.led_pd_dac_v_led_21[1], m_config.led_pd_dac_v_led_22[1],m_config.led_pd_dac_v_led_23[1], m_config.led_pd_dac_v_led_24[1]);
// break;
// case 3:
// sprintf(mea_tx_buffer, "Tag-Currrnt %d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d,\t%d\r\n", i,0, m_config.led_pd_dac_v_led_1[1], m_config.led_pd_dac_v_led_2[1], m_config.led_pd_dac_v_led_3[1], m_config.led_pd_dac_v_led_4[1], m_config.led_pd_dac_v_led_5[1], m_config.led_pd_dac_v_led_6[1], m_config.led_pd_dac_v_led_7[1], m_config.led_pd_dac_v_led_8[1],
// m_config.led_pd_dac_v_led_9[1], m_config.led_pd_dac_v_led_10[1], m_config.led_pd_dac_v_led_11[1], m_config.led_pd_dac_v_led_12[1], m_config.led_pd_dac_v_led_13[1], m_config.led_pd_dac_v_led_14[1], m_config.led_pd_dac_v_led_15[1], m_config.led_pd_dac_v_led_16[1], m_config.led_pd_dac_v_led_17[1],m_config.led_pd_dac_v_led_18[1],
// m_config.led_pd_dac_v_led_19[1], m_config.led_pd_dac_v_led_20[1],m_config.led_pd_dac_v_led_21[1], m_config.led_pd_dac_v_led_22[1],m_config.led_pd_dac_v_led_23[1], m_config.led_pd_dac_v_led_24[1]);
// break;
// default:
// break;
//// }
// sprintf(mea_tx_buffer,"CNT_%d\r\n",cnt);
// data_tx_handler(mea_tx_buffer);
//
// mea_send_timer_start();
}
else
{
//battery_timer_start();
sprintf(mea_tx_buffer,"END \r\n");
data_tx_handler(mea_tx_buffer);
printf("\r\nLED-DP Gain Array =\r\n");
for(uint16_t i = 0; i < LED_NUM; i++){
printf("%d,\t", m_config.led_power_dp[i]);
}
printf("\r\n");
printf("\r\nLED-PD Gain Array =\r\n");
for(uint16_t i = 0; i < PD_NUM; i++){
for(uint16_t j = 0; j < LED_NUM; j++){
printf("%d,\t", m_config.led_pd_dac_v[i][j]);
}
///break;
printf("\r\n");
}
printf("\r\n");
processing = false ;
}
cnt++;
}
ret_code_t led_on(uint8_t led_index)
{
uint32_t err_code = NRF_SUCCESS;
#if FEATURE_PRINTF
printf("\tled_on, %d =====================\r\n", led_index);
#endif
if((led_index >= 1)&&(led_index <= 24)){
activated_led = led_index;
/* LED켤때 파워 셋팅한후 켜는지 결정요 */
if(NRF_SUCCESS != led_power_set(led_index)) {
printf("ERR!!! LED Power set\r\n");
return NRF_ERROR_INTERNAL;
}
#if FEATURE_FOR_SCOPE
nrf_gpio_pin_set(LED_CLK_15);
nrf_gpio_pin_clear(LED_CLK_15);
#endif
if(NRF_SUCCESS != led_select(led_index)){
printf("ERR!!! LED Select\r\n");
return NRF_ERROR_INTERNAL;
}
VCSEL_SW(true);
}else{
printf("ERR!!! led_index Failed! %d\r\n", led_index);
return NRF_ERROR_INTERNAL;
}
return err_code;
}
ret_code_t led_off(uint8_t led_index)
{
uint32_t err_code = NRF_SUCCESS;
#if FEATURE_PRINTF
printf("led_off\r\n");
#endif
if(led_index == 99){
LED_ALLOFF();
VCSEL_SW(false);
activated_led = 99;
}else{
printf("ERR!!! led_index Failed! %d\r\n", led_index);
return NRF_ERROR_INTERNAL;
}
return err_code;
}
ret_code_t led_pd_matching_value_set(uint8_t led_index, uint8_t pd_index)
{
uint32_t err_code = NRF_SUCCESS;
if(((led_index >= 1)&&(led_index <= 24))||((pd_index >= 1)&&(pd_index <= 20))){
if(NRF_SUCCESS != pd_gain_set(led_index, pd_index)){
printf("ERR!!! pd_gain_set\r\n");
return NRF_ERROR_INTERNAL;
}
if(NRF_SUCCESS != pd_on(pd_index)){
printf("ERR!!! pd_on\r\n");
return NRF_ERROR_INTERNAL;
}
}else{
printf("ERR!!! led_index || pd_index Failed! %d, %d\r\n", led_index, pd_index);
return NRF_ERROR_INTERNAL;
}
return err_code;
}
ret_code_t pd_on(uint8_t pd_index)
{
uint32_t err_code = NRF_SUCCESS;
#if FEATURE_FOR_SCOPE
nrf_gpio_pin_set(PD_CLK_26);
nrf_gpio_pin_clear(PD_CLK_26);
#endif
#if FEATURE_PRINTF
printf("pd_on, %d ===== \r\n", pd_index);
#endif
if((pd_index >= 1)&&(pd_index <= 20)){
activated_pd = pd_index;
if(NRF_SUCCESS != pd_select(pd_index)){
printf("ERR!!! pd_on Failed! %d\r\n", pd_index);
return NRF_ERROR_INTERNAL;
}
}else{
printf("ERR!!! pd_index Failed! %d\r\n", pd_index);
return NRF_ERROR_INTERNAL;
}
return err_code;
}
ret_code_t pd_off(uint8_t pd_index)
{
uint32_t err_code = NRF_SUCCESS;
#if FEATURE_PRINTF
printf("pd_off\r\n");
#endif
if(pd_index == 99){
PD_ALLOFF();
activated_pd = 99;
}else{
printf("ERR!!! PD Off Failed! %d\r\n", pd_index);
return NRF_ERROR_INTERNAL;
}
return err_code;
}
int16_t led_power_read(uint8_t led_index)
{
int16_t led_power;
if((led_index >= 1)&&(led_index <= 24)){
led_power = m_config.led_power_dp[led_index];
}else{
printf("ERR!!! led_index Failed! %d\r\n", led_index);
return NRF_ERROR_INTERNAL;
}
return led_power;
}
ret_code_t led_power_save_mem(uint8_t led_index, int16_t led_power) /* 커맨드에 의해서 LED파워 값을 저장할때 */
{
uint32_t err_code = NRF_SUCCESS;
if(((led_index >= 1)&&(led_index <= 24))||((led_power >= 0)&&(led_power <= 1023))){
m_config.led_power_dp[led_index] = led_power;
if(activated_led == led_index) { /* LED파워 값을 RDAC에도 설정함. */
if(NRF_SUCCESS != ad5272_write_rdac(led_power)){
printf("ERR!!! ad5272_write_rdac 1\r\n");
err_code = NRF_ERROR_INTERNAL;
}
}
}else{
printf("ERR!!! led_index || pd_index Failed! %d, %d\r\n", led_index, led_power);
return NRF_ERROR_INTERNAL;
}
return err_code;
}
ret_code_t led_power_set(uint8_t led_index) /* LED켤때 사용, 메모리 값을 디지털포텐셔미터에 입력 */
{
uint32_t err_code = NRF_SUCCESS;
int16_t led_power;
if((led_index >= 1)&&(led_index <= 24)){
led_power = m_config.led_power_dp[led_index];
if(NRF_SUCCESS != ad5272_write_rdac(led_power)) { /* LED를 켜기전에 메모리에 저장된 파워값을 DAC에 설정 */
printf("ERR!!! ad5272_write_rdac 2\r\n");
err_code = NRF_ERROR_INTERNAL;
}
}else{
printf("ERR!!! led_index Failed! %d\r\n", led_index);
return NRF_ERROR_INTERNAL;
}
return err_code;
}
ret_code_t pd_gain_set(uint8_t activated_led, uint8_t pd_index) /* LED와 PD 매칭 값으로 On */
{
uint32_t err_code = NRF_SUCCESS;
#if FEATURE_PRINTF
printf("<<pd_gain_set L%d, P%d>>\r\n",activated_led ,pd_index);
#endif
if(((activated_led >= 1)&&(activated_led <= 24))||((pd_index >= 1)&&(pd_index <= 20))){
mcp4725_writeFastMode( m_config.led_pd_dac_v[pd_index][activated_led]); /* LED는 먼저 ON되어 있어 하며 그 LED번호와 PD배칭 값으로 DAC에 설정 */
}else{
printf("ERR!!! led_index || pd_index Failed! %d, %d\r\n", activated_led, pd_index);
return NRF_ERROR_INTERNAL;
}
return err_code;
}
ret_code_t led_select(uint8_t led_index)
{
uint32_t err_code = NRF_SUCCESS;
LED_ALLOFF();
VCSEL_SW(false);
switch(led_index) {
case 1:
LED1();
break;
case 2:
LED2();
break;
case 3:
LED3();
break;
case 4:
LED4();
break;
case 5:
LED5();
break;
case 6:
LED6();
break;
case 7:
LED7();
break;
case 8:
LED8();
break;
case 9:
LED9();
break;
case 10:
LED10();
break;
case 11:
LED11();
break;
case 12:
LED12();
break;
case 13:
LED13();
break;
case 14:
LED14();
break;
case 15:
LED15();
break;
case 16:
LED16();
break;
case 17:
LED17();
break;
case 18:
LED18();
break;
case 19:
LED19();
break;
case 20:
LED20();
break;
case 21:
LED21();
break;
case 22:
LED22();
break;
case 23:
LED23();
break;
case 24:
LED24();
break;
default:
err_code = NRF_ERROR_NOT_FOUND;
break;
}
return err_code;
}
ret_code_t pd_select(uint8_t pd_index)
{
uint32_t err_code = NRF_SUCCESS;
PD_ALLOFF();
switch(pd_index) {
case 1:
PD1();
break;
case 2:
PD2();
break;
case 3:
PD3();
break;
case 4:
PD4();
break;
case 5:
PD5();
break;
case 6:
PD6();
break;
case 7:
PD7();
break;
case 8:
PD8();
break;
case 9:
PD9();
break;
case 10:
PD10();
break;
case 11:
PD11();
break;
case 12:
PD12();
break;
case 13:
PD13();
break;
case 14:
PD14();
break;
case 15:
PD15();
break;
case 16:
PD16();
break;
case 17:
PD17();
break;
case 18:
PD18();
break;
case 19:
PD19();
break;
case 20:
PD20();
break;
default:
err_code = NRF_ERROR_NOT_FOUND;
break;
}
return err_code;
}
void mea_send_timer_start(void)
{
APP_ERROR_CHECK(app_timer_start(m_mea_send_loop_timer_id, APP_TIMER_TICKS(MEA_SEND_LOOP_INTERVAL), NULL));
}
void mea_send_timer_stop(void)
{
APP_ERROR_CHECK(app_timer_stop(m_mea_send_loop_timer_id));
}
void mea_send_timer_init(void)
{
APP_ERROR_CHECK(app_timer_create(&m_mea_send_loop_timer_id, APP_TIMER_MODE_SINGLE_SHOT, mea_send_loop));
}

519
project/ble_peripheral/ble_app_bladder_patch/measurements_20.h
View File

@@ -1,519 +0,0 @@
/*******************************************************************************
* @file measurements.h
* @author CandyPops Co.
* @version V1.0.0
* @date 2022-09-05
* @brief
******************************************************************************/
#ifndef _MEASUREMENTS_H__
#define _MEASUREMENTS_H__
#include "sdk_common.h"
#include <stdbool.h>
#include "nrf.h"
#include "nrf_drv_gpiote.h"
/* For NIR LED */
#define LIGHT_ON1 NRF_GPIO_PIN_MAP(0,28)
#define LIGHT_ON2 NRF_GPIO_PIN_MAP(0,29)
#define LIGHT_ON3 NRF_GPIO_PIN_MAP(0,31)
#define LIGHT_ON4 NRF_GPIO_PIN_MAP(0,19)
#define VCSEL_SW1 NRF_GPIO_PIN_MAP(1,1)
#define VCSEL_SW2 NRF_GPIO_PIN_MAP(1,2)
#define VCSEL_SW3 NRF_GPIO_PIN_MAP(1,3)
#define LED_CONFIG() nrf_gpio_cfg_output(LIGHT_ON1);\
nrf_gpio_cfg_output(LIGHT_ON2);\
nrf_gpio_cfg_output(LIGHT_ON3);\
nrf_gpio_cfg_output(LIGHT_ON4);\
nrf_gpio_cfg_output(VCSEL_SW1);\
nrf_gpio_cfg_output(VCSEL_SW2);\
nrf_gpio_cfg_output(VCSEL_SW3)
#define LED1() nrf_gpio_pin_clear(LIGHT_ON1);\
nrf_gpio_pin_set(LIGHT_ON2);\
nrf_gpio_pin_set(LIGHT_ON3);\
nrf_gpio_pin_set(LIGHT_ON4);\
nrf_gpio_pin_clear(VCSEL_SW1);\
nrf_gpio_pin_clear(VCSEL_SW2);\
nrf_gpio_pin_clear(VCSEL_SW3)
#define LED2() nrf_gpio_pin_clear(LIGHT_ON1);\
nrf_gpio_pin_set(LIGHT_ON2);\
nrf_gpio_pin_set(LIGHT_ON3);\
nrf_gpio_pin_set(LIGHT_ON4);\
nrf_gpio_pin_set(VCSEL_SW1);\
nrf_gpio_pin_clear(VCSEL_SW2);\
nrf_gpio_pin_clear(VCSEL_SW3)
#define LED3() nrf_gpio_pin_clear(LIGHT_ON1);\
nrf_gpio_pin_set(LIGHT_ON2);\
nrf_gpio_pin_set(LIGHT_ON3);\
nrf_gpio_pin_set(LIGHT_ON4);\
nrf_gpio_pin_clear(VCSEL_SW1);\
nrf_gpio_pin_set(VCSEL_SW2);\
nrf_gpio_pin_clear(VCSEL_SW3)
#define LED4() nrf_gpio_pin_clear(LIGHT_ON1);\
nrf_gpio_pin_set(LIGHT_ON2);\
nrf_gpio_pin_set(LIGHT_ON3);\
nrf_gpio_pin_set(LIGHT_ON4);\
nrf_gpio_pin_set(VCSEL_SW1);\
nrf_gpio_pin_set(VCSEL_SW2);\
nrf_gpio_pin_clear(VCSEL_SW3)
#define LED5() nrf_gpio_pin_clear(LIGHT_ON1);\
nrf_gpio_pin_set(LIGHT_ON2);\
nrf_gpio_pin_set(LIGHT_ON3);\
nrf_gpio_pin_set(LIGHT_ON4);\
nrf_gpio_pin_clear(VCSEL_SW1);\
nrf_gpio_pin_clear(VCSEL_SW2);\
nrf_gpio_pin_set(VCSEL_SW3)
#define LED6() nrf_gpio_pin_clear(LIGHT_ON1);\
nrf_gpio_pin_set(LIGHT_ON2);\
nrf_gpio_pin_set(LIGHT_ON3);\
nrf_gpio_pin_set(LIGHT_ON4);\
nrf_gpio_pin_set(VCSEL_SW1);\
nrf_gpio_pin_clear(VCSEL_SW2);\
nrf_gpio_pin_set(VCSEL_SW3)
#define LED7() nrf_gpio_pin_set(LIGHT_ON1);\
nrf_gpio_pin_clear(LIGHT_ON2);\
nrf_gpio_pin_set(LIGHT_ON3);\
nrf_gpio_pin_set(LIGHT_ON4);\
nrf_gpio_pin_clear(VCSEL_SW1);\
nrf_gpio_pin_clear(VCSEL_SW2);\
nrf_gpio_pin_clear(VCSEL_SW3)
#define LED8() nrf_gpio_pin_set(LIGHT_ON1);\
nrf_gpio_pin_clear(LIGHT_ON2);\
nrf_gpio_pin_set(LIGHT_ON3);\
nrf_gpio_pin_set(LIGHT_ON4);\
nrf_gpio_pin_set(VCSEL_SW1);\
nrf_gpio_pin_clear(VCSEL_SW2);\
nrf_gpio_pin_clear(VCSEL_SW3)
#define LED9() nrf_gpio_pin_set(LIGHT_ON1);\
nrf_gpio_pin_clear(LIGHT_ON2);\
nrf_gpio_pin_set(LIGHT_ON3);\
nrf_gpio_pin_set(LIGHT_ON4);\
nrf_gpio_pin_clear(VCSEL_SW1);\
nrf_gpio_pin_set(VCSEL_SW2);\
nrf_gpio_pin_clear(VCSEL_SW3)
#define LED10() nrf_gpio_pin_set(LIGHT_ON1);\
nrf_gpio_pin_clear(LIGHT_ON2);\
nrf_gpio_pin_set(LIGHT_ON3);\
nrf_gpio_pin_set(LIGHT_ON4);\
nrf_gpio_pin_set(VCSEL_SW1);\
nrf_gpio_pin_set(VCSEL_SW2);\
nrf_gpio_pin_clear(VCSEL_SW3)
#define LED11() nrf_gpio_pin_set(LIGHT_ON1);\
nrf_gpio_pin_clear(LIGHT_ON2);\
nrf_gpio_pin_set(LIGHT_ON3);\
nrf_gpio_pin_set(LIGHT_ON4);\
nrf_gpio_pin_clear(VCSEL_SW1);\
nrf_gpio_pin_clear(VCSEL_SW2);\
nrf_gpio_pin_set(VCSEL_SW3)
#define LED12() nrf_gpio_pin_set(LIGHT_ON1);\
nrf_gpio_pin_clear(LIGHT_ON2);\
nrf_gpio_pin_set(LIGHT_ON3);\
nrf_gpio_pin_set(LIGHT_ON4);\
nrf_gpio_pin_set(VCSEL_SW1);\
nrf_gpio_pin_clear(VCSEL_SW2);\
nrf_gpio_pin_set(VCSEL_SW3)
#define LED13() nrf_gpio_pin_set(LIGHT_ON1);\
nrf_gpio_pin_set(LIGHT_ON2);\
nrf_gpio_pin_clear(LIGHT_ON3);\
nrf_gpio_pin_set(LIGHT_ON4);\
nrf_gpio_pin_clear(VCSEL_SW1);\
nrf_gpio_pin_clear(VCSEL_SW2);\
nrf_gpio_pin_clear(VCSEL_SW3)
#define LED14() nrf_gpio_pin_set(LIGHT_ON1);\
nrf_gpio_pin_set(LIGHT_ON2);\
nrf_gpio_pin_clear(LIGHT_ON3);\
nrf_gpio_pin_set(LIGHT_ON4);\
nrf_gpio_pin_set(VCSEL_SW1);\
nrf_gpio_pin_clear(VCSEL_SW2);\
nrf_gpio_pin_clear(VCSEL_SW3)
#define LED15() nrf_gpio_pin_set(LIGHT_ON1);\
nrf_gpio_pin_set(LIGHT_ON2);\
nrf_gpio_pin_clear(LIGHT_ON3);\
nrf_gpio_pin_set(LIGHT_ON4);\
nrf_gpio_pin_clear(VCSEL_SW1);\
nrf_gpio_pin_set(VCSEL_SW2);\
nrf_gpio_pin_clear(VCSEL_SW3)
#define LED16() nrf_gpio_pin_set(LIGHT_ON1);\
nrf_gpio_pin_set(LIGHT_ON2);\
nrf_gpio_pin_clear(LIGHT_ON3);\
nrf_gpio_pin_set(LIGHT_ON4);\
nrf_gpio_pin_set(VCSEL_SW1);\
nrf_gpio_pin_set(VCSEL_SW2);\
nrf_gpio_pin_clear(VCSEL_SW3)
#define LED17() nrf_gpio_pin_set(LIGHT_ON1);\
nrf_gpio_pin_set(LIGHT_ON2);\
nrf_gpio_pin_clear(LIGHT_ON3);\
nrf_gpio_pin_set(LIGHT_ON4);\
nrf_gpio_pin_clear(VCSEL_SW1);\
nrf_gpio_pin_clear(VCSEL_SW2);\
nrf_gpio_pin_set(VCSEL_SW3)
#define LED18() nrf_gpio_pin_set(LIGHT_ON1);\
nrf_gpio_pin_set(LIGHT_ON2);\
nrf_gpio_pin_clear(LIGHT_ON3);\
nrf_gpio_pin_set(LIGHT_ON4);\
nrf_gpio_pin_set(VCSEL_SW1);\
nrf_gpio_pin_clear(VCSEL_SW2);\
nrf_gpio_pin_set(VCSEL_SW3)
#define LED19() nrf_gpio_pin_set(LIGHT_ON1);\
nrf_gpio_pin_set(LIGHT_ON2);\
nrf_gpio_pin_set(LIGHT_ON3);\
nrf_gpio_pin_clear(LIGHT_ON4);\
nrf_gpio_pin_clear(VCSEL_SW1);\
nrf_gpio_pin_clear(VCSEL_SW2);\
nrf_gpio_pin_clear(VCSEL_SW3)
#define LED20() nrf_gpio_pin_set(LIGHT_ON1);\
nrf_gpio_pin_set(LIGHT_ON2);\
nrf_gpio_pin_set(LIGHT_ON3);\
nrf_gpio_pin_clear(LIGHT_ON4);\
nrf_gpio_pin_set(VCSEL_SW1);\
nrf_gpio_pin_clear(VCSEL_SW2);\
nrf_gpio_pin_clear(VCSEL_SW3)
#define LED21() nrf_gpio_pin_set(LIGHT_ON1);\
nrf_gpio_pin_set(LIGHT_ON2);\
nrf_gpio_pin_set(LIGHT_ON3);\
nrf_gpio_pin_clear(LIGHT_ON4);\
nrf_gpio_pin_clear(VCSEL_SW1);\
nrf_gpio_pin_set(VCSEL_SW2);\
nrf_gpio_pin_clear(VCSEL_SW3)
#define LED22() nrf_gpio_pin_set(LIGHT_ON1);\
nrf_gpio_pin_set(LIGHT_ON2);\
nrf_gpio_pin_set(LIGHT_ON3);\
nrf_gpio_pin_clear(LIGHT_ON4);\
nrf_gpio_pin_set(VCSEL_SW1);\
nrf_gpio_pin_set(VCSEL_SW2);\
nrf_gpio_pin_clear(VCSEL_SW3)
#define LED23() nrf_gpio_pin_set(LIGHT_ON1);\
nrf_gpio_pin_set(LIGHT_ON2);\
nrf_gpio_pin_set(LIGHT_ON3);\
nrf_gpio_pin_clear(LIGHT_ON4);\
nrf_gpio_pin_clear(VCSEL_SW1);\
nrf_gpio_pin_clear(VCSEL_SW2);\
nrf_gpio_pin_set(VCSEL_SW3)
#define LED24() nrf_gpio_pin_set(LIGHT_ON1);\
nrf_gpio_pin_set(LIGHT_ON2);\
nrf_gpio_pin_set(LIGHT_ON3);\
nrf_gpio_pin_clear(LIGHT_ON4);\
nrf_gpio_pin_set(VCSEL_SW1);\
nrf_gpio_pin_clear(VCSEL_SW2);\
nrf_gpio_pin_set(VCSEL_SW3)
#define LED_ALLOFF() nrf_gpio_pin_clear(LIGHT_ON1);\
nrf_gpio_pin_clear(LIGHT_ON2);\
nrf_gpio_pin_clear(LIGHT_ON3);\
nrf_gpio_pin_clear(LIGHT_ON4);\
nrf_gpio_pin_set(VCSEL_SW1);\
nrf_gpio_pin_set(VCSEL_SW2);\
nrf_gpio_pin_set(VCSEL_SW3)
/* For Photo Diode */
#define MUX_EN_RDATA1 NRF_GPIO_PIN_MAP(1,6)
#define MUX_EN_RDATA2 NRF_GPIO_PIN_MAP(1,5)
#define MUX_EN_RDATA3 NRF_GPIO_PIN_MAP(1,4)
#define RDATA_SW1 NRF_GPIO_PIN_MAP(0,23)
#define RDATA_SW2 NRF_GPIO_PIN_MAP(0,22)
#define RDATA_SW3 NRF_GPIO_PIN_MAP(0,21)
#define PD_SEL1 NRF_GPIO_PIN_MAP(1,12)
#define PD_SEL2 NRF_GPIO_PIN_MAP(1,11)
#define PD_SEL3 NRF_GPIO_PIN_MAP(1,10)
#define PD_CONFIG() nrf_gpio_cfg_output(MUX_EN_RDATA1);\
nrf_gpio_cfg_output(MUX_EN_RDATA2);\
nrf_gpio_cfg_output(MUX_EN_RDATA3);\
nrf_gpio_cfg_output(RDATA_SW1);\
nrf_gpio_cfg_output(RDATA_SW2);\
nrf_gpio_cfg_output(RDATA_SW3);\
nrf_gpio_cfg_output(PD_SEL1);\
nrf_gpio_cfg_output(PD_SEL2);\
nrf_gpio_cfg_output(PD_SEL3)
#define PD1() nrf_gpio_pin_clear(MUX_EN_RDATA1);\
nrf_gpio_pin_set(MUX_EN_RDATA2);\
nrf_gpio_pin_set(MUX_EN_RDATA3);\
nrf_gpio_pin_clear(RDATA_SW1);\
nrf_gpio_pin_clear(RDATA_SW2);\
nrf_gpio_pin_clear(RDATA_SW3);\
nrf_gpio_pin_clear(PD_SEL1);\
nrf_gpio_pin_clear(PD_SEL2);\
nrf_gpio_pin_clear(PD_SEL3)
#define PD2() nrf_gpio_pin_clear(MUX_EN_RDATA1);\
nrf_gpio_pin_set(MUX_EN_RDATA2);\
nrf_gpio_pin_set(MUX_EN_RDATA3);\
nrf_gpio_pin_set(RDATA_SW1);\
nrf_gpio_pin_clear(RDATA_SW2);\
nrf_gpio_pin_clear(RDATA_SW3);\
nrf_gpio_pin_clear(PD_SEL1);\
nrf_gpio_pin_clear(PD_SEL2);\
nrf_gpio_pin_clear(PD_SEL3)
#define PD3() nrf_gpio_pin_clear(MUX_EN_RDATA1);\
nrf_gpio_pin_set(MUX_EN_RDATA2);\
nrf_gpio_pin_set(MUX_EN_RDATA3);\
nrf_gpio_pin_clear(RDATA_SW1);\
nrf_gpio_pin_set(RDATA_SW2);\
nrf_gpio_pin_clear(RDATA_SW3);\
nrf_gpio_pin_clear(PD_SEL1);\
nrf_gpio_pin_clear(PD_SEL2);\
nrf_gpio_pin_clear(PD_SEL3)
#define PD4() nrf_gpio_pin_clear(MUX_EN_RDATA1);\
nrf_gpio_pin_set(MUX_EN_RDATA2);\
nrf_gpio_pin_set(MUX_EN_RDATA3);\
nrf_gpio_pin_set(RDATA_SW1);\
nrf_gpio_pin_set(RDATA_SW2);\
nrf_gpio_pin_clear(RDATA_SW3);\
nrf_gpio_pin_clear(PD_SEL1);\
nrf_gpio_pin_clear(PD_SEL2);\
nrf_gpio_pin_clear(PD_SEL3)
#define PD5() nrf_gpio_pin_clear(MUX_EN_RDATA1);\
nrf_gpio_pin_set(MUX_EN_RDATA2);\
nrf_gpio_pin_set(MUX_EN_RDATA3);\
nrf_gpio_pin_clear(RDATA_SW1);\
nrf_gpio_pin_clear(RDATA_SW2);\
nrf_gpio_pin_set(RDATA_SW3);\
nrf_gpio_pin_clear(PD_SEL1);\
nrf_gpio_pin_clear(PD_SEL2);\
nrf_gpio_pin_clear(PD_SEL3)
#define PD6() nrf_gpio_pin_clear(MUX_EN_RDATA1);\
nrf_gpio_pin_set(MUX_EN_RDATA2);\
nrf_gpio_pin_set(MUX_EN_RDATA3);\
nrf_gpio_pin_set(RDATA_SW1);\
nrf_gpio_pin_clear(RDATA_SW2);\
nrf_gpio_pin_set(RDATA_SW3);\
nrf_gpio_pin_clear(PD_SEL1);\
nrf_gpio_pin_clear(PD_SEL2);\
nrf_gpio_pin_clear(PD_SEL3)
#define PD7() nrf_gpio_pin_clear(MUX_EN_RDATA1);\
nrf_gpio_pin_set(MUX_EN_RDATA2);\
nrf_gpio_pin_set(MUX_EN_RDATA3);\
nrf_gpio_pin_clear(RDATA_SW1);\
nrf_gpio_pin_set(RDATA_SW2);\
nrf_gpio_pin_set(RDATA_SW3);\
nrf_gpio_pin_clear(PD_SEL1);\
nrf_gpio_pin_clear(PD_SEL2);\
nrf_gpio_pin_clear(PD_SEL3)
#define PD8() nrf_gpio_pin_clear(MUX_EN_RDATA1);\
nrf_gpio_pin_set(MUX_EN_RDATA2);\
nrf_gpio_pin_set(MUX_EN_RDATA3);\
nrf_gpio_pin_set(RDATA_SW1);\
nrf_gpio_pin_set(RDATA_SW2);\
nrf_gpio_pin_set(RDATA_SW3);\
nrf_gpio_pin_clear(PD_SEL1);\
nrf_gpio_pin_clear(PD_SEL2);\
nrf_gpio_pin_clear(PD_SEL3)
#define PD9() nrf_gpio_pin_set(MUX_EN_RDATA1);\
nrf_gpio_pin_clear(MUX_EN_RDATA2);\
nrf_gpio_pin_set(MUX_EN_RDATA3);\
nrf_gpio_pin_clear(RDATA_SW1);\
nrf_gpio_pin_clear(RDATA_SW2);\
nrf_gpio_pin_clear(RDATA_SW3);\
nrf_gpio_pin_set(PD_SEL1);\
nrf_gpio_pin_clear(PD_SEL2);\
nrf_gpio_pin_clear(PD_SEL3)
#define PD10() nrf_gpio_pin_set(MUX_EN_RDATA1);\
nrf_gpio_pin_clear(MUX_EN_RDATA2);\
nrf_gpio_pin_set(MUX_EN_RDATA3);\
nrf_gpio_pin_set(RDATA_SW1);\
nrf_gpio_pin_clear(RDATA_SW2);\
nrf_gpio_pin_clear(RDATA_SW3);\
nrf_gpio_pin_set(PD_SEL1);\
nrf_gpio_pin_clear(PD_SEL2);\
nrf_gpio_pin_clear(PD_SEL3)
#define PD11() nrf_gpio_pin_set(MUX_EN_RDATA1);\
nrf_gpio_pin_clear(MUX_EN_RDATA2);\
nrf_gpio_pin_set(MUX_EN_RDATA3);\
nrf_gpio_pin_clear(RDATA_SW1);\
nrf_gpio_pin_set(RDATA_SW2);\
nrf_gpio_pin_clear(RDATA_SW3);\
nrf_gpio_pin_set(PD_SEL1);\
nrf_gpio_pin_clear(PD_SEL2);\
nrf_gpio_pin_clear(PD_SEL3)
#define PD12() nrf_gpio_pin_set(MUX_EN_RDATA1);\
nrf_gpio_pin_clear(MUX_EN_RDATA2);\
nrf_gpio_pin_set(MUX_EN_RDATA3);\
nrf_gpio_pin_set(RDATA_SW1);\
nrf_gpio_pin_set(RDATA_SW2);\
nrf_gpio_pin_clear(RDATA_SW3);\
nrf_gpio_pin_set(PD_SEL1);\
nrf_gpio_pin_clear(PD_SEL2);\
nrf_gpio_pin_clear(PD_SEL3)
#define PD13() nrf_gpio_pin_set(MUX_EN_RDATA1);\
nrf_gpio_pin_clear(MUX_EN_RDATA2);\
nrf_gpio_pin_set(MUX_EN_RDATA3);\
nrf_gpio_pin_clear(RDATA_SW1);\
nrf_gpio_pin_clear(RDATA_SW2);\
nrf_gpio_pin_set(RDATA_SW3);\
nrf_gpio_pin_set(PD_SEL1);\
nrf_gpio_pin_clear(PD_SEL2);\
nrf_gpio_pin_clear(PD_SEL3)
#define PD14() nrf_gpio_pin_set(MUX_EN_RDATA1);\
nrf_gpio_pin_clear(MUX_EN_RDATA2);\
nrf_gpio_pin_set(MUX_EN_RDATA3);\
nrf_gpio_pin_set(RDATA_SW1);\
nrf_gpio_pin_clear(RDATA_SW2);\
nrf_gpio_pin_set(RDATA_SW3);\
nrf_gpio_pin_set(PD_SEL1);\
nrf_gpio_pin_clear(PD_SEL2);\
nrf_gpio_pin_clear(PD_SEL3)
#define PD15() nrf_gpio_pin_set(MUX_EN_RDATA1);\
nrf_gpio_pin_clear(MUX_EN_RDATA2);\
nrf_gpio_pin_set(MUX_EN_RDATA3);\
nrf_gpio_pin_clear(RDATA_SW1);\
nrf_gpio_pin_set(RDATA_SW2);\
nrf_gpio_pin_set(RDATA_SW3);\
nrf_gpio_pin_set(PD_SEL1);\
nrf_gpio_pin_clear(PD_SEL2);\
nrf_gpio_pin_clear(PD_SEL3)
#define PD16() nrf_gpio_pin_set(MUX_EN_RDATA1);\
nrf_gpio_pin_clear(MUX_EN_RDATA2);\
nrf_gpio_pin_set(MUX_EN_RDATA3);\
nrf_gpio_pin_set(RDATA_SW1);\
nrf_gpio_pin_set(RDATA_SW2);\
nrf_gpio_pin_set(RDATA_SW3);\
nrf_gpio_pin_set(PD_SEL1);\
nrf_gpio_pin_clear(PD_SEL2);\
nrf_gpio_pin_clear(PD_SEL3)
#define PD17() nrf_gpio_pin_set(MUX_EN_RDATA1);\
nrf_gpio_pin_set(MUX_EN_RDATA2);\
nrf_gpio_pin_clear(MUX_EN_RDATA3);\
nrf_gpio_pin_clear(RDATA_SW1);\
nrf_gpio_pin_clear(RDATA_SW2);\
nrf_gpio_pin_clear(RDATA_SW3);\
nrf_gpio_pin_clear(PD_SEL1);\
nrf_gpio_pin_set(PD_SEL2);\
nrf_gpio_pin_clear(PD_SEL3)
#define PD18() nrf_gpio_pin_set(MUX_EN_RDATA1);\
nrf_gpio_pin_set(MUX_EN_RDATA2);\
nrf_gpio_pin_clear(MUX_EN_RDATA3);\
nrf_gpio_pin_set(RDATA_SW1);\
nrf_gpio_pin_clear(RDATA_SW2);\
nrf_gpio_pin_clear(RDATA_SW3);\
nrf_gpio_pin_clear(PD_SEL1);\
nrf_gpio_pin_set(PD_SEL2);\
nrf_gpio_pin_clear(PD_SEL3)
#define PD19() nrf_gpio_pin_set(MUX_EN_RDATA1);\
nrf_gpio_pin_set(MUX_EN_RDATA2);\
nrf_gpio_pin_clear(MUX_EN_RDATA3);\
nrf_gpio_pin_clear(RDATA_SW1);\
nrf_gpio_pin_set(RDATA_SW2);\
nrf_gpio_pin_clear(RDATA_SW3);\
nrf_gpio_pin_clear(PD_SEL1);\
nrf_gpio_pin_set(PD_SEL2);\
nrf_gpio_pin_clear(PD_SEL3)
#define PD20() nrf_gpio_pin_set(MUX_EN_RDATA1);\
nrf_gpio_pin_set(MUX_EN_RDATA2);\
nrf_gpio_pin_clear(MUX_EN_RDATA3);\
nrf_gpio_pin_set(RDATA_SW1);\
nrf_gpio_pin_set(RDATA_SW2);\
nrf_gpio_pin_clear(RDATA_SW3);\
nrf_gpio_pin_clear(PD_SEL1);\
nrf_gpio_pin_set(PD_SEL2);\
nrf_gpio_pin_clear(PD_SEL3)
#define PD_ALLOFF() nrf_gpio_pin_clear(MUX_EN_RDATA1);\
nrf_gpio_pin_clear(MUX_EN_RDATA2);\
nrf_gpio_pin_clear(MUX_EN_RDATA3);\
nrf_gpio_pin_clear(RDATA_SW1);\
nrf_gpio_pin_clear(RDATA_SW2);\
nrf_gpio_pin_clear(RDATA_SW3);\
nrf_gpio_pin_set(PD_SEL1);\
nrf_gpio_pin_set(PD_SEL2);\
nrf_gpio_pin_set(PD_SEL3)
/* For IC_NZP */
#define VCSEL_EN_PIN NRF_GPIO_PIN_MAP(1,7)
#define VCSEL_CONFIG() nrf_gpio_cfg_output(VCSEL_EN_PIN)
#define VCSEL_SW(x) if(x == true) nrf_gpio_pin_set(VCSEL_EN_PIN);\
else if(x == false) nrf_gpio_pin_clear(VCSEL_EN_PIN)
/* For AGC SW FSA5157L6X */
#define GAIN_SW_PIN NRF_GPIO_PIN_MAP(0,20)
#define GAIN_SW_CONFIG() nrf_gpio_cfg_output(GAIN_SW_PIN)
#define AGC_GAIN_SW(x) if(x == true) nrf_gpio_pin_set(GAIN_SW_PIN);\
else if(x == false) nrf_gpio_pin_clear(GAIN_SW_PIN)
#if FEATURE_FOR_SCOPE
#define ADC_CLK_18 18
#define PD_CLK_26 26
#define LED_CLK_15 15
#endif
void led_pd_gain_array_printout(void);
ret_code_t led_on(uint8_t led_index);
ret_code_t led_off(uint8_t led_index);
ret_code_t led_pd_matching_value_set(uint8_t led_index, uint8_t pd_index);
ret_code_t pd_on(uint8_t pd_index);
ret_code_t pd_off(uint8_t pd_index);
int16_t led_power_read(uint8_t led_index);
ret_code_t led_power_save_mem(uint8_t led_index, int16_t led_power);
ret_code_t led_power_set(uint8_t led_index);
ret_code_t pd_gain_set(uint8_t activated_led, uint8_t pd_index);
ret_code_t led_select(uint8_t led_index);
ret_code_t pd_select(uint8_t pd_index);
void mea_send_loop(void * p_context); /* For x ms */
void mea_send_timer_start(void);
void mea_send_timer_stop(void);
void mea_send_timer_init(void);
#endif //_MEASUREMENTS_H__

590
project/ble_peripheral/ble_app_bladder_patch/pca10056/s140/arm5_no_packs/ble_app_bladder_patch_s140.uvoptx
View File

File diff suppressed because it is too large Load Diff

200
project/ble_peripheral/ble_app_bladder_patch/pca10056/s140/arm5_no_packs/ble_app_bladder_patch_s140.uvprojx
View File

File diff suppressed because one or more lines are too long

44
project/ble_peripheral/ble_app_bladder_patch/pca10056/s140/i2c_manager.c
View File

@@ -6,14 +6,41 @@
#include "i2c_manager.h"
#include "debug_print.h"
#include "nrf_delay.h"
#include "eeprom_driver.h"
#include "mcp4725_i2c.h"
#include "nrf_drv_twi.h"
#include "cat_interface.h"
#include "nrfx_twi.h"
#include "boards.h"
#include "system_interface.h"
bool HW_I2C_FRQ = false;
bool SW_I2C_FRQ = false;
extern const nrf_drv_twi_t m_eeprom;
#define TWI_INSTANCE 0
/* TWI (I2C) 하드웨어 인스턴스 : IMU 드라이버에서 사용 - jhChun 26.03.16 */
const nrfx_twi_t m_twi = NRFX_TWI_INSTANCE(TWI_INSTANCE);
/* TWI (I2C) 해제 - jhChun 26.03.16 */
static void twi_uninitialize(void){
nrfx_twi_disable(&m_twi);
nrfx_twi_uninit(&m_twi);
}
/* TWI (I2C) 하드웨어 초기화 (SCL/SDA핀, 400kHz) - jhChun 26.03.16 */
static void twi_initialize(void){
ret_code_t err_code;
const nrfx_twi_config_t twi_config = {
.scl = ICM42670_I2C_SCL_PIN,
.sda = ICM42670_I2C_SDA_PIN,
.frequency = NRF_TWI_FREQ_400K,
.interrupt_priority = APP_IRQ_PRIORITY_HIGH,
};
err_code = nrfx_twi_init(&m_twi, &twi_config, NULL, NULL);
APP_ERROR_CHECK(err_code);
nrfx_twi_enable(&m_twi);
}
/* -------------------------------------------------------------------------- */
/* HW (TWI) 초기화 */
@@ -34,7 +61,7 @@ void hw_i2c_init_once(void)
}
DBG_PRINTF("[I2C] Initializing HW (TWI) I2C...\r\n");
eeprom_initialize();
twi_initialize();
nrf_delay_ms(2);
HW_I2C_FRQ = true;
@@ -53,8 +80,8 @@ void sw_i2c_init_once(void)
DBG_PRINTF("[I2C] HW I2C active -> switching to SW I2C\r\n");
// HW 완전 종료
nrf_drv_twi_disable(&m_eeprom);
nrf_drv_twi_uninit(&m_eeprom);
nrfx_twi_disable(&m_twi);
nrfx_twi_uninit(&m_twi);
nrf_delay_ms(3);
HW_I2C_FRQ = false; // 반드시 false로 갱신
@@ -65,9 +92,8 @@ void sw_i2c_init_once(void)
{
DBG_PRINTF("[I2C] Initializing SW (Port Bang-Bang) I2C...\r\n");
eeprom_uninitialize(); // SDA/SCL 해제
twi_uninitialize(); // SDA/SCL 해제
nrf_delay_ms(1);
mcp4725_init(); // 소프트 I2C 초기화
SW_I2C_FRQ = true;
HW_I2C_FRQ = false;

1
project/ble_peripheral/ble_app_bladder_patch/power_control.c
View File

@@ -14,7 +14,6 @@
#include "nrf_log.h"
#include "app_timer.h"
#include "debug_print.h"
#include "cat_interface.h"
#include "i2c_manager.h"
#define EEP_WP NRF_GPIO_PIN_MAP(0, 24)
APP_TIMER_DEF(m_power_timer_id);

5
project/ble_peripheral/ble_app_bladder_patch/tmp235_q1.c
View File

@@ -19,7 +19,6 @@
#include "ble_nus.h"
#include "tmp235_q1.h"
#include "main.h"
#include "meas_pd_48.h"
#include <cmd_parse.h>
#include "main_timer.h"
#include "debug_print.h"
@@ -42,7 +41,7 @@ extern uint8_t ble_bin_buffer[BLE_NUS_MAX_DATA_LEN] ;
extern which_cmd_t cmd_type_t;
extern bool info4; //cmd_parse
extern bool go_temp; //cmd_parse
extern volatile uint16_t info_temp; //48_C
volatile uint16_t info_temp; //48_C
extern bool motion_raw_data_enabled;
/**@brief Function for handling the ADC interrupt.
@@ -87,7 +86,7 @@ void tmp235_voltage_handler(nrf_drv_saadc_evt_t const * p_event) /* TMP325 Vout
led_temp_16 = (uint16_t)(led_temp*100);
single_format_data(ble_bin_buffer, "rso:", led_temp_16);
binary_tx_handler(ble_bin_buffer,3);
dr_binary_tx_safe(ble_bin_buffer,3);
// sprintf(ble_tx_buffer, "To%.2f\r\n",led_temp);
// data_tx_handler(ble_tx_buffer);

2
project/ble_peripheral/dr_piezo/dr_piezo.h
View File

@@ -69,7 +69,7 @@
#define DR_PIEZO_FREQ_HZ 2100000 /**< Target frequency (set PIEZO_FREQ_MHZ in .c) */
#define DR_PIEZO_DEFAULT_CYCLES 5 /**< Default burst cycles (3~5) */
#define DR_PIEZO_MIN_CYCLES 3
#define DR_PIEZO_MAX_CYCLES 10
#define DR_PIEZO_MAX_CYCLES 7 /* 3 -> 7 jhChun 26.03.12 */
#define DR_PIEZO_MUX_SETTLING_US 1300 /**< MUX settling delay (us) */
/*==============================================================================