Person_iCloud/utils/params-page-state.js

const {
  atoBandwidthInputRegisters,
  calculatedParameterRegisters,
  dqGainInputRegisters,
  oilParameterInputRegisters,
  parameterInputRegisters,
  prepositionParameterInputRegisters,
  protectionRegisters,
  protectionSwitchRegisters,
  speedLoopExtraRegisters,
  speedSlopeRegister,
  tailwindSwitchRegisters,
  getByteRegisterValue
} = require('./registers')
const {
  getSharedInputValues,
  mergeInputValues,
  toFiniteNumber
} = require('./calculation-context')
const {
  calculateAtoGainWriteValues,
  calculateDqGainWriteValue,
  calculateParameterInputWriteValue,
  calculateParameterReadValue,
  calculateProtectionWriteValue,
  calculateSpeedSlope,
  formatFixedValue
} = require('./conversions')
const {
  toAddressKey,
  wordsToFloat
} = require('./register-value-utils')
const {
  appendInputUnit
} = require('./input-value-utils')

const VSP_CURVE_ORDER = [
  '开机电压',
  '关机电压',
  '调速最低电压',
  '调速最高电压'
]

const SPEED_LOOP_INPUT_ORDER = [
  '速度最小值',
  '速度最大值',
  'SOUT_MAX'
]

const SPEED_LOOP_CALCULATED_NAMES = [
]

const TAILWIND_CALCULATED_NAMES = [
  'SPEED_KLPF_TAILWIND',
  'OBS_EA_KS_TAILWIND'
]

const ESTIMATOR_CALCULATED_PREFIXES = [
  'OBS_E',
  'OBS_FBASE',
  'OBS_EA_KS',
  'SPEED_KLPF',
  'FOC_KFG'
]

function formatInputValue(item, value) {
  if (value === '' || value === undefined || value === null) return '--'

  const numberValue = toFiniteNumber(value, NaN)
  if (!Number.isFinite(numberValue)) return value

  if (item.type === 'uint8_t' && (numberValue < 0 || numberValue > 0xFF)) return '--'

  if (item.type === 'float') return formatFixedValue(numberValue, 2)

  return String(Math.round(numberValue))
}

function getInputValues(registers) {
  return mergeInputValues(registers)
}

function getSharedParameterValues(registers, extraRegisters = []) {
  return {
    ...getSharedInputValues(),
    ...getInputValues(registers.concat(extraRegisters))
  }
}

function updateAtoBandwidthValues(registers, inputValues) {
  return registers.map((item) => ({
    ...item,
    ...calculateAtoGainWriteValues(item.inputValue, inputValues)
  }))
}

function updateInputWriteValues(registers) {
  const inputValues = getInputValues(registers)

  return registers.map((item) => ({
    ...item,
    writeValue: calculateParameterInputWriteValue(item, item.inputValue, inputValues)
  }))
}

function updateSpeedLoopExtraValues(registers, inputValues) {
  return registers.map((item) => {
    const writeValue = calculateParameterInputWriteValue(item, item.inputValue, inputValues)

    return {
      ...item,
      actualText: '',
      writeValue
    }
  })
}

function updateOilParameterValues(registers, inputValues) {
  return registers.map((item) => ({
    ...item,
    writeValue: calculateParameterInputWriteValue(item, item.inputValue, inputValues)
  }))
}

function updateSpeedSlope(register, inputValues) {
  const speedSlope = calculateSpeedSlope(inputValues)

  return {
    ...register,
    writeValue: speedSlope === null ? '--' : formatFixedValue(speedSlope, 2)
  }
}

function addSourceIndex(registers) {
  return registers.map((item, index) => ({
    ...item,
    sourceIndex: index
  }))
}

function isNameIn(names, item) {
  return names.includes(item.name)
}

function isTailwindAtoRegister(item) {
  return item.suffix === 'TAILWIND'
}

function isSpeedLoopCalculatedRegister(item) {
  return isNameIn(SPEED_LOOP_CALCULATED_NAMES, item)
}

