namespace sensors.internal {
    export class Poller {
        private query: () => number;
        private update: (previous: number, current: number) => void;
        public interval: number;

        private previousValue: number;
        private currentValue: number;
        private lastQuery: number; // track down the last time we did a query/update cycle
        private lastPause: number;  // track down the last time we pause in the sensor polling loop

        constructor(interval: number, query: () => number, update: (previous: number, current: number) => void) {
            this.interval = interval | 0;
            this.query = query;
            this.update = update;

            this.poll();
        }

        poke(): void {
            const now = control.millis();
            if (now - this.lastQuery >= this.interval * 2)
                this.queryAndUpdate(); // sensor poller is not allowed to run
            if (now - this.lastPause >= this.interval * 5)
                pause(1); // allow events to trigger
        }

        private queryAndUpdate() {
            this.lastQuery = control.millis();
            this.currentValue = this.query();
            if (this.previousValue != this.currentValue) {
                this.update(this.previousValue, this.currentValue);
                this.previousValue = this.currentValue;
            }
        }

        private poll() {
            control.runInBackground(() => {
                this.lastQuery = this.lastPause = control.millis();
                this.previousValue = this.currentValue = this.query();
                this.update(this.previousValue, this.currentValue);
                while (true) {
                    this.lastPause = control.millis();
                    pause(this.interval);
                    this.queryAndUpdate();
                }
            })
        }
    }

    export function bufferToString(buf: Buffer): string {
        let s = ''
        for (let i = 0; i < buf.length; i++)
            s += String.fromCharCode(buf[i])

        return s
    }

    let analogMM: MMap
    let uartMM: MMap
    let IICMM: MMap
    let powerMM: MMap
    let devcon: Buffer
    let devPoller: Poller
    let sensorInfos: SensorInfo[];

    let batteryInfo: {
        CinCnt: number;
        CoutCnt: number;
        VinCnt: number;
    };
    let batteryVMin: number;
    let batteryVMax: number;

    class SensorInfo {
        port: number
        sensor: Sensor
        sensors: Sensor[]
        connType: number
        devType: number
        iicid: string
        poller: Poller;

        constructor(p: number) {
            this.port = p
            this.connType = DAL.CONN_NONE
            this.devType = DAL.DEVICE_TYPE_NONE
            this.iicid = ''
            this.sensors = []
            this.poller = new Poller(25, () => this.query(), (prev, curr) => this.update(prev, curr));
        }

        poke() {
            this.poller.poke();
        }

        private query() {
            if (this.sensor) return this.sensor._query();
            return 0;
        }

        private update(prev: number, curr: number) {
            if (this.sensor) this.sensor._update(prev, curr)
        }
    }

    function init() {
        if (sensorInfos) return
        sensorInfos = []
        for (let i = 0; i < DAL.NUM_INPUTS; ++i) sensorInfos.push(new SensorInfo(i))
        devcon = output.createBuffer(DevConOff.Size)

        analogMM = control.mmap("/dev/lms_analog", AnalogOff.Size, 0)
        if (!analogMM) control.fail("no analog sensor")

        uartMM = control.mmap("/dev/lms_uart", UartOff.Size, 0)
        if (!uartMM) control.fail("no uart sensor")

        IICMM = control.mmap("/dev/lms_iic", IICOff.Size, 0)
        if (!IICMM) control.fail("no iic sensor")

        powerMM = control.mmap("/dev/lms_power", 2, 0)

        devPoller = new Poller(250, () => { return hashDevices(); },
            (prev, curr) => {
                detectDevices();
            });
    }

    export function getActiveSensors(): Sensor[] {
        init();
        return sensorInfos.filter(si => si.sensor && si.sensor.isActive()).map(si => si.sensor);
    }

