I have a question about the NPM1300.

Hello,
I’m working with a combination of nRF5340 + nRF7002 + NPM1300,
and I’ve only changed the I2C pins connected to the NPM1300 to sda pgio1.4 and scl gpio1.6.

  • SDK version: v3.0.2

  • Toolchain version: v3.0.2

  • Board target: nrf7002dk/nrf5340/cpuapp

In the fuel_gauge example, under the same conditions,
I confirmed that the device works normally by only adding the following to the nrf7002dk_nrf5340_cpuapp.overlay file:

/ {
    gpio_fwd: nrf-gpio-forwarder {
        compatible = "nordic,nrf-gpio-forwarder";
        status = "disabled";

        uart {
            status = "disabled";
        };
    };
};

However, when applying the same changes to the ble_coex example, it does not work and I get the error "Pmic device not ready."
The only change made to the ble_coex example was the addition of Wi-Fi FOTA via HTTP.
I would appreciate any help.


CMakeLists.txt

#
# Copyright (c) 2022 Nordic Semiconductor ASA
#
# SPDX-License-Identifier: LicenseRef-Nordic-5-Clause
#

cmake_minimum_required(VERSION 3.20.0)

find_package(Zephyr REQUIRED HINTS $ENV{ZEPHYR_BASE})
project(Algo_SC50_rev0)

set(gen_dir ${CMAKE_CURRENT_BINARY_DIR}/certs)
zephyr_include_directories(${gen_dir})

generate_inc_file_for_target(
	app
	cert/AmazonRootCA1.pem
	${gen_dir}/AmazonRootCA1.pem.inc
)

target_sources(app PRIVATE
	# src/bt_throughput_test.c
	src/main.c

	src/Algo/wifi_socket.c
	src/Algo/ble.c
	src/Algo/adc.c
	src/Algo/fuel_gauge.c
)

# For net_private.h
target_include_directories(app PUBLIC
	${ZEPHYR_BASE}/subsys/net/ip
)

zephyr_library_include_directories(${ZEPHYR_BASE}/samples/bluetooth)

#####
# add_custom_command(
#   OUTPUT ${CMAKE_BINARY_DIR}/zephyr/merged_update.bin
#   COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_SOURCE_DIR}/merge_bin.py
#           ${CMAKE_BINARY_DIR}/../signed_by_mcuboot_and_b0_hci_ipc.bin
#           ${CMAKE_BINARY_DIR}/zephyr/zephyr.signed.bin
#           ${CMAKE_BINARY_DIR}/zephyr/merged_update.bin
#   DEPENDS
#           ${CMAKE_BINARY_DIR}/../signed_by_mcuboot_and_b0_hci_ipc.bin
#           ${CMAKE_BINARY_DIR}/zephyr/zephyr.signed.bin
#   COMMENT "Generating merged_update.bin for FOTA"
#   VERBATIM
# )

# add_custom_target(
#   generate_merged_bin ALL
#   DEPENDS ${CMAKE_BINARY_DIR}/zephyr/merged_update.bin
# )

set(MCUBOOT_IMAGE_VERSION "1.2.3")

prj.conf

#
# Copyright (c) 2022 Nordic Semiconductor ASA
#
# SPDX-License-Identifier: LicenseRef-Nordic-5-Clause
#

CONFIG_WIFI=y
CONFIG_WIFI_NRF70=y
CONFIG_NRF70_SR_COEX=n
CONFIG_NRF70_SR_COEX_RF_SWITCH=n

# WPA supplicant
CONFIG_WIFI_NM_WPA_SUPPLICANT=y

# Networking
CONFIG_NETWORKING=y
CONFIG_NET_SOCKETS=y
CONFIG_NET_LOG=y
CONFIG_NET_IPV4=y
CONFIG_NET_UDP=y
CONFIG_NET_TCP=y
CONFIG_NET_DHCPV4=y

CONFIG_NET_IF_UNICAST_IPV4_ADDR_COUNT=2
CONFIG_NET_MAX_CONTEXTS=8
CONFIG_NET_CONTEXT_SYNC_RECV=y

CONFIG_INIT_STACKS=y

CONFIG_NET_L2_ETHERNET=y

CONFIG_NET_CONFIG_SETTINGS=y
CONFIG_NET_CONFIG_INIT_TIMEOUT=0