function isTailwindCalculatedRegister(item) {
  return isNameIn(TAILWIND_CALCULATED_NAMES, item)
}

function isEstimatorCalculatedRegister(item) {
  if (isSpeedLoopCalculatedRegister(item) || isTailwindCalculatedRegister(item)) return false

  return ESTIMATOR_CALCULATED_PREFIXES.some((prefix) => item.name.startsWith(prefix))
}

function sortByNameOrder(registers, nameOrder) {
  return registers
    .filter((item) => nameOrder.includes(item.name))
    .slice()
    .sort((left, right) => nameOrder.indexOf(left.name) - nameOrder.indexOf(right.name))
}

function buildProtectionGroups(registers) {
  return {
    protectionDisplayRegisters: addSourceIndex(registers)
  }
}

function getWord(readValues, address) {
  return readValues.words[toAddressKey(address)]
}

function getRegisterReadValue(item, readValues) {
  if (item.area && item.area.key === 'coil') {
    const coilValue = readValues.coils[toAddressKey(item.address)]
    return coilValue === undefined ? null : coilValue
  }

  const firstWord = getWord(readValues, item.address)
  if (!Number.isInteger(firstWord)) return null

  if (item.type === 'uint8_t' && item.bytePosition) {
    return getByteRegisterValue(item, firstWord)
  }

  if (item.type === 'float') {
    const nextAddress = (parseInt(item.address, 16) + 1).toString(16).toUpperCase()
    return wordsToFloat(firstWord, getWord(readValues, nextAddress))
  }

  return firstWord
}

function formatReadValue(item, value) {
  if (value === null || value === undefined || !Number.isFinite(Number(value))) return null

  const numberValue = Number(value)

  if (item.type === 'float') return formatFixedValue(numberValue, 2)

  return String(Math.round(numberValue))
}

function getReadInputValue(item, readValue, readText, options = {}) {
  let inputText = readText

  if (options.useCalculatedInputValue) {
    const calculatedValue = calculateParameterReadValue(item, readValue, options.inputValues || {})

    if (calculatedValue !== null) {
      inputText = formatFixedValue(calculatedValue, 2)
    }
  }

  return appendInputUnit(item, inputText)
}

function getDqReadInputValue(item, rawText) {
  const rawValue = Number(rawText)
  if (!Number.isFinite(rawValue)) return ''

  if (item.gainType === 'kp') return formatFixedValue(rawValue / 4095, 2)
  if (item.gainType === 'ki') return formatFixedValue(rawValue / 32767, 2)

  return rawText
}

function applyReadValuesToRegisters(registers, readValues, options = {}) {
  return registers.map((item) => {
    const readValue = getRegisterReadValue(item, readValues)
    const readText = formatReadValue(item, readValue)

    if (readText === null) return item

    const nextItem = {
      ...item,
      isDirty: false,
      writeValue: readText
    }

    if (Object.prototype.hasOwnProperty.call(item, 'value')) {
      nextItem.value = Number(readValue) !== 0
    }

    if (options.updateInputValue) {
      nextItem.inputValue = getReadInputValue(item, readValue, readText, options)
    }

    if (options.updateDqInputValue) {
      nextItem.inputValue = getDqReadInputValue(item, readText)
    }

    return nextItem
  })
}

function applyReadValuesToAtoRegisters(registers, readValues) {
  return registers.map((item) => {
    const kpWord = getWord(readValues, item.kpAddress)
    const kiWord = getWord(readValues, item.kiAddress)

    if (!Number.isInteger(kpWord) && !Number.isInteger(kiWord)) return item

    return {
      ...item,
      isDirty: false,
      kpWriteValue: Number.isInteger(kpWord) ? String(kpWord) : item.kpWriteValue,
      kiWriteValue: Number.isInteger(kiWord) ? String(kiWord) : item.kiWriteValue
    }
  })
}

