def __init__(self, dev=(0,0),speed=4000000, brightness=256, contrast=CONTRAST):
        self.spi = spidev.SpiDev()
        self.speed = speed
        self.dev = dev
        self.spi.open(self.dev[0],self.dev[1])
        self.spi.max_speed_hz=self.speed

        # Set pin directions.
        self.dc = DC
        self.rst = RST
        wiringpi.wiringPiSetup()
        for pin in [self.dc, self.rst]:
            wiringpi.pinMode(pin, 1)

        self.contrast=contrast
        self.brightness=brightness
        
        # Toggle RST low to reset.
        wiringpi.digitalWrite(self.rst, OFF)
        time.sleep(0.100)
        wiringpi.digitalWrite(self.rst, ON)
        # Extended mode, bias, vop, basic mode, non-inverted display.
        wiringpi.digitalWrite(self.dc, OFF)
        self.spi.writebytes([0x21, 0x14, self.contrast, 0x20, 0x0c])
        # cls()

        self.ledpin = LED
        if self.ledpin == 1:
            wiringpi.pinMode(self.ledpin, 2)
            wiringpi.pwmWrite(self.ledpin, self.brightness)
        else:
            wiringpi.pinMode(self.ledpin, 1)
            wiringpi.digitalWrite(self.ledpin, ON)

    def run(self):            
        logging.info(__name__ + ":initializing WiringPi2")
        wiringpi.wiringPiSetup()

        localNode = Node.local
        localEvent = Event(0,localNode.id,localNode.devStr,localNode.devNum,[])
        localEvent.values = [0]*len(Sensor.instances)
        lastReport = time.time()
        lastRead = 0.0
        sigChange = False
        needToReport = False
        while not self.cancelled:
            now = time.time()
            if now - lastRead > localNode.monitorInterval:
                #Read all sensors and schedule their updates and reporting
                lastRead = now
                for key in Sensor.instances:
                    sigChange |= Sensor.instances[key].update()   # read sensor
            if sigChange or (now - lastReport) > localNode.reportInterval:
                for i,sensor in enumerate(self.sensors):
                    localEvent.values[i] = round(sensor.report()*10)
                localEvent.time = now
                evt = localEvent.tuple()
                logging.debug(__name__ + "Local event:" + str(evt))
                localNode.eventlog.qEvent(evt)
                needToReport = True
                sigChange = False
            if needToReport and (now - lastReport) > localNode.minServerEventInterval:
                localNode.server.qEvent(evt)
                logging.debug(__name__+":logged event for-"+str(evt))
                lastReport = now
                needToReport = False
            time.sleep(max(0, min(2,
                                  lastRead + localNode.monitorInterval - now,
                                  lastReport + localNode.reportInterval - now)))

def main():
    delay = 1E-2 # seconds

    # set up pins
    wiringpi.wiringPiSetup()
    for pin in pinsA:
        wiringpi.pinMode( pin, 1 )
    for pin in pinsB:
        wiringpi.pinMode( pin, 1 )
    for pin in pinsOut:
        wiringpi.pinMode( pin, 0 )
    wiringpi.pinMode( isSignedPin, 1 )
    wiringpi.pinMode( isSupportedPin, 0 )
    
    numFails = testUnsigned(delay)
    numFails += testSigned(delay)

    # magic for coloured printing from https://pythonadventures.wordpress.com/2011/03/16/print-colored-text-in-terminal/
    colorred = "\033[01;31m{0}\033[00m"
    colorgrn = "\033[1;36m{0}\033[00m"
    
    if numFails > 0:
        print colorred.format("%d tests were failed" % numFails)
    else:
        print colorgrn.format("All tests passed")

def init_wiringpi(sCon):

    wiringpi.wiringPiSetup()

    wiringpi.pinMode(sCon.mosipin, 1)
    wiringpi.pinMode(sCon.misopin, 0)
    wiringpi.pinMode(sCon.clkpin,  1)
    wiringpi.pinMode(sCon.cspin,   1)
    wiringpi.pullUpDnControl(sCon.misopin, 0)

