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 main():
    global lcd
    global inactivity_timer
    global motion_sensor
    global distance_sensor
    global lcd
    global buzzer
    global led
    global last_pullup_time
    global pullup_count_alltime
    global pullups_to_go
    global storage

    wiringpi.wiringPiSetupGpio()

    init_storage()

    inactivity_timer = InactivityTimer(wakeup, shutdown, config.SHUTDOWN_DELAY)
    motion_sensor = MotionSensor(wiringpi, config.MOTION, inactivity_timer.trigger)
    distance_sensor = DistanceSensor(wiringpi, config.SONIC_ECHO, config.SONIC_TRIG)
    lcd = Display(config.LCD_RS, config.LCD_E, config.LCD_D4, config.LCD_D5, config.LCD_D6, config.LCD_D7, config.LCD_K)
    buzzer = Buzzer(wiringpi, config.BUZZER)
    led = Led(wiringpi, config.LED_PIN)

    distance_resetted = True

    shutdown()

    while True:
        if inactivity_timer.is_active():
            distance = distance_sensor.measure()

            distance_str = "{:13.2f}".format(distance)

            if config.DEBUG:
                print(distance_str + " cm")
                # if wiringpi.millis() % 5 == 0:
                #     lcd.message(0, 0, distance_str + " cm")

            # only count a pullup if:
            # - distance is smaller than 5cm
            # - distance was resetted (athlete moved more than 20 cm away from sensor)
            # - last pullup was done more than 1 second ago
            if 0 < distance < config.COUNT_DISTANCE and distance_resetted and wiringpi.millis() > (last_pullup_time + config.RESET_TIME):
                buzzer.beep(5000)
                distance_resetted = False
                cnt = count_pullup()
                lcd.clear()
                lcd.message(0, 0, "Pullups: " + str(cnt).rjust(5))
                lcd.message(0, 1, "2do2day: " + str(pullups_to_go).rjust(5))
            elif distance > config.RESET_DISTANCE:
                distance_resetted = True

        delay_milli(100)

        inactivity_timer.loop()
        motion_sensor.sense()

        if config.DEBUG and inactivity_timer.is_active() == 1:
            print("shutting down in " + inactivity_timer.get_seconds_till_shutdown() + " seconds")

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 setup():
        wiringpi.wiringPiSetupGpio()
        wiringpi.pinMode(25,1)        #red light
        wiringpi.digitalWrite(25,0)   #red is off
        wiringpi.pinMode(24,1)        #green light
        wiringpi.digitalWrite(24,0)   #green is off
      
        flash(2)

 def initQTI(self,wiring=True):
     #pin = pinNum
     if wiring == True:
         wp.wiringPiSetup()
         wp.wiringPiSetupGpio()
         wp.wiringPiSetupPhys()
     else:
         GPIO.setmode(GPIO.BOARD)

    def __init__(self):
        led.wiringPiSetupGpio()
        led.pinMode(18, 2)      # sets GPIO 24 to output

        #self.pwmLed=pwmLed
        
        #self.ledPin=18
        self.pwmThread=threading.Thread(target=self.fade)