function clearDirty(registers = [], matcher = () => true) {
  return registers.map((item) => (
    matcher(item)
      ? {
        ...item,
        isDirty: false
      }
      : item
  ))
}

function clearGroupDirty(data, groupKey) {
  const nextState = {
    ...data
  }

  if (groupKey === 'estimator') {
    nextState.atoBandwidthInputRegisters = clearDirty(data.atoBandwidthInputRegisters)
    nextState.calculatedParameterRegisters = clearDirty(data.calculatedParameterRegisters, isEstimatorCalculatedRegister)
  }
  if (groupKey === 'dq') nextState.dqGainInputRegisters = clearDirty(data.dqGainInputRegisters)
  if (groupKey === 'tailwind') {
    nextState.tailwindSwitchRegisters = clearDirty(data.tailwindSwitchRegisters, (item) => item.name !== '预定位启用')
    nextState.atoBandwidthInputRegisters = clearDirty(data.atoBandwidthInputRegisters, isTailwindAtoRegister)
    nextState.calculatedParameterRegisters = clearDirty(data.calculatedParameterRegisters, isTailwindCalculatedRegister)
  }
  if (groupKey === 'preposition') {
    nextState.tailwindSwitchRegisters = clearDirty(data.tailwindSwitchRegisters, (item) => item.name === '预定位启用')
    nextState.prepositionParameterInputRegisters = clearDirty(data.prepositionParameterInputRegisters)
  }
  if (groupKey === 'speedLoop') {
    nextState.parameterInputRegisters = clearDirty(data.parameterInputRegisters, (item) => (
      SPEED_LOOP_INPUT_ORDER.includes(item.name)
    ))
    nextState.calculatedParameterRegisters = clearDirty(data.calculatedParameterRegisters, isSpeedLoopCalculatedRegister)
    nextState.speedLoopExtraRegisters = clearDirty(data.speedLoopExtraRegisters)
  }
  if (groupKey === 'vsp') {
    nextState.parameterInputRegisters = clearDirty(data.parameterInputRegisters, (item) => VSP_CURVE_ORDER.includes(item.name))
    nextState.speedSlopeRegister = {
      ...data.speedSlopeRegister,
      isDirty: false
    }
  }
  if (groupKey === 'oil') nextState.oilParameterInputRegisters = clearDirty(data.oilParameterInputRegisters)
  if (groupKey === 'protectionSwitch') nextState.protectionSwitchRegisters = clearDirty(data.protectionSwitchRegisters)
  if (groupKey === 'protection') nextState.protectionRegisters = clearDirty(data.protectionRegisters)

  return {
    ...nextState,
    ...buildViewState(nextState)
  }
}

function clearRegisterDirty(registers = [], index) {
  return registers.map((item, currentIndex) => (
    currentIndex === index
      ? {
        ...item,
        isDirty: false
      }
      : item
  ))
}

function clearTailwindSwitchDirty(data, index) {
  const nextState = {
    ...data,
    tailwindSwitchRegisters: clearRegisterDirty(data.tailwindSwitchRegisters, index)
  }

  return {
    ...nextState,
    ...buildViewState(nextState)
  }
}

function clearProtectionSwitchDirty(data, index) {
  return {
    ...data,
    protectionSwitchRegisters: clearRegisterDirty(data.protectionSwitchRegisters, index)
  }
}

