uci-interrupt/src/interrupt.mjs

import bus, { Gpio } from 'pigpio'
// import bus, { Gpio } from 'pigpio-mock'
// import btc from 'better-try-catch'
import debounce from 'lodash.debounce'
// import throttle from 'lodash.throttle'
// import debounce from 'debounce-fn'
import Base from '@uci/base'

import logger from '@uci/logger'
let log = {}
const LOG_OPTS = (id) => {
  return {
    repo:'uci-interrupt',
    npm:'@uci/interrupt',
    file:'src/interrupt.mjs',
    class:'Interrupt',
    id:id,
    instance_created:new Date().getTime()
  }}

export default class Interrupt extends Base {
  constructor(pin,opts={}) {

    opts.itrt = opts.itrt || {}
    if (opts.itrt || opts.host) {
      opts.itrt.host = opts.host || opts.itrt.host
      if (opts.itrt.host) {
        opts.itrt.port =   opts.itrt.port || opts.port || 9000+pin
        opts.sockets = (opts.sockets ? (opts.sockets + ',') : '') + 'itrt#c>t'
      }
    }
    if (opts.path  || opts.itrn || !opts.itrt.host) {
      opts.itrn = opts.itrn || {}
      opts.itrn.path = opts.path || opts.itrn.path || 'interrupt:'+ pin
      opts.sockets = (opts.sockets ? (opts.sockets + ',') : '') + 'itrn#c>n'
    }
    if (opts.sockets==='') throw ('must have at least one socket client')
    super(opts)
    console.dir(opts)
    log = logger.child(LOG_OPTS(this.id))
    log.info({pins:pin, opts:opts},'created interrupt with these opts')
    this.pin_num = pin
    this.mock = opts.mock
    this.wait = opts.wait || 0  // debounce is off by default
    this.dbopts = { maxWait:opts.maxwait || 500, leading: opts.leading || true, trailing:opts.trailing || false}
    this.edge = opts.edge || Gpio.RISING_EDGE
    this.pin = new Gpio(
      pin, {
        mode: Gpio.INPUT,
        pullUpDown: opts.pull || Gpio.PUD_DOWN
        // do not! set edge here as it will start the emitter -- see pigio js
      })
    this._hook = opts.hook
    this.packet = opts.packet || {}
    this.packet.pin = pin
    this.packet.cmd = this.packet.cmd || 'interrupt'
    this.packet.count = 0


  }  // end constructor


  async init(){
    await super.init()
    // for cntrl-c exit of interrupt
    process.on('SIGINT', () => {
      this.exit().then((resp) => console.log('\n', resp)) // unexport on cntrl-c
        .catch(err => console.log('error:', err))
    })
    // const pinDebounce = function (processor, wait, options, packet) {
    //   console.log(processor,wait,options,packet)
    //   return debounce.bind(this,processor.bind(this,packet),wait, options)
    // return debounce.bind(processor.bind(this,packet),wait)
    // return debounce.bind(null,processor,{ wait:wait})
    // }
    // else cb = pinDebounce(this.interruptProcess,this.wait,this.dbopts,this.packet)

    let cb = () => {}
    if (this.wait===0) {
      cb = this._interruptProcess.bind(this,this.packet)
      console.log(`starting interrupt on pin ${this.pin_num} without debounce`)
      log.info({packet:this.packet},`starting interrupt on pin ${this.pin_num} without debounce`)
    }
    else {
      cb = debounce(this._interruptProcess.bind(this,this.packet),this.wait,this.dbopts)
      console.log(`starting interrupt on pin ${this.pin_num} with debounce wait:${this.wait} options:${JSON.stringify(this.dbopts)}` )
      log.info({packet:this.packet, wait:this.wait, options:this.dbopts},`starting interrupt on pin ${this.pin_num} with debounce wait:${this.wait}` )
    }
    this.pin.on('interrupt',cb)
    // rock n roll!!, start the pigpio interrupt
    if(!this.mock) this.pin.enableInterrupt(this.edge)
  }


  // manual firing for testing
  fire() {
    console.log('manually firing interrupt for pin', this.pin_num)
    this.pin.emit('interrupt',1)
  }

  exit() {
    bus.terminate()
    return Promise.reject('keyboard termination...terminating interrupts')
  }

  // default processor
  async _interruptProcess (packet) {
    packet.count += 1
    packet.time = new Date().getTime()
    if(this._hook) packet = this.hook(packet)
    // console.log('packet sending',packet)
    this.send(packet)
  }

  //sample hook
  hook (packet) {
    // new Promise((resolve) => {
    console.log('=======================')
    console.log(`pin ${packet.pin} on sbc gpio bus has thrown an interrupt`)
    console.log('sending to all connected sockets with default cmd:"interrupt"')
    console.dir(packet)
    console.log('this is the default beforeHook')
    console.log('add  "beforeHook" for your instance or extended class')
    console.log('=======================')
    return packet
    // resolve(packet)
    // })

  }


} // end Class