Add npm1012 support

src/components/Battery/BatteryStatus.tsx

@@ -15,6 +15,7 @@ import {
     getPmicChargingState,
     isReceivingBatteryVoltageAboveThreshold,
 } from '../../features/pmicControl/pmicControlSlice';
+import { getMaxNumDecimalsForRangeOrNumberArray } from '../../utils/helpers';
 
 import './battery.scss';
 
@@ -81,7 +82,11 @@ export default ({ disabled }: { disabled: boolean }) => {
                                   latestAdcSample.iBat ?? 0,
                               ).toFixed(
                                   npmDevice?.chargerModule?.ranges.current
-                                      .decimals ?? 0,
+                                      ? getMaxNumDecimalsForRangeOrNumberArray(
+                                            npmDevice?.chargerModule?.ranges
+                                                .current,
+                                        )
+                                      : 0,
                               )} mA`
                             : 'N/A'
                     }

src/components/Cards/Power/PowerCard.tsx

@@ -19,6 +19,7 @@ import {
     ChargerModule,
     isFixedListRangeWithLabel,
     ITerm,
+    ITrickle,
     VTrickleFast,
 } from '../../../features/pmicControl/npm/types';
 
@@ -120,6 +121,50 @@ const IBatLimUI = ({
     );
 };
 
+const ITrickleUI = ({
+    chargerModule,
+    charger,
+    disabled,
+}: {
+    chargerModule: ChargerModule;
+    charger: Charger;
+    disabled: boolean;
+}) => {
+    const [internalITrickle] = useState(charger.iTrickle);
+
+    if (
+        !chargerModule.set.iTrickle ||
+        charger.iTrickle === undefined ||
+        internalITrickle === undefined ||
+        chargerModule.values.iTrickle === undefined
+    ) {
+        return null;
+    }
+
+    return (
+        <Dropdown
+            label={
+                <DocumentationTooltip card={card} item="ITrickle">
+                    <>
+                        <span>I</span>
+                        <span className="subscript">TRICKLE</span>
+                    </>
+                </DocumentationTooltip>
+            }
+            items={chargerModule.values.iTrickle}
+            onSelect={item =>
+                chargerModule.set.iTrickle?.(item.value as ITrickle)
+            }
+            selectedItem={
+                chargerModule.values.iTrickle.find(
+                    item => item.value === charger.iTrickle,
+                ) ?? chargerModule.values.iTrickle[0]
+            }
+            disabled={disabled}
+        />
+    );
+};
+
 export default ({
     chargerModule,
     charger,
@@ -290,6 +335,11 @@ export default ({
                         }
                         disabled={disabled}
                     />
+                    <ITrickleUI
+                        charger={charger}
+                        chargerModule={chargerModule}
+                        disabled={disabled}
+                    />
                 </>
             )}
         </Card>

src/components/DeviceSelector.tsx

@@ -16,10 +16,14 @@ import path from 'path';
 
 import { closeDevice, openDevice } from '../actions/deviceActions';
 import {
+    npm1012DeviceSetup,
     npm1300DeviceSetup,
     npm1304DeviceSetup,
     npm2100DeviceSetup,
 } from '../features/pmicControl/npm/deviceSetups';
+import Npm1012, {
+    npm1012FWVersion,
+} from '../features/pmicControl/npm/npm1012/pmic1012Device';
 import Npm1300, {
     npm1300FWVersion,
 } from '../features/pmicControl/npm/npm1300/pmic1300Device';
@@ -56,6 +60,13 @@ const deviceListing: DeviceTraits = {
 
 const deviceSetupConfig: DeviceSetupConfig = {
     deviceSetups: [
+        npm1012DeviceSetup({
+            key: 'nPM1012',
+            description: '',
+            hex: getAppFile(
+                path.join('fw', `app_signed_nPM1012_${npm1012FWVersion}.hex`),
+            ),
+        }),
         npm1300DeviceSetup({
             key: 'nPM1300',
             description: '',
@@ -123,9 +134,17 @@ export default () => {
                 isNpm2100SerialApplicationMode(device) ||
                 isNpm2100SerialRecoverMode(device)
             }
-            virtualDevices={['nPM1300', 'nPM1304', 'nPM2100']}
+            virtualDevices={['nPM1012', 'nPM1300', 'nPM1304', 'nPM2100']}
             onVirtualDeviceSelected={device => {
-                if (device === 'nPM1300') {
+                if (device === 'nPM1012') {
+                    dispatch(
+                        setNpmDevice(
+                            new Npm1012(undefined, pmicDialog =>
+                                dispatch(dialogHandler(pmicDialog)),
+                            ),
+                        ),
+                    );
+                } else if (device === 'nPM1300') {
                     dispatch(
                         setNpmDevice(
                             new Npm1300(undefined, pmicDialog =>

src/components/Profiling/Dialog/ConfigurationDialog.tsx

@@ -33,6 +33,7 @@ import {
     setProfile,
     setProfilingStage,
 } from '../../../features/pmicControl/profilingSlice';
+import { getMaxValueOfRangeOrNumberArray } from '../../../utils/helpers';
 import { generateDefaultProjectPath, saveProjectSettings } from '../helpers';
 import { ProfilingProject } from '../types';
 
@@ -52,7 +53,11 @@ export default ({
     const [showValidationError, setShowValidationError] = useState(false);
 
     const [capacity, setCapacity] = useState(
-        npmDevice.chargerModule?.ranges.current.max ?? 800,
+        npmDevice.chargerModule?.ranges.current
+            ? getMaxValueOfRangeOrNumberArray(
+                  npmDevice.chargerModule?.ranges.current,
+              )
+            : 800,
     );
     const [ntcThermistor, setNTCThermistor] = useState<NTCThermistor>('10 kΩ');
     const [temperatures, setTemperatures] = useState<number[]>([25]);

src/features/pmicControl/npm/deviceSetups.tsx

@@ -25,6 +25,8 @@ import { minimumHWVersion as minimumHWVersionNpm2100 } from './npm2100/pmic2100D
 import { getNpmDevice } from './npmFactory';
 import {
     dialogHandler,
+    isNpm1012SerialApplicationMode,
+    isNpm1012SerialRecoverMode,
     isNpm1300SerialApplicationMode,
     isNpm1300SerialRecoverMode,
     isNpm1304SerialApplicationMode,
@@ -130,6 +132,107 @@ const getNpmDeviceObject = async (comName: string) => {
     }
 };
 
+export const npm1012DeviceSetup = (firmware: NpmFirmware): DeviceSetup => ({
+    supportsProgrammingMode: (device: Device) =>
+        device.traits.mcuBoot === true &&
+        device.traits.serialPorts === true &&
+        (isNpm1012SerialRecoverMode(device) ||
+            isNpm1012SerialApplicationMode(device)),
+    getFirmwareOptions: device => [
+        {
+            key: firmware.key,
+            description: firmware.description,
+            programDevice: onProgress => dispatch =>
+                new Promise<Device>((resolve, reject) => {
+                    let success = false;
+                    dispatch(
+                        setWaitForDevice({
+                            timeout: 60000,
+                            when: programmedDevice =>
+                                // device lib report device with wrong value initially so we have to wait until device is fully recognized
+                                programmedDevice.serialPorts?.length === 2 &&
+                                programmedDevice.traits.mcuBoot === true &&
+                                programmedDevice.traits.serialPorts === true &&
+                                isNpm1012SerialApplicationMode(
+                                    programmedDevice,
+                                ),
+                            once: true,
+                            onSuccess: dev => {
+                                success = true;
+                                resolve(dev);
+                            },
+                            onFail: reject,
+                        }),
+                    );
+                    NrfutilDeviceLib.program(device, firmware.hex, progress => {
+                        onProgress(
+                            progress.stepProgressPercentage,
+                            progress.message,
+                        );
+                    })
+                        .then(() => {
+                            onProgress(
+                                100,
+                                'Programming upload complete. Waiting for device to apply firmware and restart. This can take a minute.',
+                            );
+                        })
+                        .catch(err => {
+                            if (err && !success) {
+                                reject(err.message);
+                            }
+                        });
+                    logger.debug('Firmware updated finished');
+                }),
+        },
+    ],
+    isExpectedFirmware:
+        (
+            device: Device,
+        ): AppThunk<
+            RootState,
+            Promise<{
+                device: Device;
+                validFirmware: boolean;
+            }>
+        > =>
+        async () => {
+            if (!(device.serialPorts && device.serialPorts[0].comName)) {
+                throw new Error('Device does not have a serial port');
+            }
+
+            if (isNpm1012SerialRecoverMode(device)) {
+                return {
+                    device,
+                    validFirmware: false,
+                };
+            }
+
+            const { npmDevice, dispose } = await getNpmDeviceObject(
+                device.serialPorts[0].comName,
+            );
+
+            try {
+                const result = await npmDevice.isSupportedVersion();
+
+                const action = () => ({
+                    device,
+                    validFirmware: result.supported,
+                });
+
+                await dispose();
+
+                return action();
+            } catch (e) {
+                await dispose();
+                throw e;
+            }
+        },
+    tryToSwitchToApplicationMode: () => () =>
+        new Promise<Device | null>(resolve => {
+            resolve(null);
+        }),
+});
+
 export const npm1300DeviceSetup = (firmware: NpmFirmware): DeviceSetup => ({
     supportsProgrammingMode: (device: Device) =>
         device.traits.mcuBoot === true &&