    function readUartInfo(port: number, mode: number) {
        let buf = output.createBuffer(UartCtlOff.Size)
        buf[UartCtlOff.Port] = port
        buf[UartCtlOff.Mode] = mode
        uartMM.ioctl(IO.UART_READ_MODE_INFO, buf)
        return buf
        //let info = `t:${buf[TypesOff.Type]} c:${buf[TypesOff.Connection]} m:${buf[TypesOff.Mode]} n:${buf.slice(0, 12).toHex()}`
        //serial.writeLine("UART " + port + " / " + mode + " - " + info)
    }

    export function readIICID(port: number) {
        const buf = output.createBuffer(IICStr.Size)
        buf[IICStr.Port] = port
        IICMM.ioctl(IO.IIC_READ_TYPE_INFO, buf)
        const manufacturer = bufferToString(buf.slice(IICStr.Manufacturer, 8))
        const sensorType = bufferToString(buf.slice(IICStr.SensorType, 8))
        return manufacturer + sensorType;
    }

    const ADC_REF = 5000                  //!< [mV]  maximal value on ADC
    const ADC_RES = 4095                  //!< [CNT] maximal count on ADC
    // see c_ui.c
    const SHUNT_IN = 0.11              //  [Ohm]
    const AMP_CIN = 22.0              //  [Times]

    const EP2_SHUNT_IN = 0.05              //  [Ohm]
    const EP2_AMP_CIN = 15.0              //  [Times]

    const SHUNT_OUT = 0.055             //  [Ohm]
    const AMP_COUT = 19.0              //  [Times]

    const VCE = 0.05              //  [V]
    const AMP_VIN = 0.5               //  [Times]

    const AVR_CIN = 300
    const AVR_COUT = 30
    const AVR_VIN = 30
    // lms2012
    const BATT_INDICATOR_HIGH = 7500          //!< Battery indicator high [mV]
    const BATT_INDICATOR_LOW = 6200          //!< Battery indicator low [mV]
    const ACCU_INDICATOR_HIGH = 7500          //!< Rechargeable battery indicator high [mV]
    const ACCU_INDICATOR_LOW = 7100          //!< Rechargeable battery indicator low [mV]    

    function CNT_V(C: number) {
        return ((C * ADC_REF) / (ADC_RES * 1000.0))
    }

    function updateBatteryInfo() {
        let CinCnt = analogMM.getNumber(NumberFormat.Int16LE, AnalogOff.BatteryCurrent);
        let CoutCnt = analogMM.getNumber(NumberFormat.Int16LE, AnalogOff.MotorCurrent);
        let VinCnt = analogMM.getNumber(NumberFormat.Int16LE, AnalogOff.Cell123456);
        if (!batteryInfo) {
            batteryVMin = BATT_INDICATOR_LOW;
            batteryVMax = BATT_INDICATOR_HIGH;
            if (powerMM) {
                const accu = powerMM.getNumber(NumberFormat.UInt8LE, 0);
                if (accu > 0) {
                    control.dmesg("rechargeable battery")
                    batteryVMin = ACCU_INDICATOR_LOW;
                    batteryVMax = ACCU_INDICATOR_HIGH;
                }
            }
            batteryInfo = {
                CinCnt: CinCnt,
                CoutCnt: CoutCnt,
                VinCnt: VinCnt
            };
            // update in background
            control.runInParallel(() => forever(updateBatteryInfo));
        } else {
            CinCnt = batteryInfo.CinCnt = ((batteryInfo.CinCnt * (AVR_CIN - 1)) + CinCnt) / AVR_CIN;
            CoutCnt = batteryInfo.CoutCnt = ((batteryInfo.CoutCnt * (AVR_COUT - 1)) + CoutCnt) / AVR_COUT;
            VinCnt = batteryInfo.VinCnt = ((batteryInfo.VinCnt * (AVR_VIN - 1)) + VinCnt) / AVR_VIN;
        }
    }

    export interface BatteryInfo {
        level: number;
        Ibatt: number,
        Vbatt: number,
        Imotor: number
    }