def init():

    GPIO.wiringPiSetup()  
    GPIO.pinMode(pinLed, 0) # sets WP pin 6 to input  
    GPIO.pinMode(pinPwr, 1) 
    GPIO.pinMode(pin1Cup, 1) 
    GPIO.pinMode(pin2Cup, 1) 
    # mise à 1 de tous les boutons
    GPIO.digitalWrite(pinPwr, GPIO.GPIO.HIGH)
    GPIO.digitalWrite(pin1Cup, GPIO.GPIO.HIGH)
    GPIO.digitalWrite(pin2Cup, GPIO.GPIO.HIGH)

def setup():
  # Set pin directions.
  wiringpi.wiringPiSetup()
  for pin in [DC, RST]:
    wiringpi.pinMode(pin, ON)

  wiringpi.pinMode(LED,2)
  wiringpi.pwmWrite(LED,128)

  spi.open(0,0)
  spi.max_speed_hz=5000000

 def setup(self):
     """
     Setup to use the GPIO. 
     """
     wiringpi.wiringPiSetup()                # setup the wiringPi library 
     self.A     = self.DigitalInputPin(0)    # the rotary encorder A
     self.B     = self.DigitalInputPin(1)    # the rotary encorder B
     self.RED   = self.LED(2)                # the LED on the rotary encorder RED
     self.GREEN = self.LED(3)                # the LED on the rotary encorder GREEN
     self.SW    = self.DigitalInputPin(4)    # the push switch on the rotary encorder
     self.A.pullUp()                         # set default level HIGH
     self.B.pullUp()                         # set default level HIGH
     self.SW.pullUp()                        # set default level HIGH

	def create( self ):
		# Addresses: 0x20, 0x21, 0x22
		# Setup WIRING PI in Pin Mode
		wiringpi.wiringPiSetup()

		# Setup the chips
		wiringpi.mcp23017Setup( 65, 0x20 )
		wiringpi.mcp23017Setup( 81, 0x21 )
		wiringpi.mcp23017Setup( 97, 0x22 )

		# Setup pins on the I2C Controller chip
		for x in range( 65, 114 ):
			wiringpi.pinMode( x, 1 ) # Set pin to output
			wiringpi.digitalWrite( x, 1 ) # Set pin to off

    def __init__(self, valves, pullsocket, pushsocket):
        threading.Thread.__init__(self)
        wp.wiringPiSetup()
        time.sleep(1)
        for index in range(0, 21):  # Set GPIO pins to output
            wp.pinMode(index, 1)
            wp.digitalWrite(index, 0)
        # Now that all output are low, we can open main safety output
        wp.digitalWrite(20, 1)

        self.pullsocket = pullsocket
        self.pushsocket = pushsocket
        self.running = True
        self.valves = valves

def main():
    if wp.wiringPiSetup() == -1:
        print ("Unable to start wiringPi")
        sys.exit(1)

    if wp.wiringPiSPISetup(SPI_CHANNEL, SPI_SPEED) == -1:
        print ("wiringPiSPISetup Failed")
        sys.exit(1)

    wp.pinMode(CS_MCP3208, wp.OUTPUT)

    while 1:
        t = time.time()

        vt = read_adc(0)
        R = (10000*vt)/(5-vt)
        vt = 5*R/(R+10000)
        temp = -0.3167*(vt**6) + 4.5437*(vt**5) - 24.916*(vt**4) + 63.398*(vt**3) - 67.737*vt*vt - 13.24*vt + 98.432

        vh = read_adc(1)
        humidity = (((vh/5.0)-0.16)/0.0062)/(1.0546-0.00216*temp)

        print('{} Temp={}C, Humid={}%'.format(t, temp, humidity))
        data = 'rasptest temp={},hum={} {:d}'.format(temp, humidity, int(t * (10**9)))
        print("Send data to DB")
        r = requests.post('http://192.168.1.231:8086/write', auth=('mydb', 'O7Bf3CkiaK6Ou8eqYttU'), params={'db': 'mydb'}, data=data)
        print("Return status: {}", r.status_code)

        time.sleep(30)

	def __init__(self, CS1, CS2, E, RS, D0, D1, D2, D3, D4, D5, D6, D7, PWM):
		self.CS1 = CS1
		self.CS2 = CS2
		self.E = E
		self.RS = RS
		self.D0 = D0
		self.D1 = D1
		self.D2 = D2
		self.D3 = D3
		self.D4 = D4
		self.D5 = D5
		self.D6 = D6
		self.D7 = D7
		self.PWM = PWM
		
		# initialize new framebuffer
		self.myFrameBuffer = Framebuffer()
		
		# setup wiringPi for backlight PWM
		wiringpi.wiringPiSetup()
		wiringpi.pinMode(self.PWM,2) # setup wiringPi pin for PWM		   
		
		GPIO.setmode(GPIO.BCM)
		
		GPIO.setup(self.CS1, GPIO.OUT, initial=0)
		GPIO.setup(self.CS2, GPIO.OUT, initial=0)
		GPIO.setup(self.E, GPIO.OUT, initial=0)
		GPIO.setup(self.RS, GPIO.OUT, initial=1)
		GPIO.setup(self.D0, GPIO.OUT, initial=0)
		GPIO.setup(self.D1, GPIO.OUT, initial=0)
		GPIO.setup(self.D2, GPIO.OUT, initial=0)
		GPIO.setup(self.D3, GPIO.OUT, initial=0)
		GPIO.setup(self.D4, GPIO.OUT, initial=0)
		GPIO.setup(self.D5, GPIO.OUT, initial=0)
		GPIO.setup(self.D6, GPIO.OUT, initial=0)
		GPIO.setup(self.D7, GPIO.OUT, initial=0)
		
		sleep(self.DELAY_E)
		self.turnOn()
		self.setStartLine(0)
		self.clearScreen()
		self.setPage(0) # start on top left
		self.setAddress(1)

