def init(self, pins):
   wiringpi2.wiringPiSetup()
   self._pins = set(pins)
   Log('Setting pins %s to output mode...' % list(self._pins))
   for i in self._pins:
     wiringpi2.pinMode(i, PINMODE_OUTPUT)
   Log("Done.")

def set_pin_as_input(pin):
    """Set the specified pin as an input.

    :param pin: index of pin in cm.hardware.gpio_pins
    :type pin: int
    """
    wiringpi.pinMode(cm.hardware.gpio_pins[pin], _GPIOASINPUT)

	def __init__(self, GPIO, name, hasNeutral):
		self.pin = GPIO
		self.name = name
		self.hasNeutral = hasNeutral

		self.isMidPulse = False
		self.pulseStart = 0
		self.pulseEnd = 0
		self.pulses = []

		self.minPulseLen = 1200
		self.maxDeltaLen = 600
		self.neutralDeltaLen = 1500

		self.lastOutput = 0.0

		self.isPrintData = True
		self.preprocessData = True

		try:
			with open('radio.cfg') as file:
				for line in file:
					if line.startswith(self.name):
						data = line.split(',')
						self.minPulseLen = int(data[2])
						self.maxDeltaLen = int(data[1]) - self.minPulseLen
						if self.hasNeutral:
							self.neutralDeltaLen = int(data[3]) - self.minPulseLen
			
		except (OSError, IOError):
			procComms.PrintLog('Config file not found. Use radioConfig.py!')

		wiringpi.pinMode(self.pin, 0)

def set_pin(pin, state):
    global state_updated
    s = None
    try:
        s = pin_state[pin]
    except KeyError:
        logger.debug("pin {0} had no state.  Initializing?".format(pin))

    if wiringpi.getAlt(pin) != PIN_MODE_ACTIVE:
        logger.warn(
            'Attempting to set output value on NON-ACTIVE pin {0} (mode: {1}).  Forcing to OUTPUT and setting...'.format(
                pin,
                PIN_MODES.get(wiringpi.getAlt(pin))))
        wiringpi.pinMode(pin, PIN_MODE_ACTIVE)

    pin_state[pin] = state
    if s == state:
        state_updated = False
    else:
        state_updated = True

    name = pin_names.get(pin)
    if name is not None:
        n = name
    else:
        n = "Pin_{0}".format(pin)
    logger.info("{0} -> {1}".format(n, state_names[pin_state.get(pin)]))

def init_control_plane():
    logger.info("Initializing control plane")
    chip1_i2c_addr = 0x20  # Controlled by A0, A1, A2 pins GND or +5V
#    chip2_i2c_addr = 0x22  # Controlled by A0, A1, A2 pins GND or +5V
#    chip3_i2c_addr = 0x23  # Controlled by A0, A1, A2 pins GND or +5V
#    chip4_i2c_addr = 0x24  # Controlled by A0, A1, A2 pins GND or +5V

    wiringpi.wiringPiSetup()  # initialise wiringpi

    wiringpi.mcp23017Setup(pin_base, chip1_i2c_addr)  # pins 65-80
#    wiringpi.mcp23017Setup(pin_base + 16, chip2_i2c_addr)  # pins 81-96
#    wiringpi.mcp23017Setup(pin_base + 32, chip3_i2c_addr)  # pins 97-112
#    wiringpi.mcp23017Setup(pin_base + 48, chip4_i2c_addr)  # pins 113-128

    for pin in range(pin_base, pin_max):
        set_pin(pin, OFF)
        wiringpi.pinMode(pin, PIN_MODE_ACTIVE)  # set to output mode

    sleep(1)

    for pin in range(pin_base, pin_max):
        mode = wiringpi.getAlt(pin)
        if mode != PIN_MODE_ACTIVE:
            logger.error("Initialized pin {0} to mode {1} but found it in mode {2}".format(pin, PIN_MODE_ACTIVE, mode))

    # and then apply our CHANGES
    apply_model(False)
    logger.info("Control plane initialized successfully")