    export function getBatteryInfo(): BatteryInfo {
        init();
        if (!batteryInfo) updateBatteryInfo();
        const CinCnt = batteryInfo.CinCnt;
        const CoutCnt = batteryInfo.CoutCnt;
        const VinCnt = batteryInfo.VinCnt;
        /*
void      cUiUpdatePower(void)
{
#ifndef Linux_X86
  DATAF   CinV;
  DATAF   CoutV;

  if ((UiInstance.Hw == FINAL) || (UiInstance.Hw == FINALB))
  {
    CinV                =  CNT_V(UiInstance.CinCnt) / AMP_CIN;
    UiInstance.Vbatt    =  (CNT_V(UiInstance.VinCnt) / AMP_VIN) + CinV + VCE;

    UiInstance.Ibatt    =  CinV / SHUNT_IN;
    CoutV               =  CNT_V(UiInstance.CoutCnt) / AMP_COUT;
    UiInstance.Imotor   =  CoutV / SHUNT_OUT;

  }
  else
  {
    CinV                =  CNT_V(UiInstance.CinCnt) / EP2_AMP_CIN;
    UiInstance.Vbatt    =  (CNT_V(UiInstance.VinCnt) / AMP_VIN) + CinV + VCE;

    UiInstance.Ibatt    =  CinV / EP2_SHUNT_IN;
    UiInstance.Imotor   =  0;

  }

#endif
#ifdef DEBUG_TEMP_SHUTDOWN

  UiInstance.Vbatt  =  7.0;
  UiInstance.Ibatt  =  5.0;

#endif
}        
        */
        const CinV = CNT_V(CinCnt) / AMP_CIN;
        const Vbatt = CNT_V(VinCnt) / AMP_VIN + CinV + VCE;
        const Ibatt = CinV / SHUNT_IN;
        const CoutV = CNT_V(CoutCnt) / AMP_COUT;
        const Imotor = CoutV / SHUNT_OUT;
        const level = Math.max(0, Math.min(100, Math.floor((Vbatt * 1000.0 - batteryVMin)
            / (batteryVMax - batteryVMin) * 100)));

        return {
            level: level,
            Vbatt: Vbatt,
            Ibatt: Ibatt,
            Imotor: Imotor
        };
    }

    function hashDevices(): number {
        const conns = analogMM.slice(AnalogOff.InConn, DAL.NUM_INPUTS)
        let r = 0;
        for (let i = 0; i < conns.length; ++i) {
            r = (r << 8 | conns[i]);
        }
        return r;
    }