CONFIG_NET_SOCKETS_POLL_MAX=10

CONFIG_NET_BUF_FIXED_DATA_SIZE=y
CONFIG_NET_BUF_DATA_SIZE=256
CONFIG_NET_TCP_WORKQ_STACK_SIZE=2048

# Memories
CONFIG_MAIN_STACK_SIZE=4096
CONFIG_NET_TX_STACK_SIZE=2048
CONFIG_NET_RX_STACK_SIZE=2048

# Debugging
CONFIG_STACK_SENTINEL=y
CONFIG_DEBUG_COREDUMP=y
CONFIG_DEBUG_COREDUMP_BACKEND_LOGGING=y
CONFIG_DEBUG_COREDUMP_MEMORY_DUMP_MIN=y

# Kernel options
CONFIG_ENTROPY_GENERATOR=y

# Logging
CONFIG_LOG=y
CONFIG_PRINTK=n
CONFIG_POSIX_CLOCK=y

CONFIG_USE_SEGGER_RTT=y
CONFIG_RTT_CONSOLE=y
CONFIG_LOG_MODE_IMMEDIATE=y

CONFIG_UART_CONSOLE=n

# Benchmarking
CONFIG_NET_ZPERF=y
CONFIG_ZVFS_OPEN_MAX=16

# Optimized networking settings for performance
CONFIG_NET_TC_TX_COUNT=1
CONFIG_NET_PKT_RX_COUNT=8
CONFIG_NET_PKT_TX_COUNT=8
CONFIG_NET_BUF_RX_COUNT=10
CONFIG_NET_BUF_TX_COUNT=10
CONFIG_HEAP_MEM_POOL_SIZE=20480
CONFIG_NRF_WIFI_CTRL_HEAP_SIZE=20000
CONFIG_NRF70_RX_NUM_BUFS=20
CONFIG_NRF70_MAX_TX_AGGREGATION=6
CONFIG_NRF_WIFI_DATA_HEAP_SIZE=96000

CONFIG_WIFI_CREDENTIALS=y
CONFIG_WIFI_CREDENTIALS_STATIC=y
CONFIG_WIFI_CREDENTIALS_STATIC_SSID="algorigo_tp5G"
CONFIG_WIFI_CREDENTIALS_STATIC_PASSWORD="dkfrhflrh24223#"

# CONFIG_NET_CONFIG_MY_IPV4_ADDR="192.168.0.8"
CONFIG_NET_CONFIG_PEER_IPV4_ADDR="192.168.1.242" 

CONFIG_NET_CONFIG_MY_IPV4_ADDR="192.168.1.99"
CONFIG_NET_CONFIG_MY_IPV4_NETMASK="255.255.255.0"
CONFIG_NET_CONFIG_MY_IPV4_GW="192.168.1.1"

# DUT zperf configuration
CONFIG_WIFI_ZPERF_PROT_UDP=y
CONFIG_WIFI_ZPERF_PKT_SIZE=1024
CONFIG_WIFI_ZPERF_RATE=10000
CONFIG_WIFI_ZPERF_SERVER=n

CONFIG_BT_DEVICE_NAME="SC50"
CONFIG_BT=y
CONFIG_BT_SMP=y
CONFIG_BT_PERIPHERAL=y
CONFIG_BT_CENTRAL=n
CONFIG_BT_MAX_CONN=1

CONFIG_BT_SCAN=n
CONFIG_BT_SCAN_FILTER_ENABLE=n
# CONFIG_BT_SCAN_UUID_CNT=1

CONFIG_BT_GATT_CLIENT=n
CONFIG_BT_GATT_DM=n
CONFIG_BT_THROUGHPUT=y

CONFIG_BT_USER_DATA_LEN_UPDATE=y
CONFIG_BT_USER_PHY_UPDATE=y
CONFIG_BT_GAP_AUTO_UPDATE_CONN_PARAMS=n

CONFIG_BT_BUF_ACL_RX_SIZE=502
CONFIG_BT_ATT_PREPARE_COUNT=2
CONFIG_BT_CONN_TX_MAX=10
CONFIG_BT_L2CAP_TX_BUF_COUNT=10
CONFIG_BT_L2CAP_TX_MTU=498
CONFIG_BT_BUF_ACL_TX_SIZE=502
CONFIG_BT_L2CAP_DYNAMIC_CHANNEL=y