function buildViewState(state) {
  const inputRegisters = addSourceIndex(state.parameterInputRegisters)
  const atoRegisters = addSourceIndex(state.atoBandwidthInputRegisters)
  const dqRegisters = addSourceIndex(state.dqGainInputRegisters)
  const calculatedRegisters = addSourceIndex(state.calculatedParameterRegisters)
  const speedLoopExtras = addSourceIndex(state.speedLoopExtraRegisters)
  const tailwindSwitches = addSourceIndex(state.tailwindSwitchRegisters)

  return {
    vspCurveRegisters: sortByNameOrder(inputRegisters, VSP_CURVE_ORDER),
    speedLoopInputDisplayRegisters: sortByNameOrder(inputRegisters, SPEED_LOOP_INPUT_ORDER),
    speedLoopCalculatedDisplayRegisters: calculatedRegisters.filter(isSpeedLoopCalculatedRegister),
    speedLoopExtraDisplayRegisters: speedLoopExtras,
    atoBandwidthDisplayRegisters: atoRegisters.filter((item) => !isTailwindAtoRegister(item)),
    tailwindAtoBandwidthDisplayRegisters: atoRegisters.filter(isTailwindAtoRegister),
    tailwindCalculatedDisplayRegisters: calculatedRegisters.filter(isTailwindCalculatedRegister),
    tailwindControlRegisters: tailwindSwitches.filter((item) => item.name !== '预定位启用'),
    prepositionSwitchRegisters: tailwindSwitches.filter((item) => item.name === '预定位启用'),
    prepositionParameterDisplayRegisters: addSourceIndex(state.prepositionParameterInputRegisters),
    dqGainDisplayRegisters: dqRegisters,
    estimatorCalculatedDisplayRegisters: calculatedRegisters.filter(isEstimatorCalculatedRegister),
    ...buildProtectionGroups(state.protectionRegisters)
  }
}

function createInitialState() {
  const state = {
    atoBandwidthInputRegisters,
    atoBandwidthDisplayRegisters: [],
    calculatedParameterRegisters,
    dqGainInputRegisters,
    dqGainDisplayRegisters: [],
    estimatorCalculatedDisplayRegisters: [],
    oilParameterInputRegisters,
    parameterInputRegisters,
    prepositionParameterDisplayRegisters: [],
    prepositionParameterInputRegisters,
    prepositionSwitchRegisters: [],
    protectionDisplayRegisters: [],
    protectionRegisters,
    protectionSwitchRegisters,
    speedLoopExtraRegisters,
    speedLoopExtraDisplayRegisters: [],
    speedLoopCalculatedDisplayRegisters: [],
    speedLoopInputDisplayRegisters: [],
    speedSlopeRegister,
    tailwindAtoBandwidthDisplayRegisters: [],
    tailwindCalculatedDisplayRegisters: [],
    tailwindControlRegisters: [],
    tailwindSwitchRegisters,
    vspCurveRegisters: []
  }

  return {
    ...state,
    ...buildViewState(state)
  }
}

function refreshState(data) {
  const inputValues = getSharedParameterValues(data.parameterInputRegisters, data.speedLoopExtraRegisters)
  const nextSpeedLoopExtraRegisters = updateSpeedLoopExtraValues(data.speedLoopExtraRegisters, inputValues)
  const nextState = {
    ...data,
    atoBandwidthInputRegisters: updateAtoBandwidthValues(data.atoBandwidthInputRegisters, inputValues),
    oilParameterInputRegisters: updateOilParameterValues(data.oilParameterInputRegisters, inputValues),
    speedLoopExtraRegisters: nextSpeedLoopExtraRegisters,
    speedSlopeRegister: updateSpeedSlope(data.speedSlopeRegister, inputValues)
  }

  return {
    ...nextState,
    ...buildViewState(nextState)
  }
}