    let nonActivated = 0;
    function detectDevices() {
        //control.dmesg(`detect devices (${nonActivated} na)`)
        const inDcm = analogMM.slice(AnalogOff.InDcm, DAL.NUM_INPUTS)
        const inConn = analogMM.slice(AnalogOff.InConn, DAL.NUM_INPUTS)
        let numChanged = 0;
        const uartSensors: SensorInfo[] = [];

        for (const sensorInfo of sensorInfos) {
            const newConn = inConn[sensorInfo.port]
            if (newConn == sensorInfo.connType) {
                // control.dmesg(`connection unchanged ${newConn} at ${sensorInfo.port}`)
                continue;
            }
            numChanged++
            sensorInfo.connType = newConn
            sensorInfo.devType = DAL.DEVICE_TYPE_NONE;
            switch (newConn) {
                case DAL.CONN_INPUT_UART: {
                    control.dmesg(`new UART connection at ${sensorInfo.port}`)
                    updateUartMode(sensorInfo.port, 0);
                    uartSensors.push(sensorInfo);
                    break;
                }
                case DAL.CONN_NXT_IIC: {
                    control.dmesg(`new NXT IIC connection at ${sensorInfo.port}`)
                    sensorInfo.devType = DAL.DEVICE_TYPE_IIC_UNKNOWN
                    sensorInfo.iicid = readIICID(sensorInfo.port)
                    control.dmesg(`IIC ID ${sensorInfo.iicid.length}`)
                    break;
                } case DAL.CONN_NXT_DUMB: { // analog NXT sensor
                    control.dmesg(`new NXT analog connection at ${sensorInfo.port}`);
                    sensorInfo.devType = inDcm[sensorInfo.port];
                    control.dmesg(`NXT analog dev type ${sensorInfo.devType}`);
                    break;
                }
                case DAL.CONN_INPUT_DUMB: {
                    control.dmesg(`new DUMB connection at ${sensorInfo.port}`)
                    // TODO? for now assume touch
                    sensorInfo.devType = DAL.DEVICE_TYPE_TOUCH
                    break;
                }
                case DAL.CONN_NONE:
                case 0: {
                    //control.dmesg(`disconnect at port ${sensorInfo.port}`)
                    break;
                }
                default: {
                    control.dmesg(`unknown connection type: ${newConn} at ${sensorInfo.port}`)
                    break;
                }
            }

            if (uartSensors.length > 0) {
                setUartModes();
                for (const sensorInfo of uartSensors) {
                    let uinfo = readUartInfo(sensorInfo.port, 0)
                    sensorInfo.devType = uinfo[TypesOff.Type]
                    control.dmesg(`UART type ${sensorInfo.devType}`)
                }
            }

            if (numChanged == 0 && nonActivated == 0)
                return

            //control.dmesg(`updating sensor status`)
            nonActivated = 0;
            for (const sensorInfo of sensorInfos) {
                if (sensorInfo.devType == DAL.DEVICE_TYPE_IIC_UNKNOWN) {
                    sensorInfo.sensor = sensorInfo.sensors.filter(s => s._IICId() == sensorInfo.iicid)[0]
                    if (!sensorInfo.sensor) {
                        control.dmesg(`sensor not found for iicid=${sensorInfo.iicid} at ${sensorInfo.port}`)
                        nonActivated++;
                    } else {
                        control.dmesg(`sensor connected iicid=${sensorInfo.iicid} at ${sensorInfo.port}`)
                        sensorInfo.sensor._activated()
                    }
                } else if (sensorInfo.devType != DAL.DEVICE_TYPE_NONE) {
                    sensorInfo.sensor = sensorInfo.sensors.filter(s => s._deviceType() == sensorInfo.devType)[0]
                    if (!sensorInfo.sensor) {
                        control.dmesg(`sensor not found for type=${sensorInfo.devType} at ${sensorInfo.port}`)
                        nonActivated++;
                    } else {
                        control.dmesg(`sensor connected type=${sensorInfo.devType} at ${sensorInfo.port}`)
                        sensorInfo.sensor._activated()
                    }
                }
            }
            //control.dmesg(`detect devices done`)
        }
    }

    export class Sensor extends control.Component {
        protected _port: number // this is 0-based

        constructor(port_: number) {
            super()
            if (!(1 <= port_ && port_ <= DAL.NUM_INPUTS))
                control.panic(120)
            this._port = port_ - 1
            init()
            sensorInfos[this._port].sensors.push(this)
            this.markUsed();
        }

        poke() {
            if (this.isActive())
                sensorInfos[this._port].poke();
        }

        markUsed() {
            sensors.__sensorUsed(this._port, this._deviceType());
        }

        _activated() { }

        // 1-based
        port() {
            return this._port + 1
        }

        isActive() {
            return sensorInfos[this._port].sensor == this
        }

        _query() {
            return 0
        }

        _info(): string {
            return this._query().toString();
        }

        _update(prev: number, curr: number) {
        }

        _deviceType() {
            return 0
        }

        _IICId() {
            return ''
        }
    }

    export class AnalogSensor extends Sensor {
        constructor(port: number) {
            super(port)
        }

        _readPin6() {
            if (!this.isActive()) return 0
            return analogMM.getNumber(NumberFormat.Int16LE, AnalogOff.InPin6 + 2 * this._port)
        }
    }

    export class UartSensor extends Sensor {
        protected mode: number // the mode user asked for
        protected realmode: number // the mode the hardware is in

        constructor(port: number) {
            super(port)
            this.mode = 0
            this.realmode = 0
        }