CONFIG_DK_LIBRARY=y
CONFIG_DK_LIBRARY_DYNAMIC_BUTTON_HANDLERS=y
CONFIG_NRF70_MAX_TX_PENDING_QLEN=12
CONFIG_NRF70_QSPI_LOW_POWER=n

#Added to fix BLE crash in coex enable cases.
CONFIG_NRF_RPC=n
CONFIG_NRF_RPC_CBOR=n
# CONFIG_MBEDTLS_HEAP_SIZE=1024
CONFIG_MBEDTLS_HEAP_SIZE=65536

#---------------------------------------------------------
CONFIG_GPIO=y
CONFIG_SPI=y
CONFIG_SPI_NRFX=y
CONFIG_SPI_NOR=y
CONFIG_SPI_NOR_SFDP_DEVICETREE=y
CONFIG_SPI_NOR_FLASH_LAYOUT_PAGE_SIZE=4096
CONFIG_NORDIC_QSPI_NOR=n 

CONFIG_FLASH=y
CONFIG_FLASH_MAP=y
CONFIG_IMG_MANAGER=y
CONFIG_MCUBOOT_IMG_MANAGER=y

CONFIG_PARTITION_MANAGER_ENABLED=y
CONFIG_DFU_TARGET=y
CONFIG_STREAM_FLASH=y
CONFIG_IMG_ERASE_PROGRESSIVELY=y

CONFIG_HTTP_PARSER_URL=y

##  250722
CONFIG_BOOTLOADER_MCUBOOT=y
CONFIG_UPDATEABLE_IMAGE_NUMBER=2
CONFIG_MCUBOOT_BOOTUTIL_LIB=y

CONFIG_REBOOT=y

CONFIG_FOTA_DOWNLOAD=y

CONFIG_NET_SOCKETS_SOCKOPT_TLS=y
CONFIG_NRF_SECURITY=y

CONFIG_TLS_CREDENTIALS=y
CONFIG_TLS_CREDENTIALS_BACKEND_PROTECTED_STORAGE=y

CONFIG_MBEDTLS=y
CONFIG_MBEDTLS_ENABLE_HEAP=y
CONFIG_MBEDTLS_RSA_C=y
CONFIG_MBEDTLS_DHM_C=y
CONFIG_MBEDTLS_TLS_LIBRARY=y
CONFIG_MBEDTLS_SSL_SERVER_NAME_INDICATION=y

CONFIG_SYSTEM_WORKQUEUE_STACK_SIZE=2048

CONFIG_DOWNLOADER=y

CONFIG_NET_IPV6=n
CONFIG_DNS_RESOLVER=y
CONFIG_DNS_SERVER_IP_ADDRESSES=y
CONFIG_DNS_SERVER1="8.8.8.8"

CONFIG_DOWNLOADER_STACK_SIZE=4096        
CONFIG_DOWNLOAD_CLIENT_STACK_SIZE=4096 

CONFIG_HTTP_CLIENT=y

CONFIG_PCD=y
CONFIG_PCD_APP=y
CONFIG_PCD_NET=y

CONFIG_DFU_TARGET_STREAM=y
CONFIG_BOOTLOADER_MCUBOOT=y
CONFIG_DFU_TARGET_MCUBOOT=y
CONFIG_DFU_MULTI_IMAGE=n

# CONFIG_SUIT_DFU_CANDIDATE_PROCESSING_LEVEL=y
# CONFIG_SUIT_DFU_CANDIDATE_PROCESSING_FULL=y
# CONFIG_SUIT_DFU_CANDIDATE_PROCESSING_PUSH_TO_CACHE=y

# Enable PINCTRL
CONFIG_PINCTRL=y

CONFIG_ADC=y

## npm1300
CONFIG_SHELL=y
CONFIG_REGULATOR=y
CONFIG_SENSOR=y
CONFIG_I2C_SHELL=y
CONFIG_NRF_FUEL_GAUGE=y
CONFIG_NRF_FUEL_GAUGE_VARIANT_SECONDARY_CELL=y
CONFIG_REQUIRES_FLOAT_PRINTF=y