def setup_gpio():
  wiringpi.wiringPiSetup()
  # Set pin directions.
# outputs :
  for pin in [DIN, SCLK, DC, RST, SCE]:
    wiringpi.pinMode(pin, OUT)
# inputs :
  for pin in [UP, RIGHT, DOWN, LEFT, SELECT]:
    wiringpi.pinMode(pin, IN)
 
# enable pull downs for the switches
  wiringpi.pullUpDnControl(UP, wiringpi.PUD_DOWN)
  wiringpi.pullUpDnControl(RIGHT, wiringpi.PUD_DOWN)
  wiringpi.pullUpDnControl(DOWN, wiringpi.PUD_DOWN)
  wiringpi.pullUpDnControl(LEFT, wiringpi.PUD_DOWN)
  wiringpi.pullUpDnControl(SELECT, wiringpi.PUD_DOWN)
 
  wiringpi.pinMode(LED,2) # pwm mode
  wiringpi.pwmWrite(LED,128) # mid-level

def main():
    context = zmq.Context()
    socket = context.socket(zmq.SUB)
    socket.setsockopt(zmq.SUBSCRIBE, '')
    socket.connect('tcp://192.168.2.1:7777')

    wiringpi.wiringPiSetup()
    wiringpi.softPwmCreate(RED_PIN, 0, 255)
    wiringpi.softPwmCreate(GREEN_PIN, 0, 255)
    wiringpi.softPwmCreate(BLUE_PIN, 0, 255)

    while True:
        rgb = int(socket.recv())
        red = (rgb >> 16) & 0xFF
        green = (rgb >> 8) & 0xFF
        blue = rgb & 0xFF

        wiringpi.softPwmWrite(RED_PIN, red)
        wiringpi.softPwmWrite(GREEN_PIN, green)
        wiringpi.softPwmWrite(BLUE_PIN, blue)

