def pinBlinkInterval(pin, Timeout):
    # initialisation compteur
    startTime = getStartTime()
    
    initPinState = GPIO.digitalRead(pin)
    startCounting=False
    firstPulse = False
    pulse = 0
    ## récupération d'un cycle
    while True :
        # gestion du timeout
        if ( isTimeoutExpired(startTime, Timeout) ):
            return -1
            
        #time.sleep(0.01)
        # lecture de la pin
        if (startCounting == False ):
            if (GPIO.digitalRead(pin) != initPinState):
                startCounting = True
                pulse = getStartTime()
        else:
            if (firstPulse == False):
                if (GPIO.digitalRead(pin) == initPinState):
                    firstPulse = True
            if (firstPulse and GPIO.digitalRead(pin) != initPinState):
                return getStartTime() - pulse

def poll():
	if wiringpi.digitalRead(WIN):
		print 'win'
	elif wiringpi.digitalRead(LOSE):
		print 'lose'
	else:
		print 'playing'

def pulse_in(gpio, state, timeout):
    tn = datetime.datetime.now()
    t0 = datetime.datetime.now()
    micros = 0

    while wp.digitalRead(gpio) != state:
        tn = datetime.datetime.now()
        if tn.second > t0.second:
            micros = 1000000L
        else:
            micros = 0
        micros += tn.microsecond - t0.microsecond
        if micros > timeout:
            return 0

    t1 = datetime.datetime.now()

    while wp.digitalRead(gpio) == state:
        tn = datetime.datetime.now()
        if tn.second > t0.second:
            micros = 1000000L
        else:
            micros = 0
        micros = micros + (tn.microsecond - t0.microsecond)
        if micros > timeout:
            return 0

    if tn.second > t1.second:
        micros = 1000000L
    else:
        micros = 0
    micros = micros + (tn.microsecond - t1.microsecond)

    return micros

	def scanQ(self):
		# steps (1) and (2) before reading GPIOs
		self.__preRead()
		
		# (3) scan rows for pushed key/button
		rowHi=1
		while rowHi==1:
			for i in range(len(self.row)):
				tmpRead=wiringpi.digitalRead(self.row[i])
				if tmpRead==0:
					rowHi=0
					rowVal=i

		# (4) after finding which key/button from the row scans, convert columns to input
		for j in range(len(self.col)):
				wiringpi.pinMode(self.col[j],INPUT)

		# (5) switch the i-th row found from scan to output
		wiringpi.pinMode(self.row[rowVal],OUTPUT)
		wiringpi.digitalWrite(self.row[rowVal],HIGH)

		# (6) scan columns for still-pushed key/button
		colLo=0
		while colLo==0:
				for j in range(len(self.col)):
						tmpRead=wiringpi.digitalRead(self.col[j])
						if tmpRead==1:
							colLo=1
							colVal=j

		# reinitialize used GPIOs
		self.__postRead()

		# (7) return the symbol of pressed key from keyPad mapping
		return self.keyPad[rowVal][colVal]

    def updateValue(self):
	if Globals.globSimulate:
	    val = (self.values[-1][1] if len(self.values) > 0 else 0) + random.randint(-10, 10)
	else:
	    # Send 10us pulse to trigger
	    wiringpi.digitalWrite(self.pinTrigger, 1)
	    time.sleep(0.00001)
	    wiringpi.digitalWrite(self.pinTrigger, 0)
	    start = time.time()
	    stop = 0

	    while wiringpi.digitalRead(self.pinEcho)==0:
	      start = time.time()

	    while wiringpi.digitalRead(self.pinEcho)==1:
	      stop = time.time()

	    # Calculate pulse length
	    elapsed = stop-start

	    # Distance pulse travelled in that time is time
	    # multiplied by the speed of sound (cm/s)
	    distance = elapsed * 34300

	    # That was the distance there and back so halve the value
	    val = distance / 2


	if val < 0:
	    val = 0

	currtime = int(time.time() * 1000) # this is milliseconds so JavaScript doesn't have to do this
	self.values.append([currtime, val])
	self.values = self.values[-MAXVALUES:]
	self.emit("DistanceSensor", self)