# CONFIG_GPIO_NPM1300=y
# CONFIG_LED_NPM1300=y
# CONFIG_MFD_NPM1300=y
# CONFIG_NPM1300_CHARGER=y
# CONFIG_REGULATOR_NPM1300=y
# CONFIG_WDT_NPM1300=y
CONFIG_LED=y


# CONFIG_I2C=y
# CONFIG_I2C_NRFX=y
# CONFIG_SENSOR_SHELL=y
# CONFIG_REGULATOR_SHELL=y

# CONFIG_NRFX_TWIM1=y

CONFIG_PWM=y

sysbuild.conf

#
# Copyright (c) 2024 Nordic Semiconductor ASA
#
# SPDX-License-Identifier: LicenseRef-Nordic-5-Clause
#

SB_CONFIG_WIFI_NRF70=y

SB_CONFIG_BOOTLOADER_MCUBOOT=y
SB_CONFIG_SECURE_BOOT_NETCORE=y

# Needed for FOTA for nRF5340 and TF-M
SB_CONFIG_MCUBOOT_USE_ALL_AVAILABLE_RAM=y

# External flash configurations
SB_CONFIG_PM_EXTERNAL_FLASH_MCUBOOT_SECONDARY=y
SB_CONFIG_PM_OVERRIDE_EXTERNAL_DRIVER_CHECK=y

SB_CONFIG_MCUBOOT_UPDATEABLE_IMAGES=2

SB_CONFIG_MCUBOOT_NRF53_MULTI_IMAGE_UPDATE=y
SB_CONFIG_NETCORE_APP_UPDATE=y       # Net 이미지 빌드
SB_CONFIG_NETCORE_HCI_IPC=y          # IPC 채널

SB_CONFIG_DFU_MULTI_IMAGE_PACKAGE_BUILD=y
SB_CONFIG_DFU_MULTI_IMAGE_PACKAGE_APP=y
SB_CONFIG_DFU_MULTI_IMAGE_PACKAGE_NET=y
# SB_CONFIG_DFU_MULTI_IMAGE_PACKAGE_MCUBOOT=y
# SB_CONFIG_DFU_MULTI_IMAGE_PACKAGE_WIFI_FW_PATCH=y
# SB_CONFIG_SUIT_MULTI_IMAGE_PACKAGE_BUILD=y

nrf7002dk_nrf5340_cpuapp.overlay

// To get started, press Ctrl+Space to bring up the completion menu and view the available nodes.

// You can also use the buttons in the sidebar to perform actions on nodes.
// Actions currently available include:

// * Enabling / disabling the node
// * Adding the bus to a bus
// * Removing the node
// * Connecting ADC channels

// For more help, browse the DeviceTree documentation at https://docs.zephyrproject.org/latest/guides/dts/index.html
// You can also visit the nRF DeviceTree extension documentation at https://docs.nordicsemi.com/bundle/nrf-connect-vscode/page/guides/ncs_configure_app.html#devicetree-support-in-the-extension

/ {
	chosen {
		// zephyr,bt-hci = &bt_hci_ipc0;
		// nordic,802154-spinel-ipc = &ipc0;
		// zephyr,ieee802154 = &ieee802154;
		nordic,pm-ext-flash = &mx25r64;
	};

	gpio_fwd: nrf-gpio-forwarder {
    compatible = "nordic,nrf-gpio-forwarder";
    status = "disabled";

		uart {
			status = "disabled";
		};
	};
	
	zephyr,user {
		io-channels = <&adc 0>;
	   
		DT1-gpios = <&gpio1 11 0>;
		DT2-gpios = <&gpio1 13 0>;
		DT3-gpios = <&gpio0 7 0>;
		DT4-gpios = <&gpio0 25 0>;
 
		MOTOR_POWER_EN-gpios = <&gpio1 0 0>;

		// MOTOR_PWM-gpios = <&gpio0 2 0>;
		pwms = <&pwm0 0 20 PWM_POLARITY_NORMAL>;
	};

	buttons {
		compatible = "gpio-keys";
		button0: button_0 {
			gpios = <&gpio1 8 (GPIO_PULL_UP | GPIO_ACTIVE_LOW)>;
			label = "Push button 1";
			zephyr,code = <INPUT_KEY_0>;
		};
		button1: button_1 {
			status = "disabled";
		};
	};

	/* These aliases are provided for compatibility with samples */
	// aliases {
	// 	pwm-led0 = &pwm_led0;
	// 	sw0 = &button0;
	// 	bootloader-led0 = &led0;
	// 	mcuboot-button0 = &button0;
	// 	mcuboot-led0 = &led0;
	// 	watchdog0 = &wdt0;
	// };
};


