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 turn_off_light(pin, use_overrides=False):
    """
    Turn off the specified light

    Taking into account various overrides if specified.

    :param pin: index of pin in _GPIO_PINS
    :type pin: int

    :param use_overrides: should overrides be used
    :type use_overrides: bool
    """
    if use_overrides:
        if is_pin_pwm[pin]:
            turn_on_light(pin, use_overrides, _PWM_OFF)
        else:
            if pin + 1 not in _ALWAYS_OFF_CHANNELS:
                if pin + 1 not in _INVERTED_CHANNELS:
                    wiringpi.digitalWrite(_GPIO_PINS[pin], _GPIOINACTIVE)
                else:
                    wiringpi.digitalWrite(_GPIO_PINS[pin], _GPIOACTIVE)
    else:
        if is_pin_pwm[pin]:
            wiringpi.softPwmWrite(_GPIO_PINS[pin], _PWM_OFF)
        else:
            wiringpi.digitalWrite(_GPIO_PINS[pin], _GPIOINACTIVE)

def fade_up(pin, step):
    """PWM ramp up to full duty"""
    logging.debug("Up")
    for i in range(0, PWM_COUNT, step):
        wiringpi.softPwmWrite(pin, i)
        IO.delay(12)
    IO.digitalWrite(pin, IO.HIGH)

def fade_down(pin, step):
    """PWM ramp down to zero duty"""
    logging.debug("Down")
    for i in reversed(range(0, PWM_COUNT, step)):
        wiringpi.softPwmWrite(pin, i)
        IO.delay(12)
    IO.digitalWrite(pin, IO.LOW)

 def wiringPiMotorBackward(self,PWM):
     if self.getStatus() == "V":
         self.wiringPiMotorStop()
     if self.getStatus() != "A":
         print PWM
         wiringpi2.softPwmWrite(self.backward,int(PWM))
     self.status = -1

def move(turn, throttle):
	throttle /= 2

	l_power = throttle
	r_power = throttle

	if (throttle < 0):
		gpio.digitalWrite(22,1)
		gpio.digitalWrite(23,0)

		l_power = (throttle * -1)
		r_power = (throttle * -1)
	else:
		gpio.digitalWrite(22,0)
		gpio.digitalWrite(23,1)


	if (turn < 0):
		l_power = throttle
		r_power = throttle - (turn * -1)
	elif turn > 0:
		l_power = throttle - turn
		r_power = throttle 

	gpio.softPwmWrite(18, l_power)
	gpio.softPwmWrite(17, r_power)

def magnet(nummer, staerke, polaritaet):
    if not ((0 <= nummer <=3) and (0<= staerke <= 100) and (0<= polaritaet <=1)):
        #fehler        
        print("magnet: falscher Parameter. Magnet=" + str(nummer) + ", Staerke=" + str(staerke) + ", Polaritaet=" + str(polaritaet))
        return -1
    w.softPwmWrite(pins_pwm[nummer],staerke)
    mag_value[nummer] = staerke
    w.digitalWrite(pins_pol[nummer],polaritaet)
    return 0

 def rotate(self, direction, speed):
     if direction == 1:
         io1.digitalWrite(self.__d1_pin,0)
         io1.digitalWrite(self.__d2_pin,1)
         io1.softPwmWrite(self.__p_pin,int(speed))
     if direction == -1:
         io1.digitalWrite(self.__d1_pin,1)
         io1.digitalWrite(self.__d2_pin,0)
         io1.softPwmWrite(self.__p_pin,int(speed))

def pol(nummer,polaritaet):
    if not ((0 <= nummer <=3) and  (0<= polaritaet <=1)):
        print("magnet: falscher Parameter. Magnet=" + str(nummer) + ", Polaritaet=" + str(polaritaet))   
        return -1
    
    w.softPwmWrite(pins_pwm[nummer],0) # magnet abschalten, bevor wir die Polaritaet umschalten
    sleep(.1)
    w.digitalWrite(pins_pol[nummer],polaritaet)
    sleep(.1)
    w.softPwmWrite(pins_pwm[nummer],mag_value[nummer])# magnet wieder auf vorherige Staerke schalten
    return 0

	def process_change(self, color, value):
		value = int(value)
		pin = 0
		if color == 'r':
			pin = red
		elif color == 'g':
			pin = green
		elif color == 'b':
			pin = blue
		if pin != 0 and value >= 0 and value <= 100:
			wpi.softPwmWrite(pin, value)