def readData(pin):
    hum = 0
    temp = 0
    crc = 0
    GPIO.pinMode(pin, 1)
    GPIO.digitalWrite(pin, 1)
    GPIO.digitalWrite(pin, 0)
    GPIO.delay(20)
    GPIO.digitalWrite(pin, 1)
    GPIO.pinMode(pin, 0)
    GPIO.delayMicroseconds(40)
    if GPIO.digitalRead(pin) == 0:
        untilHigh(pin)
        for i in range(16):
            hum <<= 1
            untilLow(pin)
            untilHigh(pin)
            GPIO.delayMicroseconds(28)
            hum += GPIO.digitalRead(pin)
        for i in range(16):
            temp <<= 1
            untilLow(pin)
            untilHigh(pin)
            GPIO.delayMicroseconds(28)
            temp += GPIO.digitalRead(pin)
        for i in range(8):
            crc <<= 1
            untilLow(pin)
            untilHigh(pin)
            GPIO.delayMicroseconds(28)
            crc += GPIO.digitalRead(pin)
        return [True, hum, temp, crc]
    else:
        return [False, hum, temp, crc]

    def get(self):
        response = {}

        # Make sure sensor pin is set to input mode
        try:
            wpi.pinMode(config['SENSOR_PIN_NUM'],0)
        except:
            response['status'] = "error"
            response['errorCode'] = "GPIO pin input mode error."
            response['message'] = "Cannot {} garage door.".format(config['MODE'])
            resp = jsonify(response)
            resp.status_code = 500
            return resp

        try:
            if wpi.digitalRead(config['SENSOR_PIN_NUM']):
                response['doorStatus'] = 'open'
            else:
                response['doorStatus'] = 'closed'
        except:
            response['status'] = "error"
            response['errorCode'] = "GPIO pin read error."
            response['message'] = "Cannot determine garage door status."
            resp = jsonify(response)
            resp.status_code = 500
            return resp


        response['status'] = "success"
        response['errorCode'] = None
        response['message'] = "Garage door is {}.".format(response['doorStatus'])
        resp = jsonify(response)
        resp.status_code = 200
        return resp

 def switch(self, v):
     if self.reading() != v:
         self.logger.debug('relay: switch: pin:%s %s' % (self.pin, str(v)))
         wiringpi.pinMode(self.pin, v)
         wiringpi.digitalWrite(self.pin, v)
     else:
         self.logger.debug('relay: switch: pin %s ignore already %s' % (self.pin, str(v)))

 def __init__(self, cursor):
     threading.Thread.__init__(self)
     wiringpi.wiringPiSetupGpio()
     wiringpi.pinMode(17, 0)
     self.cursor = cursor
     self.start()
     self.shot = False

def setup_servo():
    wiringpi.wiringPiSetupGpio()
    wiringpi.pinMode(18,2)      # hardware pwm only works on GPIO port 18  
    wiringpi.pwmSetMode(0)
    wiringpi.pwmSetClock(375)
    wiringpi.pwmSetRange(1024)
    wiringpi.pwmWrite(18,0)

 def __init__(self):
     """ Set up hardware """
     super().__init__()
     wiringpi.wiringPiSetup()
     # Set up each pin for digital output
     for i in self.lightPinMap:
         wiringpi.pinMode(i, 1)

def fancontrol(input):
    import wiringpi2 as wiringpi
    OUTPUT = 1
    INPUT = 0
    wiringpi.wiringPiSetup()
    wiringpi.pinMode(8,OUTPUT)
    wiringpi.digitalWrite(8,input)

	def initialize_hardware(self):
		wiringpi.wiringPiSetup()
		wiringpi.pinMode(GPIOPin.PIN_STATUS_LED.value, PinMode.OUTPUT.value)
		wiringpi.pinMode(GPIOPin.PIN_SOUND.value, PinMode.OUTPUT.value)
		wiringpi.pinMode(GPIOPin.PIN_RGB_RED.value, PinMode.OUTPUT.value)
		wiringpi.pinMode(GPIOPin.PIN_RGB_GREEN.value, PinMode.OUTPUT.value)
		wiringpi.pinMode(GPIOPin.PIN_RGB_BLUE.value, PinMode.OUTPUT.value)