def Main():
	print 'AR600 signal configuration tool.\nPlease follow instructions on screen.'
	print 'To cancel, kill this process via Ctrl+Z. Lazy I know :D'

	wiringpi.wiringPiSetupGpio()

	signals = [PWMSignal(5, 'Thro', True, 'right stick, horizontal', 'left', 'right'), 
		PWMSignal(6, 'Aile', False, 'left stick, vertical', 'up', 'down'), 
		PWMSignal(19, 'Elev', True, 'right stick, vertical', 'up', 'down'), 
		PWMSignal(26, 'Rudo', True, 'left stick, horizontal', 'left,', 'right'),
		PWMSignal(21, 'Gear', False, 'trainer binary switch', '0 (away from you)', '1 (towards you)'), 
		PWMSignal(20, 'Aux1', False, 'left trigger switch', 'towards you', 'default position (away from you)')]

	for signal in signals:

		print '-> Now configuring ' + signal.name

		print 'Please move ' + signal.descr + ', maximally ' + signal.descrMax + \
			', hold for 2 seconds and hit Ctrl+C.'
		try:
			while True:
				signal.Update()
		except KeyboardInterrupt:
			signal.SetMax()
		print 'Set: ' + str(signal.maxVal)

		print 'Please move ' + signal.descr + ', maximally ' + signal.descrMin + \
			', hold for 2 seconds and hit Ctrl+C.'
		try:
			while True:
				signal.Update()
		except KeyboardInterrupt:
			signal.SetMin()
		print 'Set: ' + str(signal.minVal)


		if not signal.input.hasNeutral:
			continue

		print 'Please move ' + signal.descr + ', to neutral position, hold for 2 seconds and hit Ctrl+C.'
		try:
			while True:
				signal.Update()
		except KeyboardInterrupt:
			signal.SetNeu()
		print 'Set: ' + str(signal.neuVal)




	f = open("radio.cfg", "w")
	for signal in signals:
		tuple = (signal.name, str(signal.maxVal), str(signal.minVal), str(signal.neuVal))
		f.write(",".join(tuple))
		f.write("\n")
	f.close()
	
	print 'Configuration data saved to radio.cfg'

def Init():
	global on, timeOfLastChange
	wiringpi.wiringPiSetupGpio()
	wiringpi.pinMode(27, 1)
	wiringpi.pullUpDnControl(27, 1)
	wiringpi.digitalWrite(27, 1) # switch on LEDs
	on = True
	timeOfLastChange = time.time()
	procComms.PrintLog('Switched on LEDs.')

    def __init__(self):
        wiringpi2.wiringPiSetupGpio()

        self.SPEAKER = 18
        self.MODE_PWM = 2

        wiringpi2.pinMode(self.SPEAKER, self.MODE_PWM)
        wiringpi2.pwmSetMode(wiringpi2.GPIO.PWM_MODE_MS)

        wiringpi2.pwmWrite(self.SPEAKER, 0)

 def __init__(self, base0 = 27, base90 = 73):
     wiringpi.wiringPiSetupGpio()
     wiringpi.pinMode(18,2)
     wiringpi.pwmSetMode(0)
     wiringpi.pwmSetClock(400)
     wiringpi.pwmSetRange(1024)
     wiringpi.pwmWrite(18, 0)
     self.base0 = base0
     self.base90 = base90
     self.setAngle(90)

 def __init__(self, forward, backward):
     self.forward = forward
     self.backward = backward
     self.status = 0
     
     wiringpi2.wiringPiSetupGpio()
     wiringpi2.pinMode(forward, 1) # sets GPIO forward to output  
     wiringpi2.pinMode(backward, 1) 
     wiringpi2.softPwmCreate(forward, 0, 100)
     wiringpi2.softPwmCreate(backward, 0, 100)

	def __init__(self,in1,in2,in3):
		self.in1 = in1
		self.in2 = in2
		self.in3 = in3
		GPIO.setmode(GPIO.BCM)
		GPIO.setup(self.in1,GPIO.OUT)
		GPIO.setup(self.in2,GPIO.OUT)
                wiringpi.wiringPiSetupGpio()
                wiringpi.pinMode(self.in3, wiringpi.GPIO.PWM_OUTPUT)
                wiringpi.pwmSetMode(wiringpi.GPIO.PWM_MODE_MS)
                wiringpi.pwmSetClock(375)
                wiringpi.pwmWrite(self.in3,0)

	def __init__(self, name, pinToWatch, triggerOnHigh = True, debounceTimeInSeconds = 0):
		self._watchPin = pinToWatch
		self._dataLock = Lock()
		self._name = name
		self._triggerOnHigh = triggerOnHigh
		self._debounceTimedelta = timedelta(seconds=debounceTimeInSeconds)

		wiringpi.wiringPiSetupGpio()
		wiringpi.piHiPri(99)
		wiringpi.wiringPiISR(self._watchPin, wiringpi.GPIO.INT_EDGE_BOTH, DoorbellSensor.gpioCallback, self)

		if bool(wiringpi.digitalRead(self._watchPin)) == self._triggerOnHigh:
			self._timeLastTriggered = datetime.today()

    def __init__(self):
        self.thrd_sleep_duration = 0.2  # sec
        self.light_pin = 18
        self.started = False
        self.exit_flag = threading.Event()
        self.brightness = 0.0  # 0.0 to 1.0
        self.ctrl_events = []

        if not TEST_MODE:
            IO.wiringPiSetupGpio()
            IO.pinMode(self.light_pin, IO.GPIO.PWM_OUTPUT)
            IO.pwmSetClock(1920)
            IO.pwmSetRange(100)

