def measure():

	wiringpi2.digitalWrite(TRIG, 1)
	time.sleep(0.00001)
	wiringpi2.digitalWrite(TRIG, 0)

	pulse_start = time.time()
	while wiringpi2.digitalRead(ECHO)==0:
		pulse_start = time.time()
	
	# Once a signal is received, the value changes from low (0) to high (1),
	# and the signal will remain high for the duration of the echo pulse.
	# We therefore also need the last high timestamp for ECHO (pulse_end).

	pulse_end = time.time()      
	while wiringpi2.digitalRead(ECHO) == 1:
		pulse_end = time.time()      
	
	# We can now calculate the difference between the two recorded 
	# timestamps, and hence the duration of pulse (pulse_duration).

	pulse_duration = pulse_end - pulse_start
	
	distance = pulse_duration * 17150

	return distance

def AllOff():
    # this sets all address decoder address input pins (A0 - A2) to low
    # this does not, however, cause all address decorder output pins
    # to go low.  To set all output pins (Y0 - Y7) to low,
    # you need to set E1-E2-E3 is a state OTHER than Low-Low-High
    for p in pins:
        wiringpi.digitalWrite(p, LOW)

 def foo_callback(self, path, args):
     wiringpi2.digitalWrite(args[0],1)
     #sleep(0.03)
     scaled = args[1] / 127.0
     wiringpi2.delay(int(scaled*15 + 4)) # five is min, max is uhhh 20 ish?
     wiringpi2.digitalWrite(args[0],0)
     print("received message '%s' with arguments: %d, %d" % (path, args[0], args[1]))

    def set_status(self, new_status):
        """
        Set the state of the door to open or closed, if its not already in that state.

        Args:
            new_status: 0 for closed, 1 for open.

        Raises:
            IOError: File access issues
        """

        if new_status == self.status:
            logging.debug("status is the same, skipping set_status to %u", new_status)
            return

        if new_status == 1:  # open
            logging.info("door opening")
        else:
            logging.info("door closing")

        self.init_output()

        # low turns the motor on
        wiringpi.digitalWrite(self.write_bcm_pin, 0)

        # this is simply to wait for the motor to finish running
        # we can't tell if its really finished so this sleep is just a guess
        # TODO while loop until read_bcm_pin is ready?
        sleep(10)

        # high turns the motor back off so that it can run again later
        wiringpi.digitalWrite(self.write_bcm_pin, 1)
        self.status = int(new_status)

def startWatering(duration):
    delta = datetime.datetime.now() + timedelta(seconds=duration)
    logging.debug("Start Watering")
    logging.debug("Start Stop Watering at: " + delta.ctime())
    wiringpi.digitalWrite(waterpin, 1)  # Write 1 ( HIGH ) to pin 6
    # set timer to stop watering
    scheduler.add_job(stopWatering, trigger="date", run_date=delta)

 def deactivate(self, pin):
     """ De-activate a pin """
     if settings.count_from_right:
         pin = pin
     else:
         pin = 7 - pin
     wp.digitalWrite(pin, 0)

 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 fancontrol(input):
    import wiringpi2 as wiringpi
    OUTPUT = 1
    INPUT = 0
    wiringpi.wiringPiSetup()
    wiringpi.pinMode(8,OUTPUT)
    wiringpi.digitalWrite(8,input)

  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 set_numbers(num_str):
  wiringpi.digitalWrite(7, 0)
  for x in range(71, -1, -1):
    wiringpi.digitalWrite(13, 0)
    wiringpi.digitalWrite(11, int(num_str[x]))
    wiringpi.digitalWrite(13, 1)
  wiringpi.digitalWrite(7, 1)

    def __init__(self):
        wp.wiringPiSetup()

        #left 23017, for audio
        wp.mcp23017Setup( PB1,0x20)
        for pin in OUTPUT_PINS_1:
            wp.pinMode(pin,OUTPUT)
        for pin in INPUT_PINS_1:
            wp.pinMode(pin, INPUT)

        #right 23017 for 230v switching
        wp.mcp23017Setup( PB2,0x21)
        for pin in OUTPUT_PINS_2:
            wp.pinMode(pin,OUTPUT)
        for pin in INPUT_PINS_2:
            wp.pullUpDnControl(pin,PUD_UP)
            wp.pinMode(pin, INPUT)


        #display
        wp.digitalWrite(70,0)  # write mode
        self.display1 = wp.lcdInit(2,16,8, 71,69,72,73,74,75,76,77,78,79) #connected to first expander
        wp.lcdClear(self.display1)


        #pwm driver
        self.pwm = PWM()
        self.pwm.setPWMFreq(200)