        _activated() {
            this.realmode = 0
            this._setMode(this.mode)
        }

        protected _setMode(m: number) {
            //control.dmesg(`_setMode p=${this.port} m: ${this.realmode} -> ${m}`)
            let v = m | 0
            this.mode = v
            if (!this.isActive()) return
            if (this.realmode != this.mode) {
                this.realmode = v
                setUartMode(this._port, v)
            }
        }

        getBytes(): Buffer {
            return getUartBytes(this.isActive() ? this._port : -1)
        }

        getNumber(fmt: NumberFormat, off: number) {
            if (!this.isActive())
                return 0
            return getUartNumber(fmt, off, this._port)
        }

        reset() {
            if (this.isActive()) uartReset(this._port);
            this.realmode = 0;
        }
    }

    export class IICSensor extends Sensor {
        protected mode: number // the mode user asked for
        protected realmode: number // the mode the hardware is in
        private readLength: number

        constructor(port: number) {
            super(port)
            this.mode = 0
            this.realmode = 0
            this.readLength = 1;
        }

        _activated() {
            this.realmode = 0
            this._setMode(this.mode)
        }

        protected _setMode(m: number) {
            let v = m | 0
            this.mode = v
            if (!this.isActive()) return
            if (this.realmode != this.mode) {
                this.realmode = v
                setIICMode(this._port, this._deviceType(), v)
            }
        }

        getBytes(): Buffer {
            return getIICBytes(this.isActive() ? this._port : -1, this.readLength)
        }

        getNumber(fmt: NumberFormat, off: number) {
            if (!this.isActive())
                return 0
            return getIICNumber(this.readLength, fmt, off, this._port)
        }

        transaction(deviceAddress: number, write: number[], read: number) {
            this.readLength = read;
            transactionIIC(this._port, deviceAddress, write, read)
        }

        _deviceType() {
            return DAL.DEVICE_TYPE_IIC_UNKNOWN
        }
    }

    export const iicsensor = new IICSensor(3)

    function uartReset(port: number) {
        if (port < 0) return
        control.dmesg(`UART reset at ${port}`)
        devcon.setNumber(NumberFormat.Int8LE, DevConOff.Connection + port, DAL.CONN_NONE)
        devcon.setNumber(NumberFormat.Int8LE, DevConOff.Type + port, 0)
        devcon.setNumber(NumberFormat.Int8LE, DevConOff.Mode + port, 0)
        uartMM.ioctl(IO.UART_SET_CONN, devcon)
    }

    function getUartStatus(port: number) {
        if (port < 0) return 0
        return uartMM.getNumber(NumberFormat.Int8LE, UartOff.Status + port)
    }

    function waitNonZeroUartStatus(port: number) {
        while (true) {
            if (port < 0) return 0
            let s = getUartStatus(port)
            if (s) return s
            pause(25)
        }
    }

    function uartClearChange(port: number) {
        control.dmesg(`UART clear change`);
        const UART_DATA_READY = 8
        const UART_PORT_CHANGED = 1
        while (true) {
            let status = getUartStatus(port)
            if (port < 0) break

            if ((status & UART_DATA_READY) != 0 && (status & UART_PORT_CHANGED) == 0)
                break

            devcon.setNumber(NumberFormat.Int8LE, DevConOff.Connection + port, DAL.CONN_INPUT_UART)
            devcon.setNumber(NumberFormat.Int8LE, DevConOff.Type + port, 0)
            devcon.setNumber(NumberFormat.Int8LE, DevConOff.Mode + port, 0)

            uartMM.ioctl(IO.UART_CLEAR_CHANGED, devcon)

            uartMM.setNumber(NumberFormat.Int8LE, UartOff.Status + port,
                getUartStatus(port) & 0xfffe)
            pause(10)
        }
    }