&pinctrl {
	pwm0_default: pwm0_default {
		group1 {
			psels = <NRF_PSEL(PWM_OUT0, 1, 2)>;
			// nordic,invert;
		};
	};

	pwm0_sleep: pwm0_sleep {
		group1 {
			psels = <NRF_PSEL(PWM_OUT0, 1, 2)>;
			low-power-enable;
		};
	};
	
	spi0_default: spi0_default {
		group1 {
			psels = <NRF_PSEL(SPIM_SCK, 1, 12)>,        /* SPI SCK 핀 */
					<NRF_PSEL(SPIM_MOSI, 0, 31)>,       /* SPI MOSI 핀 */
					<NRF_PSEL(SPIM_MISO, 1, 1)>;       /* SPI MISO 핀 */
		};
	};

	spi0_sleep: spi0_sleep {
		group1 {
				psels = <NRF_PSEL(SPIM_SCK, 1, 12)>,        /* SPI SCK 핀 */
						<NRF_PSEL(SPIM_MOSI, 0, 31)>,       /* SPI MOSI 핀 */
						<NRF_PSEL(SPIM_MISO, 1, 1)>;       /* SPI MISO 핀 */
				low-power-enable;
		};
	};

	i2c1_default: i2c1_default {
        group1 {
            bias-pull-up;
            psels = <NRF_PSEL(TWIM_SCL, 1, 6)>,
                    <NRF_PSEL(TWIM_SDA, 1, 4)>;
        };
    };

    i2c1_sleep: i2c1_sleep {
        group1 {
            psels = <NRF_PSEL(TWIM_SCL, 1, 6)>, 
                    <NRF_PSEL(TWIM_SDA, 1, 4)>;
            low-power-enable;
        };
    };
};


&uart0 {
	status = "disabled";
};

arduino_serial: &uart1 {
	status = "disabled";
};

&gpio_fwd {
    compatible = "nordic,nrf-gpio-forwarder";
    status = "disabled";

	uart {
        status = "disabled";
    };
};


&led0 {
	status = "disabled";
};


&led1 {
	status = "disabled";
};


&pwm_led0 {
	status = "disabled";
};


&pwm0 {
    status = "okay";                      /* PWM 컨트롤러 활성화 */
    pinctrl-0 = <&pwm0_default>;          /* 기본 설정 */
	pinctrl-1 = <&pwm0_sleep>; 
    pinctrl-names = "default", "sleep";
	// label = "PWM_0";
};


&spi0 {
	compatible = "nordic,nrf-spim";
    status = "okay";

	pinctrl-0 = <&spi0_default>;
	pinctrl-1 = <&spi0_sleep>;
	pinctrl-names = "default", "sleep"; 

	label = "SPI_0";
    
    cs-gpios = <&gpio0 19 GPIO_ACTIVE_HIGH>,  /* CS 4151_1 */
               <&gpio0 21 GPIO_ACTIVE_HIGH>,  /* CS 4152_2 */
               <&gpio0 20 GPIO_ACTIVE_HIGH>;  /* CS 4052_2 */
               
    slave1: spi-dev1@0 {
        compatible = "spi-device";
        reg = <0>;       /* 슬레이브 1의 ID */
        spi-max-frequency = <8000000>;
        // cs-gpios = <&gpio0 8 GPIO_ACTIVE_LOW>;
    };

    slave2: spi-dev2@1 {
        compatible = "spi-device";
        reg = <1>;       /* 슬레이브 2의 ID */
        spi-max-frequency = <8000000>;
        // cs-gpios = <&gpio0 9 GPIO_ACTIVE_LOW>;
    };

    slave3: spi-dev3@2 {
        compatible = "spi-device";
        reg = <2>;       /* 슬레이브 3의 ID */
        spi-max-frequency = <8000000>;
        // cs-gpios = <&gpio0 10 GPIO_ACTIVE_LOW>;
    };
};

&mx25r64 {
	status = "okay";
};


#include <dt-bindings/regulator/npm1300.h>
#include <zephyr/dt-bindings/input/input-event-codes.h>