def all_off():
    for pin in pins_pol:
        w.digitalWrite(pin, 0)

    for pin in pins_pwm:
        w.softPwmWrite(pin,0)
    mag_value=[0,0,0,0]

def display_char(char, font=FONT):
    try:
        wiringpi.digitalWrite(DC, ON)
        spi.writebytes(font[char]+[0])

    except KeyError:
        pass # Ignore undefined characters.

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__(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 _flash_led(self,nflash=1,delay=0.1):
     #nflash is the number of blink the led will make
     for n in range(nflash):
         gpio.digitalWrite(self.led,True)
         rospy.sleep(delay)
         gpio.digitalWrite(self.led,False)
         rospy.sleep(delay)

def initPorts():
	#
	# define constants
	#
	INPUT = 0
	OUTPUT = 1
	PUD_UP = 2
	#
	# use Broadcom GPIO pin scheme
	#
	gpio.wiringPiSetupGpio()
	
	# comparator output is PGOOD  - needs pull-up
	#
	gpio.pinMode(PGOOD,INPUT)
	gpio.pullUpDnControl(PGOOD,PUD_UP)
	#
	#
	gpio.pinMode(CSb,OUTPUT)
	gpio.pinMode(UDb,OUTPUT)
	#
	# cs* -> 1 to deselect; USb is don't care
	#
	gpio.digitalWrite(CSb,1)
	return

	def _write(self, status):
		if status:
			wiringpi2.digitalWrite(self.pin, 1)
			time.sleep(self.DELAY_LED)
		else: 
			wiringpi2.digitalWrite(self.pin, 0)
			time.sleep(self.DELAY_LED)

    def setFanSpeed(self):
        START = 650      #  this value is minimal pwm value that can start the fan, depends on the fan and transistors used
        LO_TEMP = 45.0   #  minimal temperature that turns on the fan 
        HI_TEMP = 55.0   #  when core temperature is higher than this the fan operates at full speed
        tempDiff = HI_TEMP - LO_TEMP
        
        temp = self.readtemp()

        if self.PWMmode:                                
          if temp < LO_TEMP:
              pwm = 0
          elif temp > HI_TEMP:
              pwm = 1023
          else:        
              pwm = (1023-START)/tempDiff * temp - ((1023-START)/tempDiff)*LO_TEMP + START
              pwm = int(pwm)
          wiringpi2.pwmWrite(1, pwm)
          return pwm
        
        elif not self.PWMmode:
          if self.fanRunning:
            if temp <= LO_TEMP:
              wiringpi2.digitalWrite(1, 0)
              self.fanRunning = False
              return(0)
            else: return(1023)
          elif not self.fanRunning:
            if temp > HI_TEMP:
              wiringpi2.digitalWrite(1, 1)
              self.fanRunning = True
              return(1023)
            else: return(0)

def beeper(beeps):
	"Beep all of the requested beeps in the beeps list"
	for i in beeps:
		wiringpi2.digitalWrite(1,1)	# beep on
		time.sleep(i)								# length of beep from beeps list
		wiringpi2.digitalWrite(1,0)	# beep off
		time.sleep(0.025)						# interval between beeps