def main():
    """ Main function """
    wp.wiringPiSetup()
    datasocket = DateDataPullSocket('furnaceroom_controller',
                                    ['temperature', 'setpoint', 'dutycycle', 'pid_p', 'pid_i'],
                                    timeouts=999999, port=9000)
    datasocket.start()

    pushsocket = DataPushSocket('furnaceroom_push_control', action='store_last')
    pushsocket.start()

    power_calculator = PowerCalculatorClass(datasocket, pushsocket)
    power_calculator.daemon = True
    power_calculator.start()

    heater = HeaterClass(power_calculator, datasocket)
    heater.start()

    tui = CursesTui(heater)
    tui.daemon = True
    tui.start()

	def __init__(self, keyPad=default.defaultKeyPad, row=default.row, col=default.col):
		# wiringPi instance creation
		# (print SETUP for debugging, success value is SETUP=1) 
		self.SETUP=wiringpi.wiringPiSetup()
		
		# keypad dimension vs assigned GPIO checking
		# (must be of the same m x n size)
		self.__matrixSanity(keyPad, row, col)
		
		# in class 'global' constants
		self.keyPad = keyPad
		self.row = row
		self.col = col

	def __init__(self, ssr):
		
		self.verbose = False
		
		self.ssr = ssr
		
		threading.Thread.__init__(self)
		
		# set up the pin in out mode
		if wiringpi_available:
			#call(["/usr/local/bin/gpio", "mode", str(ssr.pin), "out"])
			#wiringpi.wiringPiSetupSys()
			
			#rasp numbering
			wiringpi.wiringPiSetup()
			
			#gpio numbering
			#wiringpi.wiringPiSetupGpio()
			
			#set the pinmode
			wiringpi.pinMode(int(ssr.pin), 1)
		elif bbb_available:
			GPIO.setup(ssr.pin, GPIO.OUT)
			#GPIO.cleanup()

		self.daemon = True
		self.duty_cycle = 0
		self.cycle_time = 0
		self.power = 100
		self.enabled = False
		self._On = False
		
		self.pid_controller = pid_controller.pidpy(ssr.pid)
		
		#create an event so we can stop
		self._stop = threading.Event()

def RFIDSetup():
    # setup up the serial port and the wiringpi software for use
    # call setup for the wiringpi2 software
    response = wiringpi2.wiringPiSetup()
    # set the GPIO pin for input
    wiringpi2.pinMode(GPIO_PIN, 0)
    # open the serial port and set the speed accordingly
    fd = wiringpi2.serialOpen('/dev/serial0', 9600)

    # clear the serial buffer of any left over data
    wiringpi2.serialFlush(fd)
    
    if response == 0 and fd >0:
        # if wiringpi is setup and the opened channel is greater than zero (zero = fail)
        print ("PI setup complete on channel %d" %fd)
    else:
        print ("Unable to Setup communications")
        sys.exit()
        
    return fd

	def __init(self):
		self.gpio = wiringpi.wiringPiSetup()		
		wiringpi.softPwmCreate(PIN_RED,   0, LED_MAX)
		wiringpi.softPwmCreate(PIN_GREEN, 0, LED_MAX)
		wiringpi.softPwmCreate(PIN_BLUE,  0, LED_MAX)
		self.off()

#Thermostat test script This tests all functionality
import wiringpi as io
import time
import Adafruit_CharLCD as LCD
import sht31
sht31 = sht31.SHT31(0)
LOW = 0
HIGH = 1
OUTPUT = 1
RELAY = 7

io.wiringPiSetup()
io.pinMode(RELAY,OUTPUT)

lcd = LCD.Adafruit_CharLCDPlate()

# Test Relay
io.digitalWrite(RELAY,HIGH)
time.sleep(1)
io.digitalWrite(RELAY,LOW)
time.sleep(1)

# activate screen
lcd.set_color(1,1,1)
lcd.clear()
time.sleep(1)
lcd.message('Hello!')
time.sleep(1)

# initialize temp
temperature, humidity = sht31.get_temp_and_humidity()

        elif shutdownBtn.is_pressed:
            shutdown()
        elif monitorBtn.is_pressed:
            toggleState()
        elif wifiBtn.is_pressed:
            wifiToggle()
        elif bluetoothBtn.is_pressed:
            bluetoothToggle()
        elif cheatBtn.is_pressed:
            showCheat()


# Initial File Setup
try:
    comboStates = readData(statePath)
    wiringpi.wiringPiSetup()
    wiringpi.pinMode(led, 2)
    wiringpi.pwmWrite(led, comboStates['brightness'])
    os.system("amixer sset -q 'PCM' " + str(comboStates['volume']) + "%")
    if comboStates['wifi'] == 1:
        os.system("sudo rfkill unblock wifi")
    else:
        os.system("sudo rfkill block wifi")
    if comboStates['bluetooth'] == 1:
        os.system("sudo rfkill unblock bluetooth")
    else:
        os.system("sudo rfkill block bluetooth")
except:
    writeData(statePath)
    wiringpi.wiringPiSetup()
    wiringpi.pinMode(led, 2)