    function setUartModes() {
        control.dmesg(`UART set modes`)
        uartMM.ioctl(IO.UART_SET_CONN, devcon)
        const ports: number[] = [];
        for (let port = 0; port < DAL.NUM_INPUTS; ++port) {
            if (devcon.getNumber(NumberFormat.Int8LE, DevConOff.Connection + port) == DAL.CONN_INPUT_UART) {
                ports.push(port);
            }
        }

        while (ports.length) {
            const port = ports.pop();
            const status = waitNonZeroUartStatus(port)
            control.dmesg(`UART set mode ${status} at ${port}`);
        }
    }

    function updateUartMode(port: number, mode: number) {
        control.dmesg(`UART set mode to ${mode} at ${port}`)
        devcon.setNumber(NumberFormat.Int8LE, DevConOff.Connection + port, DAL.CONN_INPUT_UART)
        devcon.setNumber(NumberFormat.Int8LE, DevConOff.Type + port, 33)
        devcon.setNumber(NumberFormat.Int8LE, DevConOff.Mode + port, mode)
    }

    function setUartMode(port: number, mode: number) {
        const UART_PORT_CHANGED = 1
        while (true) {
            if (port < 0) return
            updateUartMode(port, mode);
            uartMM.ioctl(IO.UART_SET_CONN, devcon)
            let status = waitNonZeroUartStatus(port)
            if (status & UART_PORT_CHANGED) {
                control.dmesg(`UART clear changed at ${port}`)
                uartClearChange(port)
            } else {
                control.dmesg(`UART status ${status}`);
                break;
            }
            pause(10)
        }
    }

    function getUartBytes(port: number): Buffer {
        if (port < 0) return output.createBuffer(DAL.MAX_DEVICE_DATALENGTH)
        let index = uartMM.getNumber(NumberFormat.UInt16LE, UartOff.Actual + port * 2)
        return uartMM.slice(
            UartOff.Raw + DAL.MAX_DEVICE_DATALENGTH * 300 * port + DAL.MAX_DEVICE_DATALENGTH * index,
            DAL.MAX_DEVICE_DATALENGTH)
    }

    function getUartNumber(fmt: NumberFormat, off: number, port: number) {
        if (port < 0) return 0
        let index = uartMM.getNumber(NumberFormat.UInt16LE, UartOff.Actual + port * 2)
        return uartMM.getNumber(fmt,
            UartOff.Raw + DAL.MAX_DEVICE_DATALENGTH * 300 * port + DAL.MAX_DEVICE_DATALENGTH * index + off)
    }

    export function setIICMode(port: number, type: number, mode: number) {
        if (port < 0) return;
        devcon.setNumber(NumberFormat.Int8LE, DevConOff.Connection + port, DAL.CONN_NXT_IIC)
        devcon.setNumber(NumberFormat.Int8LE, DevConOff.Type + port, type)
        devcon.setNumber(NumberFormat.Int8LE, DevConOff.Mode + port, mode)
        IICMM.ioctl(IO.IIC_SET_CONN, devcon)
    }

    export function transactionIIC(port: number, deviceAddress: number, writeBuf: number[], readLen: number) {
        if (port < 0) return;
        let iicdata = output.createBuffer(IICDat.Size)
        iicdata.setNumber(NumberFormat.Int8LE, IICDat.Port, port)
        iicdata.setNumber(NumberFormat.Int8LE, IICDat.Repeat, 0)
        iicdata.setNumber(NumberFormat.Int16LE, IICDat.Time, 0)
        iicdata.setNumber(NumberFormat.Int8LE, IICDat.WrLng, writeBuf.length + 1)
        for (let i = 0; i < writeBuf.length; i++)
            iicdata.setNumber(NumberFormat.Int8LE, IICDat.WrData + i + 1, writeBuf[i])
        iicdata.setNumber(NumberFormat.Int8LE, IICDat.WrData, deviceAddress)
        iicdata.setNumber(NumberFormat.Int8LE, IICDat.RdLng, readLen)
        IICMM.ioctl(IO.IIC_SETUP, iicdata)
    }