def init():
    #Initialize wiringpi interface
    wiringpi.wiringPiSetupGpio()

    # Enter all known sensors into array
    sensors.append(Sensor(CENTER_TRIG, CENTER_ECHO, 0))
    #sensors.append(Sensor(CENTER_TRIG, RIGHT_SENSE_ECHO, 1))
    #sensors.append(Sensor(CENTER_TRIG, LEFT_SENSE_ECHO, -1))
    wiringpi.digitalWrite(OUTPUT_ENABLED, HIGH)

    for sensor in sensors: 
        wiringpi.pinMode(sensor.trigger, OUTPUT)
        wiringpi.pinMode(sensor.echo, OUTPUT)

        def setup(self, data, clock, latch):
                self.dataPin = data 
                self.clockPin = clock
                self.latchPin = latch
                
                wiringpi2.wiringPiSetupGpio()
                
                wiringpi2.pinMode(self.latchPin,1)
                wiringpi2.pinMode(self.dataPin,0)
                wiringpi2.pinMode(self.clockPin,1)

##                wiringpi2.digitalWrite(self.dataPin,0)
                wiringpi2.digitalWrite(self.clockPin,0)
                wiringpi2.digitalWrite(self.latchPin,1)

    def __init__(self):
        wiringpi.wiringPiSetupGpio()

        # Set pin states
        wiringpi.pinMode(enable_led_a, 1)
        wiringpi.pinMode(enable_led_b, 1)
        wiringpi.pinMode(sensor, 0)
        wiringpi.pinMode(enable_motor_a, 1)
        wiringpi.pinMode(enable_motor_b, 1)

        wiringpi.digitalWrite(enable_led_a, 0)
        wiringpi.digitalWrite(enable_led_b, 0)
        wiringpi.digitalWrite(enable_motor_a, 0)
        wiringpi.digitalWrite(enable_motor_b, 0)

def init():
	GPIO.setmode(GPIO.BCM)
	wiringpi.wiringPiSetupGpio()
	wiringpi.pinMode(LEFT_MOTOR_PWM, 2)
	wiringpi.pinMode(RIGHT_MOTOR_PWM, 2)
	wiringpi.pwmSetMode(0)
	wiringpi.pwmSetClock(CLK_DIVISOR)
	wiringpi.pwmSetRange(MAX_SPEED)
	wiringpi.pwmWrite(LEFT_MOTOR_PWM, 0)
	wiringpi.pwmWrite(RIGHT_MOTOR_PWM, 0)
	GPIO.setup(LEFT_MOTOR_A, GPIO.OUT)
	GPIO.setup(LEFT_MOTOR_B, GPIO.OUT)	
	GPIO.setup(RIGHT_MOTOR_A, GPIO.OUT)
	GPIO.setup(RIGHT_MOTOR_B, GPIO.OUT)

	def __init__(self, name, pinToWatch, triggerOnHigh = True):
		self._watchPin = pinToWatch
		self._dataLock = Lock()
		self._name = name
		self._triggerOnHigh = triggerOnHigh

		wiringpi.wiringPiSetupGpio()
		wiringpi.piHiPri(99)
		wiringpi.wiringPiISR(self._watchPin, wiringpi.GPIO.INT_EDGE_BOTH, Sensor.gpioCallback, self)

		if bool(wiringpi.digitalRead(self._watchPin)) == self._triggerOnHigh:
			self._lastStatus = True
		else:
			self._lastStatus = False
			self._triggerEnded = datetime.today()