sc50_i2c: &i2c1 {
	compatible = "nordic,nrf-twim";  // I2C 마스터 모드 사용
    status = "okay"; 
    clock-frequency = <I2C_BITRATE_FAST>;
	
	pinctrl-0 = <&i2c1_default>;
	pinctrl-1 = <&i2c1_sleep>;
	pinctrl-names = "default", "sleep";

	npm1300: pmic@6b {
		compatible = "nordic,npm1300";
		reg = <0x6b>;
		label="npm1300";

        pmic-int-pin = <3>;
		
		npm1300_ek_gpio: gpio-controller {
			compatible = "nordic,npm1300-gpio";
			gpio-controller;
			#gpio-cells = <2>;
			ngpios = <5>;
		};

		npm1300_ek_regulators: regulators {
			compatible = "nordic,npm1300-regulator";

			/* limits are set to min/max allowed values */
			npm1300_ek_buck1: BUCK1 {
				regulator-min-microvolt = <1000000>;
				regulator-max-microvolt = <3300000>;
				regulator-init-microvolt =  <3000000>;
				retention-microvolt = <3000000>;
			};

			npm1300_ek_buck2: BUCK2 {
				regulator-min-microvolt = <1000000>;
				regulator-max-microvolt = <3300000>;
			};

			npm1300_ek_ldo1: LDO1 {
				regulator-min-microvolt = <1000000>;
				regulator-max-microvolt = <3300000>;
			};

			npm1300_ek_ldo2: LDO2 {
				regulator-min-microvolt = <1000000>;
				regulator-max-microvolt = <3300000>;
			};
		};

		npm1300_ek_charger: charger {
			// compatible = "nordic,npm1300-charger";
			// term-microvolt = <4150000>;
			// term-warm-microvolt = <4000000>;
			// current-microamp = <500000>;//150000
			// dischg-limit-microamp = <1000000>;
			// vbus-limit-microamp = <500000>;
			// thermistor-ohms = <10000>;
			// thermistor-beta = <3380>;
			// charging-enable;
			// vbatlow-charge-enable;

			compatible = "nordic,npm1300-charger";
			term-microvolt = <4200000>;         // 충전 종료 전압 4.20V
			term-warm-microvolt = <3600000>;    // 배터리 온도 높을 때 충전 제한 전압 3.6V
			current-microamp = <800000>;       	// 충전 전류 800mA (1A, 2600mAh 배터리의 0.5C)
			dischg-limit-microamp = <1000000>;  // 방전 제한 1A
			vbus-limit-microamp = <500000>;     // 기본 500mA로 제한 후 코드에서 충전 전류 상승
			thermistor-ohms = <10000>;          // 배터리 NTC 서미스터 10kΩ
			thermistor-beta = <3380>;           // NTC B 값 3380
			charging-enable;                    // 충전 활성화
			//vbatlow-charge-enable;              // 배터리 저전압에서도 충전 가능
		};

		npm1300_ek_buttons: buttons {
			compatible = "gpio-keys";
			pmic_button0: pmic_button_0 {
				gpios = < &npm1300_ek_gpio 0 GPIO_ACTIVE_HIGH>;
				label = "Pmic button switch 0";
			zephyr,code = <INPUT_KEY_0>;
			};
		};

		npm1300_ek_leds: leds {
			compatible = "nordic,npm1300-led";
			nordic,led0-mode = "error";			// 파랑 "error"
			nordic,led1-mode = "host";			// 초록 Full charging
			nordic,led2-mode = "charging";		// 빨강 "charging"
		};
	};
};

main.c

/*
 * Copyright (c) 2022 Nordic Semiconductor ASA
 *
 * SPDX-License-Identifier: LicenseRef-Nordic-5-Clause
 */