    export function getIICBytes(port: number, length: number) {
        if (port < 0) return output.createBuffer(length);
        let index = IICMM.getNumber(NumberFormat.UInt16LE, IICOff.Actual + port * 2);
        let buf = IICMM.slice(
            IICOff.Raw + DAL.MAX_DEVICE_DATALENGTH * 300 * port + DAL.MAX_DEVICE_DATALENGTH * index,
            length
        );

        // Reverse
        for (let i = 0; i < length / 2; i++) {
            let c = buf[i]
            buf[i] = buf[length - i - 1]
            buf[length - i - 1] = c
        }
        return buf;
    }

    export function getIICNumber(length: number, format: NumberFormat, off: number, port: number) {
        return getIICBytes(port, length).getNumber(format, off)
    }

    const enum NxtColOff {
        Calibration = 0, // uint32[4][3]
        CalLimits = 48, // uint16[2]
        Crc = 52, // uint16
        ADRaw = 54, // uint16[4]
        SensorRaw = 62, // uint16[4]
        Padding = 70,
        Size = 72
    }
    const enum AnalogOff {
        InPin1 = 0, // int16[4]
        InPin6 = 8, // int16[4]
        OutPin5 = 16, // int16[4]
        BatteryTemp = 24, // int16
        MotorCurrent = 26, // int16
        BatteryCurrent = 28, // int16
        Cell123456 = 30, // int16
        Pin1 = 32, // int16[300][4]
        Pin6 = 2432, // int16[300][4]
        Actual = 4832, // uint16[4]
        LogIn = 4840, // uint16[4]
        LogOut = 4848, // uint16[4]
        NxtCol = 4856, // uint16[36][4] - NxtColor*4
        OutPin5Low = 5144, // int16[4]
        Updated = 5152, // int8[4]
        InDcm = 5156, // int8[4]
        InConn = 5160, // int8[4]
        OutDcm = 5164, // int8[4]
        OutConn = 5168, // int8[4]
        Size = 5172
    }

    const enum DevConOff {
        Connection = 0, // int8[4]
        Type = 4, // int8[4]
        Mode = 8, // int8[4]
        Size = 12
    }

    const enum TypesOff {
        Name = 0, // int8[12]
        Type = 12, // int8
        Connection = 13, // int8
        Mode = 14, // int8
        DataSets = 15, // int8
        Format = 16, // int8
        Figures = 17, // int8
        Decimals = 18, // int8
        Views = 19, // int8
        RawMin = 20, // float32
        RawMax = 24, // float32
        PctMin = 28, // float32
        PctMax = 32, // float32
        SiMin = 36, // float32
        SiMax = 40, // float32
        InvalidTime = 44, // uint16
        IdValue = 46, // uint16
        Pins = 48, // int8
        Symbol = 49, // int8[5]
        Align = 54, // uint16
        Size = 56
    }

    const enum UartOff {
        TypeData = 0, // Types[8][4]
        Repeat = 1792, // uint16[300][4]
        Raw = 4192, // int8[32][300][4]
        Actual = 42592, // uint16[4]
        LogIn = 42600, // uint16[4]
        Status = 42608, // int8[4]
        Output = 42612, // int8[32][4]
        OutputLength = 42740, // int8[4]
        Size = 42744
    }

    const enum UartCtlOff {
        TypeData = 0, // Types
        Port = 56, // int8
        Mode = 57, // int8
        Size = 58
    }

    const enum IICOff {
        TypeData = 0, // Types[8][4]
        Repeat = 1792, // uint16[300][4]
        Raw = 4192, // int8[32][300][4]
        Actual = 42592, // uint16[4]
        LogIn = 42600, // uint16[4]
        Status = 42608, // int8[4]
        Output = 42612, // int8[32][4]
        OutputLength = 42740, // int8[4]
        Size = 42744
    }

    const enum IICCtlOff {
        TypeData = 0, // Types
        Port = 56, // int8
        Mode = 57, // int8
        Size = 58
    }