def Init():
	wiringpi2.pinMode(data_pin, 0)
	wiringpi2.pinMode(clock_pin, 0)
	wiringpi2.wiringPiSetup()
	
	SendData(cmdlist["led_cmd"])
	wiringpi2.delay(50)

  def set(self,newState):
    
    newState = int(newState)

    # FIXME need to catch error
    print "Switching relay " + `self.relayA` + " to " + `newState`

    wiringpi.pinMode(self.relayA,self.OUTPUT_MODE)
    
    initialState = wiringpi.digitalRead(self.relayA)
    wiringpi.digitalWrite(self.relayA, newState)
    currentState = wiringpi.digitalRead(self.relayA)
    
    result = None
    if(initialState == currentState):
    	result = "Target state was already set. No action taken"
    else:
    	result = "Switched"
    
    errors = None
    
    return {
        "controller": self.name,
        "timestamp": datetime.datetime.now().isoformat(' '),
        "result": result,
        "errors": errors,
    }

 def init(self, PWMmode):
     self.PWMmode = PWMmode
     wiringpi2.wiringPiSetup()
     if self.PWMmode == True:
       wiringpi2.pinMode(1, 2)
     else:
       wiringpi2.pinMode(1,1)

    def __init__(self, therm_pin, sensor_pin, target_temp=55):
        self.target_temp = target_temp
        self.THERM = therm_pin
        self.sensor = Sensor(sensor_pin)
        self.running = True
        self.heat_on = False
        self.current_temp = None
        self.OUT = 1
        self.IN = 0
        self.PWM = 0
        self.bounds = [55, 66, 80]
        self.learner = learner.Events(self, 'therm', 55, 5, 5 * 60)
        self.set_lock = RLock()

        wiringpi.wiringPiSetupSys()
        setupInCmd1 = 'echo "{}" > /sys/class/gpio/export'.format(sensor_pin)
        setupOutCmd1 = 'echo "{}" > /sys/class/gpio/export'.format(self.THERM)
        setupInCmd2 = 'echo "in" > /sys/class/gpio/gpio{}/direction'.format(sensor_pin)
        setupOutCmd2 = 'echo "out" > /sys/class/gpio/gpio{}/direction'.format(self.THERM)
        Popen( setupInCmd1, shell=True)
        Popen( setupInCmd2, shell=True)
        Popen(setupOutCmd1, shell=True)
        Popen(setupOutCmd2, shell=True)
        wiringpi.pinMode(self.THERM, self.OUT)
        wiringpi.pinMode(sensor_pin, self.IN)

        wiringpi.digitalWrite(self.THERM, 0)

        # give some time to read an initial temperature
        self.timer = Timer(15, self.tick)
        self.timer.start()
        self.temp_log_timer = Timer(5 * 60, self.logTemp)
        self.temp_log_timer.start()
        self.temp_logger = jsonlog.jsonLog('data/real-therm-data')

def test():
    pin = 0
    gpio.wiringPiSetup()  #初始化
    gpio.wiringPiSetupSys()  #初始化
    gpio.pinMode(pin, GPIO.OUTPUT) # 把pin25设置为输出模式
    gpio.digitalWrite(pin, GPIO.HIGH) #pin25输出为高电平
    print(gpio.digitalRead(pin)) #打印pin25的状态

def init():
  lcd.init()
  lcd.cls()
  lcd.backlight(ON)

  wiringpi.pinMode(BUTTON_OK,INPUT)
  wiringpi.pinMode(BUTTON_FKEY,INPUT)

def init_pump_control():
    #os.system("gpio mode 7 out")
    wpi.wiringPiSetup()
    wpi.pinMode(_PIN, _OUTPUT)
    rospy.set_param("pump_state", False)
    rospy.init_node("pump_control")
    s = rospy.Service("pump_control", PumpControl, pump_control_callback)
    rospy.spin()