constructor(config: number | string | IPWMConfig) {
    let pin: number | string;
    let frequency = DEFAULT_FREQUENCY;
    let range = DEFAULT_RANGE;
    if (typeof config === 'number' || typeof config === 'string') {
      pin = config;
    } else if (typeof config === 'object') {
      if (typeof config.pin === 'number' || typeof config.pin === 'string') {
        pin = config.pin;
      } else {
        throw new Error(`Invalid pin "${config.pin}". Pin must a number or string`);
      }
      if (typeof config.frequency === 'number') {
        frequency = config.frequency;
      }
      if (typeof config.range === 'number') {
        range = config.range;
      }
    } else {
      throw new Error('Invalid config, must be a number, string, or object');
    }
    super(pin);

    const gpioPin = getGpioNumber(pin);
    if (gpioPin === null) {
      throw new Error(`Internal error: ${pin} was parsed as a valid pin, but couldn't be resolved to a GPIO pin`);
    }

    this._frequency = frequency;
    this._range = range;
    this._dutyCycle = 0;
    this._pwm = new Gpio(gpioPin, { mode: Gpio.OUTPUT });
    this._pwm.pwmFrequency(frequency);
    this._pwm.pwmRange(range);
  }

 constructor(config: number | string | IConfig) {
   const parsedConfig = parseConfig(config);
   super(parsedConfig.pin);
   this.pullResistor = parsedConfig.pullResistor;
   this._input = new Gpio(getPin(parsedConfig.pin, this.pins[0]), {
     mode: Gpio.INPUT,
     pullUpDown: parsedConfig.pullResistor
   });
   this._input.enableInterrupt(Gpio.EITHER_EDGE);
   this._input.on('interrupt', (level: number) => setTimeout(() => {
     this._currentValue = level;
     this.emit('change', this.value);
   }));
   this._currentValue = this._input.digitalRead();
 }

 public read(): number {
   if (!this.alive) {
     throw new Error('Attempted to read from a destroyed peripheral');
   }
   this._currentValue = this._input.digitalRead();
   return this.value;
 }

 public write(dutyCycle: number) {
   if (!this.alive) {
     throw new Error('Attempted to write to a destroyed peripheral');
   }
   if (typeof dutyCycle !== 'number' || dutyCycle < 0 || dutyCycle > 1) {
     throw new Error(`Invalid PWM duty cycle "${dutyCycle}"`);
   }
   this._dutyCycle = dutyCycle;
   this._pwm.pwmWrite(Math.round(this._dutyCycle * this._range));
 }

 public write(value: number): void {
   if (!this.alive) {
     throw new Error('Attempted to write to a destroyed peripheral');
   }
   if ([LOW, HIGH].indexOf(value) === -1) {
     throw new Error('Invalid write value ' + value);
   }
   this._currentValue = value;
   this._output.digitalWrite(this.value);
   this.emit('change', this.value);
 }

 public write(dutyCycle: number) {
   if (!this.alive) {
     throw new Error('Attempted to write to a destroyed peripheral');
   }
   if (typeof dutyCycle !== 'number' || dutyCycle < 0 || dutyCycle > 1) {
     throw new Error(`Invalid PWM duty cycle ${dutyCycle}`);
   }
   this._dutyCycleValue = dutyCycle;
   this._pwm.hardwarePwmWrite(this._frequencyValue, Math.round(this._dutyCycleValue * MAX_DUTY_CYCLE));
   this.emit('change', this._dutyCycleValue);
 }

 public destroy() {
   this._input.disableInterrupt();
   super.destroy();
 }