/** @file
 * @brief SR coexistence sample
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <zephyr/logging/log.h>
LOG_MODULE_REGISTER(Algo_SC50, CONFIG_LOG_DEFAULT_LEVEL);

#include <zephyr/kernel.h>
#if NRFX_CLOCK_ENABLED && (defined(CLOCK_FEATURE_HFCLK_DIVIDE_PRESENT) || NRF_CLOCK_HAS_HFCLK192M)
#include <nrfx_clock.h>
#endif
#include <zephyr/init.h>
#include <zephyr/device.h>
#include <zephyr/devicetree.h>
#include <zephyr/drivers/gpio.h>

// #include <zephyr/drivers/i2c.h>
#include <zephyr/drivers/mfd/npm1300.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/drivers/led.h>

#include "Algo/wifi_socket.h"
#include "Algo/ble.h"
#include "Algo/adc.h"
#include "Algo/fuel_gauge.h"
// #include "Algo/Led.h"

#include "Algo/deviceInformation.h"

#define SLEEP_TIME_MS 1000

#define APPCORE_FW_VER "appcore_v2.0.0"

int powerMode = Power_On;
bool poweron_initialized = false;
bool poweroff_initialized = false;
bool powerdeeosleep_initialized = false;

static const struct device *pmic = DEVICE_DT_GET(DT_NODELABEL(npm1300));
static const struct device *charger = DEVICE_DT_GET(DT_NODELABEL(npm1300_ek_charger));
static const struct device *leds = DEVICE_DT_GET(DT_NODELABEL(npm1300_ek_leds));
static const struct device *gpios = DEVICE_DT_GET(DT_NODELABEL(npm1300_ek_gpio));
static volatile bool vbus_connected;

#define NPM1300_CHARGER_BASE        0x03U
#define REG_BCHGDISABLESET_OFFSET   0x6
#define BCHGDISABLE_NTC_MASK        BIT(1)

// VBUS 관련 레지스터 주소 정의
#define NPM1300_VBUS_BASE           0x02U       // VBUS 베이스 주소
#define VBUS_OFFSET_STATUS          0x07U       // VBUS 상태 플래그가 포함된 오프셋

// VBUSINSTATUS 레지스터의 비트 정의
#define VBUS_DETECTED_BIT     (1 << 0)  // Bit 0: VBUS detected
#define VBUS_OVERVOLTAGE_BIT  (1 << 2)  // Bit 2: Overvoltage protection active
#define VBUS_UNDERVOLTAGE_BIT (1 << 3)  // Bit 3: Undervoltage detected

// SHIP Mode Base Address
#define SHIP_MODE_BASE       0x0BU

// SHIP Mode 관련 레지스터 오프셋
#define TASKENTERSHIPMODE    0x02U  // Ship Mode 진입 명령

static struct k_timer green_blink_timer;
static bool reed_led_state = false;
static bool green_led_state = false;
static bool blue_led_state = false;


// SHIP Mode 진입 함수
int enter_ship_mode(void) {
    int ret = mfd_npm1300_reg_write(pmic, SHIP_MODE_BASE, TASKENTERSHIPMODE, 1U);
    if (ret == 0) {
        printf("Device is entering Ship Mode...\n");
    } else {
        printf("Failed to enter Ship Mode. Error: %d\n", ret);
    }
}


// VBUS 상태 확인 함수
int check_vbus_status(void) {
    int ret;
    uint8_t vbus_status;

    // VBUS 상태 레지스터 읽기
    ret = mfd_npm1300_reg_read(pmic, NPM1300_VBUS_BASE, VBUS_OFFSET_STATUS, &vbus_status);
    if (ret != 0) {
        return ret; // 읽기 실패 시 오류 코드 반환
    }

    // VBUS 상태 출력
    if (vbus_status & VBUS_DETECTED_BIT) {
        // printf("VBUS detected.\n");
        vbus_connected = true;
    } else {
        // printf("VBUS not detected.\n");
        vbus_connected = false;
    }

    if (vbus_status & VBUS_OVERVOLTAGE_BIT) {
        // printf("VBUS overvoltage detected.\n");
    }

    if (vbus_status & VBUS_UNDERVOLTAGE_BIT) {
        // printf("VBUS undervoltage detected.\n");
    }
}


/** NTC 체크 비활성화 */
void disable_ntc_check(void) {
    int ret;
    uint8_t read_val = 0;

    uint8_t val = read_val | BCHGDISABLE_NTC_MASK;
    ret = mfd_npm1300_reg_write(pmic, NPM1300_CHARGER_BASE, REG_BCHGDISABLESET_OFFSET, val);
    if (ret < 0) {
        LOG_ERR("ERROR: Failed to write BCHGDISABLESET! (ret=%d)", ret);
        return;
    }

    LOG_INF("NTC check disable command sent.");
}