def mag_st(nummer, staerke):
    if staerke < 0:
        staerke = 0
    if staerke > 100:
        staerke = 100
    if not ((0 <= nummer <=3) and (0<= staerke <= 100)):
        #fehler        
        print("mag_st: falscher Parameter. Magnet=" + str(nummer) + ", Staerke=" + str(staerke))
        return -1
    w.softPwmWrite(pins_pwm[nummer],staerke)
    mag_value[nummer] = staerke
    return 0

 def camera(self, angle1, angle2):
     if angle1 < 0 or angle1 > 180 or angle2 < 0 or angle2 > 180:
         return False
     # TODO
     angle1 = int(127 + int(127 * float(angle1) / 180))
     angle2 = int(127 + int(127 * float(angle2) / 180))
     wiringpi2.pinMode(self.config.get("pin1_cam"), 1)
     wiringpi2.softPwmCreate(self.config.get("pin1_cam"), 0, 100)
     wiringpi2.softPwmWrite(self.config.get("pin1_cam"), angle1)
     wiringpi2.pinMode(self.config.get("pin2_cam"), 1)
     wiringpi2.softPwmCreate(self.config.get("pin2_cam"), 0, 100)
     wiringpi2.softPwmWrite(self.config.get("pin2_cam"), angle2)
     time.sleep(0.100)

def setColors(red, green, blue):
   global colors

   #Check if inputs are in valid range 
   for c in (red, green, blue): 
      if c < 0 or c > 255: return -1

   colors = [red, green, blue] 

   for (clr, pin) in zip(colors, colorPins):
         wiringpi2.softPwmWrite(pin, int(clr*100.0/255.0))

   return (red*65536 + green*256 + blue)

def softPwm():
	print "SoftPwm Mode"

	wiringpi2.wiringPiSetup()
	wiringpi2.pinMode(PIN_TO_PWM,OUTPUT)
	wiringpi2.softPwmCreate(PIN_TO_PWM,0,100) # Setup PWM using Pin, Initial Value and Range parameters

	for time in range(0,4):
        	for brightness in range(0,100): # Going from 0 to 100 will give us full off to full on
                	wiringpi2.softPwmWrite(PIN_TO_PWM,brightness) # Change PWM duty cycle
                	wiringpi2.delay(10) # Delay for 0.2 seconds
        	for brightness in reversed(range(0,100)):
                	wiringpi2.softPwmWrite(PIN_TO_PWM,brightness)
                	wiringpi2.delay(10)

def MoveForward(n):
    """Move forward for 'n' seconds"""
    wiringpi.softPwmWrite(leftDrive, leftDriveLevel)
    wiringpi.softPwmWrite(rightDrive, rightDriveLevel)
    time.sleep(n)
    wiringpi.softPwmWrite(leftDrive, 0)
    wiringpi.softPwmWrite(rightDrive, 0)

	def __init__(self, pin=DEFAULT_PIN, calibration_file=None, smoothing=None, wiringpi_obj=None, zero_pin=None, **kwargs):
		super(PWMCalibrator, self).__init__()
		
		if not SOFTPWM_SUPPORT and ((pin!=WIRINGPI_PWM_PIN) or zero_pin!=None):
			raise Exception("No soft PWM support (is wiringpi2 installed?). Only pin 1 may be used.")

		self.pin = pin

		if wiringpi_obj is not None:
			self.wp = wiringpi_obj
		else:
			wiringpi.wiringPiSetup()
		
		# PWM: hardware or software?
		if (not SOFTPWM_SUPPORT) or (self.pin==WIRINGPI_PWM_PIN):
			wiringpi.pinMode(self.pin, wiringpi.GPIO.PWM_OUTPUT)
			self.pwm_write = wiringpi.pwmWrite
			self.pwm_max = PWM_MAX
		else:
			wiringpi.softPwmCreate(self.pin, 0, SOFT_PWM_MAX)
			self.pwm_write = wiringpi.softPwmWrite
			self.pwm_max = kwargs.get('soft_pwm_max', SOFT_PWM_MAX)		

		# zero out any zero pins, as necessary
		# (this is used for bidirectional meters; by default the pi's pins
		# are in a high-impedence mode that will prevent adequate calibration)
		if zero_pin!=None:
			if zero_pin==WIRINGPI_PWM_PIN:
				wiringpi.pinMode(zero_pin, wiringpi.GPIO.PWM_OUTPUT)
				wiringpi.pwmWrite(zero_pin, 0)
			else:
				wiringpi.softPwmCreate(zero_pin, 0, SOFT_PWM_MAX)
				wiringpi.softPwmWrite(zero_pin, 0)

		self.pwm_value = 0
		self.calibration = []
                if smoothing is True:
                        self.smoothing = 0.005
                else:	
		        self.smoothing = smoothing

		if calibration_file is not None:
			self.calibration_file = calibration_file
		else:
			self.calibration_file = DEFAULT_CALIBRATION_FILENAME