def hot_wire(enable):
    if enable:
        logging.info('Heating wire enabled Temp={0:0.1f}* < Temp_min={1:0.1f}'.format(temperature, TEMP_MIN))
	wiringpi.pinMode(PIN_WIRE, ON)
	logging.debug(wiringpi.digitalRead(PIN_WIRE))
    else:
        logging.info('Heating wire disabled Temp={0:0.1f}* > Temp_max={1:0.1f}'.format(temperature, TEMP_MAX))
	wiringpi.pinMode(PIN_WIRE, OFF)
	logging.debug(wiringpi.digitalRead(PIN_WIRE))
    return;

def fan(enable):
    if enable:
        logging.info('fan enabled')
	wiringpi.pinMode(PIN_FAN, ON)
	logging.debug(wiringpi.digitalRead(PIN_FAN))
	time.sleep(240)
	logging.info('fan disabled')
	wiringpi.pinMode(PIN_FAN, OFF)
	logging.debug(wiringpi.digitalRead(PIN_FAN))
    else:
	logging.info('fan disabled')
	wiringpi.pinMode(PIN_FAN, OFF)
	logging.debug(wiringpi.digitalRead(PIN_FAN))
    return;

	def getButtonStatus(self):
		ret = self.BUTTON_NONE
		if self.isRun:
			# excute, if run
			val = wiringpi.digitalRead(self.pinButton)
			ret = self.BUTTON_ON if val == wiringpi.HIGH else self.BUTTON_OFF
		return ret		

    def read_switch(self, switch):
        if not WIRING_PI:
            return False

        pin = self.switch_pin[switch]

        return wiringpi.digitalRead(pin) > 0

def read_adc(adcnum, sCon):

    if ((adcnum > 7) or (adcnum < 0)):
        return -1
    wiringpi.digitalWrite(sCon.cspin, 1)
    wiringpi.digitalWrite(sCon.clkpin, 0)  # start clock low
    wiringpi.digitalWrite(sCon.cspin, 0)     # bring CS low

    commandout = adcnum
    commandout |= 0x18  # start bit + single-ended bit
    commandout <<= 3    # we only need to send 5 bits here
    for i in range(5):
        if (commandout & 0x80):
            wiringpi.digitalWrite(sCon.mosipin, 1)
        else:
            wiringpi.digitalWrite(sCon.mosipin, 0)
        commandout <<= 1
        wiringpi.digitalWrite(sCon.clkpin, 1)
        wiringpi.digitalWrite(sCon.clkpin, 0)

    adcout = 0
    # read in one empty bit, one null bit and 10 ADC bits
    for i in range(12):
        wiringpi.digitalWrite(sCon.clkpin, 1)
        wiringpi.digitalWrite(sCon.clkpin, 0)
        adcout <<= 1
        if (wiringpi.digitalRead(sCon.misopin)):
            adcout |= 0x1
    wiringpi.digitalWrite(sCon.cspin, 1)

    adcout >>= 1       # first bit is 'null' so drop it
    return adcout

def WaitForCTS():
    # continually monitor the selected GPIO pin and wait for the line to go low
    # print ("Waiting for CTS")     # Added for debug purposes
    while wiringpi2.digitalRead(GPIO_PIN):
        # do nothing
        time.sleep(0.001)
    return

    def run(self):
        motionFirstDetectedTime = None
        SLEEP_TIME = 0.5

        # Set up the GPIO input for motion detection
        PIR_PIN = 18
        wiringpi.wiringPiSetupSys()
        wiringpi.pinMode(PIR_PIN, wiringpi.INPUT)

        # Loop through and detect motion
        while True:
            if wiringpi.digitalRead(PIR_PIN):
                if motionFirstDetectedTime is None:
                    motionFirstDetectedTime = datetime.now()
                    print('Motion detected at: ' + str(motionFirstDetectedTime))

            # Do we need to send out a notification?
            now = datetime.now()
            if (motionFirstDetectedTime is not None) and (now - motionFirstDetectedTime) > timedelta (minutes = 1):
                print('Sending out notification now!')
                motiondate = datetime.strftime(motionFirstDetectedTime, '%Y-%m-%d %H:%M:%S')
                msg = self.message + ': ' + motiondate 
                self._send_email(msg)

                # reset state
                motionFirstDetectedTime = None

            time.sleep(SLEEP_TIME)