static void pmic_event_callback(const struct device *dev, struct gpio_callback *cb, uint32_t pins)
{
	if (pins & BIT(NPM1300_EVENT_VBUS_DETECTED)) {
		printk("Vbus connected\n");
		vbus_connected = true;
	}

	if (pins & BIT(NPM1300_EVENT_VBUS_REMOVED)) {
		printk("Vbus removed\n");
		vbus_connected = false;
	}
}


int npm1300_configure_set(void) {
	int err;
    
    if (!device_is_ready(pmic)) {
        LOG_INF("Pmic device not ready.\n");
        return 0;
    }
    
    if (!device_is_ready(charger)) {
        LOG_INF("Charger device not ready.\n");
        return 0;
    }
    
    if (fuel_gauge_init(charger) < 0) {
        LOG_INF("Could not initialise fuel gauge.\n");
        return 0;
    }
    
    if (!device_is_ready(leds)) {
        printk("Error: led device is not ready\n");
        return 0;
    }
    
    if (!device_is_ready(gpios)) {
        printk("Error: gpios device is not ready\n");
        return 0;
    }
    
    static struct gpio_callback event_cb;
    // gpio_init_callback(&event_cb, pmic_event_callback, BIT(0));
    gpio_init_callback(&event_cb, pmic_event_callback,
				   BIT(NPM1300_EVENT_VBUS_DETECTED) |
				   BIT(NPM1300_EVENT_VBUS_REMOVED));
    
    err = mfd_npm1300_add_callback(pmic, &event_cb);   
    if (err) {
        LOG_INF("Failed to add pmic callback.\n");
        return 0;
    }
    
    /* ✅ 초기 설정 */
    disable_ntc_check();        // NTC 체크 비활성화
    //err = mfd_npm1300_reg_write(pmic, 0x01, 0x0C, 0x00);
    err = mfd_npm1300_reg_write(pmic, 0x09, 0x00, 0x00);
    if (err != 0) {
        return err; // 읽기 실패 시 오류 코드 반환    
    }

    /* Initialise vbus detection status. */
	struct sensor_value val;
	int ret = sensor_attr_get(charger, SENSOR_CHAN_CURRENT, SENSOR_ATTR_UPPER_THRESH, &val);

	if (ret < 0) {
		return false;
	}

	vbus_connected = (val.val1 != 0) || (val.val2 != 0);

	printk("PMIC device ok\n");

    gpio_pin_configure(gpios, 0, GPIO_OUTPUT_ACTIVE);
    gpio_pin_configure(gpios, 1, GPIO_OUTPUT_ACTIVE);
    gpio_pin_configure(gpios, 2, GPIO_OUTPUT_ACTIVE);
}


int main(void)
{
	LOG_INF("SC50 device ok");
	LOG_INF("App Core FW version: %s", APPCORE_FW_VER);

	npm1300_configure_set();

	/* npm1300 gpio led 관련 부분 1:off, 0:on */
    gpio_pin_set(gpios, 0, 0);      // Blue <- 저항값 내려야 함함
    gpio_pin_set(gpios, 1, 0);      // Green <- 저항값 적절
    gpio_pin_set(gpios, 2, 0);      // Red <- 저항값 올려야 함

	while (1) {
		if(powerMode == Power_On)
        {
			// LOG_INF("Power On");
            poweroff_initialized = false;

			if(poweron_initialized == false)
            {
				LOG_INF("Power On Init");
                poweron_initialized = true;
                // system_powering_off= false;
				Task_Wifi_Socket_Init();
				Task_ADC_Init();
			}

			/* 주기적으로 pmic 상태 확인 */
			check_vbus_status();
            fuel_gauge_update(charger, vbus_connected);
		}
        else if(powerMode == Power_Off)
        {

		}
        else if(powerMode == Power_DeepSleep)
        {
			if(!powerdeeosleep_initialized)
            {
                powerdeeosleep_initialized = true;
                enter_ship_mode();
            }
		}
        else if(powerMode == Power_LightSleep)
        {
        }

		k_msleep(SLEEP_TIME_MS);
	}

	k_sleep( K_FOREVER );
}

Additionally, I have confirmed that the npm1300 works correctly when using the ble_coex example with the above configuration as-is.
However, the system stops working after adding the settings required for FOTA.


Related