def set_light(pin, use_overrides=False, brightness=1.0):
    """Set the brightness of the specified light
    
    Taking into account various overrides if specified.
    The default is full on (1.0)
    To turn a light off pass 0 for brightness
    If brightness is a float between 0 and 1.0 that level 
    will be set.
    
    This function replaces turn_on_light and turn_off_light

    :param pin: index of pin in cm.hardware.gpio_pins
    :type pin: int

    :param use_overrides: should overrides be used
    :type use_overrides: bool

    :param brightness: float, a float representing the brightness of the lights
    :type brightness: float
    """
    if math.isnan(brightness):
        brightness = 0.0

    if _ACTIVE_LOW_MODE:
        brightness = 1.0 - brightness

    if use_overrides:
        if pin + 1 in always_off_channels:
            brightness = 0
        elif pin + 1 in always_on_channels:
            brightness = 1

        if pin + 1 in inverted_channels:
            brightness = 1 - brightness

    if not network.playing and server:
        network.broadcast(cm.hardware.gpio_pins.index(cm.hardware.gpio_pins[pin]), brightness)

    if is_pin_pwm[pin]:
        wiringpi.softPwmWrite(cm.hardware.gpio_pins[pin], int(brightness * _PWM_MAX))
    else:
        wiringpi.digitalWrite(cm.hardware.gpio_pins[pin], int(brightness > 0.5))

def turn_on_light(pin, use_overrides=False, brightness=1.0):
    """Turn on the specified light

    Taking into account various overrides if specified.

    :param pin: index of pin in _GPIO_PINS
    :type pin: int

    :param use_overrides: should overrides be used
    :type use_overrides: bool

    :param brightness: float, a float representing the brightness of the lights
    :type brightness: float
    """
    if is_pin_pwm[pin]:
        if math.isnan(brightness):
            brightness = 0.0
        if _ACTIVE_LOW_MODE:
            brightness = 1.0 - brightness
        if brightness < 0.0:
            brightness = 0.0
        if brightness > 1.0:
            brightness = 1.0
        if use_overrides:
            if pin + 1 in _ALWAYS_OFF_CHANNELS:
                brightness = 0
            elif pin + 1 in _ALWAYS_ON_CHANNELS:
                brightness = 1
            if pin + 1 in _INVERTED_CHANNELS:
                brightness = 1 - brightness
        wiringpi.softPwmWrite(_GPIO_PINS[pin], int(brightness * _PWM_MAX))
        return

    if use_overrides:
        if pin + 1 not in _ALWAYS_OFF_CHANNELS:
            if pin + 1 not in _INVERTED_CHANNELS:
                wiringpi.digitalWrite(_GPIO_PINS[pin], _GPIOACTIVE)
            else:
                wiringpi.digitalWrite(_GPIO_PINS[pin], _GPIOINACTIVE)
    else:
        wiringpi.digitalWrite(_GPIO_PINS[pin], _GPIOACTIVE)

 def sliderMoved(self,widget,data): 
     if(data == "red" and self.redIsOn == True): 
         wiringpi2.softPwmWrite(self.redPin, int(self.redSlider.get_value())) 
     elif(data == "blue" and self.blueIsOn == True): 
         wiringpi2.softPwmWrite(self.bluePin, int(self.blueSlider.get_value())) 
     elif(data == "green" and self.greenIsOn==True):
         wiringpi2.softPwmWrite(self.greenPin, int(self.greenSlider.get_value())) 

 def set(self, red, green, blue):
     self.red = red
     self.green = green
     self.blue = blue
     wiringpi2.softPwmWrite(self.r_pin, red)
     wiringpi2.softPwmWrite(self.g_pin, green)
     wiringpi2.softPwmWrite(self.b_pin, blue)