def garage_state():
    doorState = wiringpi.digitalRead(25)
    if doorState == 1: 
		return "open"
    elif doorState == 0:
		return "closed"
    else:
		return "error"

 def run(self):
     while not self.quit:
         time.sleep(1)
         print('!')
         if self.alarm_mode:
             movement = wp.digitalRead(0) != 0
             if movement:
                 self.turn_all_on_off(True, notify=True)

  def __init__(self, pinNumber):
    threading.Thread.__init__(self)

    self.daemon = True
    self.pinNumber = pinNumber

    WiringPiSingleton().setup()

    self.__initialState = wiringpi.digitalRead(self.pinNumber)
    self.__previousState = self.__initialState

    def is_enabled(self, button):
        if not WIRING_PI:
            return False

        pin = self.button_pin[button]

        wiringpi.pinMode(pin, 1)
        state = wiringpi.digitalRead(pin)

        return state == 1

  def run(self):
    self.__running = True

    while self.__running:
      state = wiringpi.digitalRead(self.pinNumber)
      if state != self.__previousState:
        self.onStateChange(state)

      self.__previousState = state
      time.sleep(self.__RESOLUTION / 1000.0)

def main():

	receiver = 27; sender = 1; state = 1; i = 0
	global last_high, ones, zeros, bits_to_output, code

	while True:
		wiringpi.delayMicroseconds(25)

		if wiringpi.digitalRead(receiver) == False:

			if (bits_to_output > 0):
				sys.stdout.write("0")
			zeros += 1
			
			if state < 80:
				state += 1
		else:
			if state >= 2 and bits_to_output > 0:
				bits_to_output -= 1
				#sys.stdout.write("\n")
				#sys.stdout.write(str(format(ones / (ones + zeros), '.2f')) + " ")
				#sys.stdout.write(str( (ones + zeros)) + " ")
				
				if ones / (ones + zeros) < 0.5:
					#sys.stdout.write("0")
					code += "0"
				else:
					#sys.stdout.write("1")
					code += "1"

				if bits_to_output == 0:
					sys.stdout.write("   " + code)
					sys.stdout.write("   " + compress_string(code))
				
				#sys.stdout.write(" --\n")
				ones = 0
				zeros = 0

			if state == 80:
				calc_time()
			
			if (bits_to_output > 0):
				sys.stdout.write("1")
			ones += 1
			

			if state >= 2:
				last_high = wiringpi.micros()

			state = 0

		i += 1
		if i == 40:
			sys.stdout.flush()
			i = 0

def pinIs(pin, statusNotWanted, nbSec):
    # initialisation compteur
    i = 0
    while True :
        time.sleep(0.1)
        # lecture de la pin
        if (GPIO.digitalRead(pin) == statusNotWanted):
            return False
        i = i+1
        if (i > nbSec*10):
            return True 

 def checkPedal(self, dt):
   try:
     # Only trigger a capture when the circuit goes from open to closed
     nextPedal = wiringpi.digitalRead(21)
     #print('checkPedal', nextPedal)
     if self.lastPedal == 1 and nextPedal == 0 and 'beginCapture' in dir(self.manager.current_screen):
       self.manager.current_screen.beginCapture()
     self.lastPedal = nextPedal
   except Exception as e:
     handleCrash(e)
   return True