function applyReadValues(data, readValues) {
  const inputValues = getSharedParameterValues(data.parameterInputRegisters, data.speedLoopExtraRegisters)
  const nextState = {
    ...data,
    atoBandwidthInputRegisters: applyReadValuesToAtoRegisters(data.atoBandwidthInputRegisters, readValues),
    calculatedParameterRegisters: applyReadValuesToRegisters(data.calculatedParameterRegisters, readValues),
    dqGainInputRegisters: applyReadValuesToRegisters(data.dqGainInputRegisters, readValues, {
      updateDqInputValue: true
    }),
    oilParameterInputRegisters: applyReadValuesToRegisters(data.oilParameterInputRegisters, readValues, {
      inputValues,
      updateInputValue: true,
      useCalculatedInputValue: true
    }),
    parameterInputRegisters: applyReadValuesToRegisters(data.parameterInputRegisters, readValues, {
      inputValues,
      updateInputValue: true,
      useCalculatedInputValue: true
    }),
    prepositionParameterInputRegisters: applyReadValuesToRegisters(data.prepositionParameterInputRegisters, readValues, {
      updateInputValue: true
    }),
    protectionRegisters: applyReadValuesToRegisters(data.protectionRegisters, readValues, {
      inputValues,
      updateInputValue: true,
      useCalculatedInputValue: true
    }),
    protectionSwitchRegisters: applyReadValuesToRegisters(data.protectionSwitchRegisters, readValues),
    speedLoopExtraRegisters: applyReadValuesToRegisters(data.speedLoopExtraRegisters, readValues, {
      updateInputValue: true
    }),
    speedSlopeRegister: applyReadValuesToRegisters([data.speedSlopeRegister], readValues)[0],
    tailwindSwitchRegisters: applyReadValuesToRegisters(data.tailwindSwitchRegisters, readValues)
  }

  return {
    ...nextState,
    ...buildViewState(nextState)
  }
}

function applyParameterInput(data, index, value) {
  const changedRegisters = data.parameterInputRegisters.map((item, currentIndex) => {
    if (currentIndex !== index) return item

    return {
      ...item,
      isDirty: true,
      inputValue: value,
      writeValue: formatInputValue(item, value)
    }
  })
  const nextRegisters = updateInputWriteValues(changedRegisters)
  const inputValues = getSharedParameterValues(nextRegisters, data.speedLoopExtraRegisters)
  const nextState = {
    ...data,
    parameterInputRegisters: nextRegisters,
    atoBandwidthInputRegisters: updateAtoBandwidthValues(data.atoBandwidthInputRegisters, inputValues),
    speedLoopExtraRegisters: updateSpeedLoopExtraValues(data.speedLoopExtraRegisters, inputValues),
    speedSlopeRegister: updateSpeedSlope(data.speedSlopeRegister, inputValues)
  }

  return {
    ...nextState,
    ...buildViewState(nextState)
  }
}

function applyAtoBandwidthInput(data, index, value) {
  const inputValues = getSharedParameterValues(data.parameterInputRegisters)
  const nextRegisters = data.atoBandwidthInputRegisters.map((item, currentIndex) => {
    if (currentIndex !== index) return item

    return {
      ...item,
      isDirty: true,
      inputValue: value,
      ...calculateAtoGainWriteValues(value, inputValues)
    }
  })
  const nextState = {
    ...data,
    atoBandwidthInputRegisters: nextRegisters
  }

  return {
    ...nextState,
    ...buildViewState(nextState)
  }
}

function applyDqGainInput(data, index, value) {
  const nextRegisters = data.dqGainInputRegisters.map((item, currentIndex) => {
    if (currentIndex !== index) return item

    return {
      ...item,
      isDirty: true,
      inputValue: value,
      writeValue: calculateDqGainWriteValue(item, value)
    }
  })
  const nextState = {
    ...data,
    dqGainInputRegisters: nextRegisters
  }

  return {
    ...nextState,
    ...buildViewState(nextState)
  }
}

function applySpeedLoopExtraInput(data, index, value) {
  const changedRegisters = data.speedLoopExtraRegisters.map((item, currentIndex) => {
    if (currentIndex !== index) return item

    return {
      ...item,
      isDirty: true,
      inputValue: value
    }
  })
  const inputValues = getSharedParameterValues(data.parameterInputRegisters, changedRegisters)
  const nextState = {
    ...data,
    speedLoopExtraRegisters: updateSpeedLoopExtraValues(changedRegisters, inputValues)
  }

  return {
    ...nextState,
    ...buildViewState(nextState)
  }
}