    const enum IICDat {
        Result = 0,  // result
        Port = 4, // int8
        Repeat = 5, // int8
        Time = 6, // int16
        WrLng = 8, // int8
        WrData = 9, // int8[32]
        RdLng = 41, // int8
        RdData = 42, //int8[32]
        Size = 74,
    }

    const enum IICStr {
        Port = 0, // int8
        Time = 2, // int16
        Type = 4, // int8
        Mode = 5, // int8
        Manufacturer = 6, // int8[9]
        SensorType = 15, // int[9]
        SetupLng = 24, // int8
        SetupString = 28, // ulong
        PollLng = 32, // int8
        PollString = 36, // ulong
        ReadLng = 40, // int8
        Size = 44
    }

    const enum IO {
        UART_SET_CONN = 0xc00c7500,
        UART_READ_MODE_INFO = 0xc03c7501,
        UART_NACK_MODE_INFO = 0xc03c7502,
        UART_CLEAR_CHANGED = 0xc03c7503,
        IIC_SET_CONN = 0xc00c6902,
        IIC_READ_TYPE_INFO = 0xc03c6903,
        IIC_SETUP = 0xc04c6905,
        IIC_SET = 0xc02c6906,
        TST_PIN_ON = 0xc00b7401,
        TST_PIN_OFF = 0xc00b7402,
        TST_PIN_READ = 0xc00b7403,
        TST_PIN_WRITE = 0xc00b7404,
        TST_UART_ON = 0xc0487405,
        TST_UART_OFF = 0xc0487406,
        TST_UART_EN = 0xc0487407,
        TST_UART_DIS = 0xc0487408,
        TST_UART_READ = 0xc0487409,
        TST_UART_WRITE = 0xc048740a,
    }
}

namespace sensors {
    export enum ThresholdState {
        Normal = 1,
        High = 2,
        Low = 3,
    }

    export class ThresholdDetector {
        public id: number;
        private min: number;
        private max: number;
        private lowThreshold: number;
        private highThreshold: number;
        public level: number;
        public state: ThresholdState;

        constructor(id: number, min = 0, max = 100, lowThreshold = 20, highThreshold = 80) {
            this.id = id;
            this.min = min;
            this.max = max;
            this.lowThreshold = lowThreshold;
            this.highThreshold = highThreshold;
            this.level = Math.ceil((max - min) / 2);
            this.state = ThresholdState.Normal;
        }

        public setLevel(level: number) {
            if (this == null) return
            this.level = this.clampValue(level);

            if (this.level >= this.highThreshold) {
                this.setState(ThresholdState.High);
            }
            else if (this.level <= this.lowThreshold) {
                this.setState(ThresholdState.Low);
            }
            else {
                const interval = (this.highThreshold - this.lowThreshold) / 6;
                if ((this.state == ThresholdState.High && this.level < this.highThreshold - interval) ||
                    (this.state == ThresholdState.Low && this.level > this.lowThreshold + interval))
                    this.setState(ThresholdState.Normal);
            }
        }

        public threshold(t: ThresholdState): number {
            switch (t) {
                case ThresholdState.High: return this.highThreshold;
                case ThresholdState.Low: return this.lowThreshold;
                default: return (this.max - this.min) / 2;
            }
        }

        public setLowThreshold(value: number) {
            this.lowThreshold = this.clampValue(value);
            this.highThreshold = Math.max(this.lowThreshold + 1, this.highThreshold);
        }

        public setHighThreshold(value: number) {
            this.highThreshold = this.clampValue(value);
            this.lowThreshold = Math.min(this.highThreshold - 1, this.lowThreshold);
        }

        private clampValue(value: number) {
            if (value < this.min) {
                return this.min;
            }
            else if (value > this.max) {
                return this.max;
            }
            return value;
        }

        private setState(state: ThresholdState) {
            if (this.state == state) return;

            this.state = state;
            switch (state) {
                case ThresholdState.High:
                    control.raiseEvent(this.id, ThresholdState.High);
                    break;
                case ThresholdState.Low:
                    control.raiseEvent(this.id, ThresholdState.Low);
                    break;
            }
        }
    }
}