uci-mcp/src/commands.mjs

// import _ from '@uci/utils/src/byte'
// import _ from '../../archive/uci-utils/src/byte'
import _ from '@uci/utils/src/byte'
import { CHIP, PIN } from './config'

export const chip = {
  // for custom chip configuration set packet.cfg='custom' then packet.setting should be a
  // configuration byte with given format ('STR' by defaul).
  cfg: async function(packet){
    // first make sure chip is in set to BANK=0 if not already
    let bus = await this.bus.write(0x05,0)
    if (bus.error) return bus
    let setting = {}
    let cfg = packet.cfg || 'default'
    if (cfg === 'custom') setting = {val:packet.setting, fmt:packet.fmt || 'STR'}
    else {
      if (CHIP[cfg]) setting = CHIP[cfg]
      else return {error:`no chip settings for ${cfg}`}
    }
    let byte = _.byteFormat(setting.val, { in: setting.fmt, out: 'DEC' })
    if (byte < 128) byte += 128  // make sure BANK=1 remains on
    let reg = this.chip17 ? 0x0A : 0x05
    bus = await this.bus.write(reg,byte)
    if (bus.error) return bus
    bus = await this.bus.read(0x05)
    if (bus.error) return bus
    return { cmd:'reply', response:_.byteFormat(bus.response,{in:'DEC',out:'STR'}) }
  }
}

// Individual Pin Configurations
// set is for cfg: 'custom'  assume a setting is zero unless given
// packet = { pin:, port:, cfg: , set:{dir: 0, ivrt: 0, pullup: 0, intr: 0, usedef: 0,defval: 0} }
// first get the current byte (pin) state for that setting
export const pin = {
  cfg: async function(packet){
    let cfg = {}
    let reply = { cmd:'reply', status:{} }
    packet.cfg = packet.cfg || 'output'
    if (packet.cfg==='custom') cfg = packet.set
    else cfg = PIN.cfgset[packet.cfg]
    for(let name of Object.keys(PIN.setting)) {
      let op = cfg[name] ? 'on' : 'off'
      // console.log(name, op)
      let busreply = await this.pin._state(packet,op,PIN.setting[name])
      if (busreply.error) return busreply
      reply.status[name] = busreply.status
    }
    return reply
  },

  // state is equivalent to read
  status: async function (packet) {
    let reg = packet.reg ? PIN.cmd[packet.reg] : PIN.cmd.gpio
    if (!reg) return {error:`unknown register ${packet.reg}`, packet:packet }
    let reply = { cmd:'reply'}
    let pins = parsePins(packet.pins)
    let state = new _.Byte()
    let bus = await this.bus.read(sreg(reg, packet.port))
    if (bus.error) return bus
    state.value = bus.response
    reply.status =
    { port:state.toFmt('ARY'),
      pins: pins.value.map(pin => {
        if (state.toFmt('PLC').indexOf(pin) !==-1) return [pin, 'on']
        else return [pin,'off']
      })
    }
    return reply
  },
  _state: async function(packet,op,reg){
    reg = (reg!==undefined)? reg : PIN.cmd.gpio
    // console.log(op, reg, packet)
    let reply = { cmd:'reply'}
    let pins = parsePins(packet.pins)
    let state = new _.Byte()
    let bus = await this.bus.read(sreg(reg,packet.port))
    if (bus.error) return bus
    state.value = bus.response
    bus = await this.bus.write(sreg(reg,packet.port),state.bwOp(pins.value,op,{in:'PLC', out:'DEC'}))
    if (bus.error) return bus
    bus = await this.bus.read(sreg(reg,packet.port))
    if (bus.error) return bus
    state.value = bus.response
    reply.status = state.bwOp(pins.value,'check',{in:'PLC', out:'PLC'})
    return reply
  },
  // threse three only for output pins
  state : {
    on: async function (packet) {
      return this.pin._state(packet,'on')
    },
    off: async function (packet) {
      return this.pin._state(packet,'off')
    },
    toggle: async function (packet) {
      return this.pin._state(packet,'toggle')
    }
  },
  // will create packet to determine pin caused interrupt, packet will come from interrupt module
  interrupt: {
    find: async function (packet) {
      console.log('interrupt fired',packet)
      return Promise.resolve({cmd:null})
    },
    report: ()=>{}, // come here after determining which pin to report to requester
    async: async ()=>{}
  }
}

const parsePins = function(pins) {
  if (typeof pins==='number') pins = [pins]
  if (typeof pins==='string') {
    if (pins==='all') pins = _.byteFormat(255,{in:'DEC', out:'PLC'})
    else pins = pins.split(/[,:\s]+/).map(Number).filter( (x) => !Number.isNaN(x))
  }
  return new _.Byte(pins,'PLC')
}

const sreg = (reg,port) => {
  return reg + ((port==='B') ? 0x10 : 0)
}