function applyOilParameterInput(data, index, value) {
  const changedRegisters = data.oilParameterInputRegisters.map((item, currentIndex) => {
    if (currentIndex !== index) return item

    return {
      ...item,
      isDirty: true,
      inputValue: value
    }
  })
  const inputValues = getSharedParameterValues(data.parameterInputRegisters, data.speedLoopExtraRegisters)
  const nextState = {
    ...data,
    oilParameterInputRegisters: updateOilParameterValues(changedRegisters, inputValues)
  }

  return nextState
}

function applyPrepositionParameterInput(data, index, value) {
  const nextState = {
    ...data,
    prepositionParameterInputRegisters: data.prepositionParameterInputRegisters.map((item, currentIndex) => {
      if (currentIndex !== index) return item

      return {
        ...item,
        isDirty: true,
        inputValue: value,
        writeValue: formatInputValue(item, value)
      }
    })
  }

  return {
    ...nextState,
    ...buildViewState(nextState)
  }
}

function applyTailwindSwitchChange(data, index, checked) {
  const nextState = {
    ...data,
    tailwindSwitchRegisters: data.tailwindSwitchRegisters.map((item, currentIndex) => {
      if (currentIndex !== index) return item

      return {
        ...item,
        isDirty: true,
        value: checked,
        writeValue: checked ? 1 : 0
      }
    })
  }

  return {
    ...nextState,
    ...buildViewState(nextState)
  }
}

function applyProtectionSwitchChange(data, index, checked) {
  return {
    ...data,
    protectionSwitchRegisters: data.protectionSwitchRegisters.map((item, currentIndex) => {
      if (currentIndex !== index) return item

      return {
        ...item,
        isDirty: true,
        value: checked,
        writeValue: checked ? 1 : 0
      }
    })
  }
}

function applyProtectionInput(data, index, value) {
  const nextRegisters = data.protectionRegisters.map((item, currentIndex) => {
    if (currentIndex !== index) return item

    return {
      ...item,
      isDirty: true,
      inputValue: value,
      writeValue: value === '' ? '--' : calculateProtectionWriteValue(item, toFiniteNumber(value, NaN))
    }
  })

  return {
    ...data,
    protectionRegisters: nextRegisters,
    ...buildProtectionGroups(nextRegisters)
  }
}

function getInputRegister(data, group, index) {
  if (group === 'parameter') return data.parameterInputRegisters[index]
  if (group === 'ato') return data.atoBandwidthInputRegisters[index]
  if (group === 'dq') return data.dqGainInputRegisters[index]
  if (group === 'speedLoopExtra') return data.speedLoopExtraRegisters[index]
  if (group === 'oil') return data.oilParameterInputRegisters[index]
  if (group === 'preposition') return data.prepositionParameterInputRegisters[index]
  if (group === 'protection') return data.protectionRegisters[index]

  return null
}

function applyInputBlur(data, group, index, value) {
  const item = getInputRegister(data, group, index)
  if (!item) return data

  const inputValue = appendInputUnit(item, value === undefined ? item.inputValue : value)

  if (group === 'parameter') return applyParameterInput(data, index, inputValue)
  if (group === 'ato') return applyAtoBandwidthInput(data, index, inputValue)
  if (group === 'dq') return applyDqGainInput(data, index, inputValue)
  if (group === 'speedLoopExtra') return applySpeedLoopExtraInput(data, index, inputValue)
  if (group === 'oil') return applyOilParameterInput(data, index, inputValue)
  if (group === 'preposition') return applyPrepositionParameterInput(data, index, inputValue)
  if (group === 'protection') return applyProtectionInput(data, index, inputValue)

  return data
}

module.exports = {
  applyAtoBandwidthInput,
  clearGroupDirty,
  clearProtectionSwitchDirty,
  clearTailwindSwitchDirty,
  applyDqGainInput,
  applyInputBlur,
  applyOilParameterInput,
  applyParameterInput,
  applyPrepositionParameterInput,
  applyProtectionInput,
  applyProtectionSwitchChange,
  applyReadValues,
  applySpeedLoopExtraInput,
  applyTailwindSwitchChange,
  createInitialState,
  refreshState
}