class lm35(object): """ Instatiates a analog read of the GPIO pin from galileo gen2 pin: Valid Analog Pin (14, 15, 16, 17, 18, 19) respectively from A0 to A5 unit: Can be either Celcius, Kelvin or Farenheit [c, k f] """ # Class Initializer def __init__(self, pin, unit="c", debug=False): self.gpio = GPIO(debug=False) self.unit = unit self.pin = pin self.gpio.pinMode(self.pin, self.gpio.ANALOG_INPUT) def get_value(self): self.raw = self.gpio.analogRead(self.pin) self.milivolt = (self.raw / 1024.0) * 5000 self.celcius = self.milivolt / 10 self.farenheit = (self.celcius * 1.8) + 32 self.kelvin = self.celcius + 273.0 if self.unit == "c": return self.celcius if self.unit == "k": return self.kelvin if self.unit == "f": return self.farenheit
class presence_sensor(object): def __init__(self, pin): self.gpio = GPIO(debug=False) self.pin = pin self.gpio.pinMode(pin, self.gpio.INPUT) def get_value(self): return bool(self.gpio.digitalRead(self.pin))
class Device(object): def __init__(self, pin_): self.gpio = GPIO(debug=False) self.gpio.pinMode(pin_, self.gpio.OUTPUT) def onDevice(self, pin_): return self.gpio.digitalWrite(pin_, self.gpio.HIGH) def offDevice(self, pin_): return self.gpio.digitalWrite(pin_, self.gpio.LOW) def getDevice(self, pin_): return self.gpio.digitalRead(pin_)
def defineIO(): gpio = GPIO(debug=False) if debugMode: print 'setting up io pin' gpio.pinMode(13,gpio.OUTPUT) gpio.pinMode(2,gpio.OUTPUT) gpio.pinMode(3,gpio.OUTPUT) gpio.pinMode(4,gpio.OUTPUT) gpio.pinMode(5,gpio.OUTPUT) gpio.pinMode(6,gpio.OUTPUT) if debugMode: print 'successfull...'
def defineIO(): from wiringx86 import GPIOGalileoGen2 as GPIO gpio = GPIO(debug=False) if debugMode: print 'setting up io pin' gpio.pinMode(13,gpio.OUTPUT) gpio.pinMode(2,gpio.OUTPUT) gpio.pinMode(3,gpio.OUTPUT) gpio.pinMode(4,gpio.OUTPUT) gpio.pinMode(5,gpio.OUTPUT) gpio.pinMode(6,gpio.OUTPUT) if debugMode: print 'successfull...'
def main(argv): print 'Starting up' gpio = GPIO(debug=False) gpio.pinMode(8,gpio.OUTPUT) for i in range(4): print 'Hi\n' gpio.digitalWrite(8,gpio.HIGH) time.sleep(0.5) print 'Lo\n' gpio.digitalWrite(8,gpio.LOW) time.sleep(0.5) print 'Done\n' gpio.cleanup()
def checkThenSetByte(dataVar): gpio = GPIO(debug=False) for x in range(0,8): if x==0: pin=2 elif x==1: pin=3 elif x==2: pin=4 elif x==3: pin=5 elif x==4: pin=6 elif x==5: pin=13 else: break gpio.pinMode(pin,gpio.OUTPUT) if checkBit(dataVar,x)>0: print("on") gpio.digitalWrite(pin, gpio.HIGH) if pin==13: print('indikator on') else: print("off") gpio.digitalWrite(pin, gpio.LOW) if pin==13: print('indikator off') if debugMode:print("seharusnya setelah di set, disini dicek lagi benar2 on apa tidak")
class photo_resistor(object): """ Instatiates a analog read of the GPIO pin from galileo gen2 pin: Valid Analog Pin (14, 15, 16, 17, 18, 19) respectively from A0 to A5 """ # Class Initializer def __init__(self, pin, debug=False): self.gpio = GPIO(debug=False) self.pin = pin self.gpio.pinMode(self.pin, self.gpio.ANALOG_INPUT) def get_value(self): self.raw = self.gpio.analogRead(self.pin) self.normalized = (self.raw / 1024.0) self.percent = self.normalized * 100 return self.percent
def main(argv): print 'Starting up' gpio = GPIO(debug=False) for i in range(5): gpio.pinMode(8+i,gpio.OUTPUT) gpio.pinMode(19,gpio.ANALOG_INPUT) for i in range(4100): x = gpio.analogRead(19) print x n = (x-460)/30 for j in range(5): if j<n: s=gpio.HIGH else: s=gpio.LOW gpio.digitalWrite(8+j,s) time.sleep(0.1) print 'Done\n' gpio.cleanup()
def temp_command(): gpio = GPIO(debug=False) analogpin = 14 gpio.pinMode(analogpin, gpio.ANALOG_INPUT) print 'Analog reading from pin %d now...' % analogpin try: count = 0 while(count < 5): # Read the voltage on pin 14 value = gpio.analogRead(analogpin) tempc = (5.0 * value * 100.0) tempc = tempc / 1024 value = tempc print 'Leitura: %.2f celsius' % value time.sleep(0.5) count = count + 1 # When you get tired of seeing the led blinking kill the loop with Ctrl-C. except KeyboardInterrupt: print '\nCleaning up...' # Do gpio.cleanup()
def main(argv): print 'Starting up' gpio = GPIO(debug=False) gpio.pinMode(19,gpio.ANALOG_INPUT) for i in range(30): x = gpio.analogRead(19) print x time.sleep(0.5) print 'Done\n' gpio.cleanup()
def __init__(self, uuid, pin, name, debug=False, gpio_debug=False): print_debug(debug, currentframe().f_code.co_name, 'Init pump: %s' % name, __name__) # Make sure we only have one instance per pump if uuid in self.instances: error = ValueError error.message = 'A pump-instance with ID "%i" already exist!' % uuid raise error # Add the new instance to the instances-list Pump.instances[uuid] = self self.uuid = uuid self.pin = pin self.name = name self.digital_pin = digitalPins.get(pin) self.debug = debug all_params_str = u'Uuid: {uuid}. Pin: {pin}. Digital pin: {dpin}. Name: {name}'.format( uuid=uuid, pin=pin, dpin=self.digital_pin, name=name, ) print_debug(debug, currentframe().f_code.co_name, all_params_str, __name__) # Get a new instance of the GPIO self.gpio = GPIO(debug=gpio_debug) # type: GPIO # Set the pump to output self.gpio.pinMode(self.digital_pin, self.gpio.OUTPUT) # Set the pumps initial status to closed self.__status = self.closed # Events the pump can send self.pump_is_turned_on = signal(blinker_signals['pump_is_on']) self.pump_is_turned_off = signal(blinker_signals['pump_is_off'])
import time import subprocess from wiringx86 import GPIOGalileoGen2 as GPIO gpio = GPIO(debug=False) pwm_pin = 11 value = 0 fade = 5 print("Setting up Pins...") gpio.pinMode(pwm_pin, gpio.OUTPUT) try: while (True): for i in xrange(0, 1000): gpio.digitalWrite(pwm_pin, gpio.HIGH) time.sleep(0.001) gpio.digitalWrite(pwm_pin, gpio.LOW) time.sleep(0.001) time.sleep(2) except KeyboardInterrupt: print("Cleaning up...") gpio.digitalWrite(pwm_pin, gpio.LOW) gpio.cleanup()
def __init__(self, pin_): self.gpio = GPIO(debug=False) self.gpio.pinMode(pin_, self.gpio.OUTPUT)
class Pump(object): """ Simple class that helps to open and close a pump that is connected to the board One instance represents one pump """ instances = {} opened = 'OPENED' closed = 'CLOSED' def __init__(self, uuid, pin, name, debug=False, gpio_debug=False): print_debug(debug, currentframe().f_code.co_name, 'Init pump: %s' % name, __name__) # Make sure we only have one instance per pump if uuid in self.instances: error = ValueError error.message = 'A pump-instance with ID "%i" already exist!' % uuid raise error # Add the new instance to the instances-list Pump.instances[uuid] = self self.uuid = uuid self.pin = pin self.name = name self.digital_pin = digitalPins.get(pin) self.debug = debug all_params_str = u'Uuid: {uuid}. Pin: {pin}. Digital pin: {dpin}. Name: {name}'.format( uuid=uuid, pin=pin, dpin=self.digital_pin, name=name, ) print_debug(debug, currentframe().f_code.co_name, all_params_str, __name__) # Get a new instance of the GPIO self.gpio = GPIO(debug=gpio_debug) # type: GPIO # Set the pump to output self.gpio.pinMode(self.digital_pin, self.gpio.OUTPUT) # Set the pumps initial status to closed self.__status = self.closed # Events the pump can send self.pump_is_turned_on = signal(blinker_signals['pump_is_on']) self.pump_is_turned_off = signal(blinker_signals['pump_is_off']) def turn_on_pump(self, magnetic_valve): """ Will open a specific pump and when it's open, and filled with water, it will open the valve provided :type magnetic_valve: MagneticValve :param magnetic_valve: The valve that should be opened while the pump is opened """ print_debug(self.debug, currentframe().f_code.co_name, 'Turning on pump: %s' % self.name, __name__) self.__status = self.opened self.gpio.digitalWrite(self.digital_pin, self.gpio.HIGH) # Open the valve after 1 second so we know there's water in the hose timer_time = 1 timer = Timer(timer_time, self.__send_turned_on_event, args=[magnetic_valve]) timer.start() def turn_off_pump(self): """ Turn off the pump :return: """ print_debug(self.debug, currentframe().f_code.co_name, 'Turning off pump: %s' % self.name, __name__) self.__status = self.closed self.gpio.digitalWrite(self.digital_pin, self.gpio.LOW) def cleanup(self): """ Turn off the pump on cleanup """ self.turn_off_pump() def __send_turned_on_event(self, valve): """ Send the turn on signal to the WateringQueue so it knows that it can open the valve :param valve: :return: """ self.pump_is_turned_on.send(valve) @property def is_opened(self): return self.__status is self.opened @property def get_instances(self): return self.instances
# This example is inspired on Arduino Blink example. # http://arduino.cc/en/Tutorial/Blink # # This example will work "out of the box" on an Intel® Galileo Gen2 board. If # you are using a different board such as an Intel® Galileo, just change the # import below. wiringx86 uses the same API for all the boards it supports. # Import the time module enable sleeps between turning the led on and off. import time # Import the GPIOGalileoGen2 class from the wiringx86 module. from wiringx86 import GPIOGalileoGen2 as GPIO # Create a new instance of the GPIOGalileoGen2 class. # Setting debug=True gives information about the interaction with sysfs. gpio = GPIO(debug=False) state = gpio.HIGH pins = 20 # Set all pins to be used as output GPIO pins. print 'Setting up all pins...' for pin in range(0, pins): gpio.pinMode(pin, gpio.OUTPUT) print 'Blinking all pins now...' try: while(True): for pin in range(0, pins): # Write a state to the pin. ON or OFF. gpio.digitalWrite(pin, state)
from upm import pyupm_servo as servo from wiringx86 import GPIOGalileoGen2 as GPIO from upm import pyupm_jhd1313m1 as lcd import __future__ from collections import OrderedDict pino_sensor_temperatura = 0 pino_rele = 8 pino_led1 = 3 pino_led2 = 4 pino_pot = 15 pino_servo1 = 5 pino_servo2 = 6 pinos = GPIO(debug=False) pinos.pinMode(pino_rele, pinos.OUTPUT) pinos.pinMode(pino_led1, pinos.OUTPUT) pinos.pinMode(pino_led2, pinos.OUTPUT) pinos.pinMode(pino_pot, pinos.ANALOG_INPUT) pinos.pinMode(pino_servo1, pinos.OUTPUT) pinos.pinMode(pino_servo2, pinos.OUTPUT) temp = upm.Temperature(pino_sensor_temperatura) sg_servo1 = servo.ES08A(pino_servo1) sg_servo2 = servo.ES08A(pino_servo2) tela = lcd.Jhd1313m1(0, 0x3E, 0x62) tela.setColor(0, 100, 50)
#defining necessary pins led = 13 #Importing Intel Galileo Official UPM Library import pyupm_grove as grove # Create the temperature sensor object using AIO pin 0 temp = grove.GroveTemp(0) # Create the light sensor object using AIO pin 0 light = grove.GroveLight(1) # make sure python wiring x86 library is installed. # Import the GPIOEdison class from the wiringx86 module. from wiringx86 import GPIOGalileoGen2 as GPIO gpio = GPIO() gpio.pinMode(led, gpio.OUTPUT) #defining topics ledTopic = "things/galileo" def on_connect(client, userdata, flags, rc): print("Connected with result code "+str(rc)) client.subscribe(ledTopic) print("Subscribed to Necessary Topics") def on_message(client, userdata, msg): print "Message Topic :" + str(msg.topic) print "Message :" + str(msg.payload)
import sys sys.path.append("../../gpio") import serial import math import time import os.path import argparse import threading from wiringx86 import GPIOGalileoGen2 as GPIO gpio = GPIO(debug=False) mote_pin = 2 gpio.pinMode(mote_pin, gpio.OUTPUT) class MoteData(object): def convert_power(raw): pw = -1 if (raw < 120): pw = 0 else: pw = 220 * math.sqrt(raw) * 0.004343 return (round(pw * 100) / 100) def convert_luminosity(raw): lum = ((raw / 8192) * 100) - 28 return lum class EposMoteIII(object): """
#!/usr/bin/python import socket, traceback import os import os.path import time import math from wiringx86 import GPIOGalileoGen2 as GPIO gpio = GPIO(debug=False) import thread #Stepper Motor Pins step = 0 direction = 1 #DC Motor Pins #For Motor 1 dir1 = 2 pwm1 = 3 brk1 = 4 #For Motor 2 dir2 = 8 pwm2 = 9 brk2 = 10 pwmvalue = 50
#!/usr/bin/python3 import sys sys.path.append("../gpio") import os import subprocess import time import threading from wiringx86 import GPIOGalileoGen2 as GPIO gpio = GPIO(debug=False) internet_pin = 1 gpio.pinMode(internet_pin, gpio.OUTPUT) def check_internet(period, lock): while True: #response = subprocess.call("ping -c 1 google.com -q > /dev/null 2>&1", shell=True) p = subprocess.Popen("ping -c 1 google.com".split(), stdout=subprocess.PIPE, stderr=subprocess.STDOUT) out, err = p.communicate() response = p.wait() #print (response) if response == 0: print("CONNECTIVITY: \tConnected to internet") gpio.digitalWrite(internet_pin, gpio.HIGH)
print 'Plataforma galileogen1' from wiringx86 import GPIOGalileo as GPIO elif modelo == 'raspberrypi': print 'Plataforma RaspBerryPi' print 'passou pela configuraPCI' ''' try: from wiringx86 import GPIOGalileo as GPIO print ('Rodando na Gen1') except: from wiringx86 import GPIOGalileoGen2 as GPIO print ('Rodando na Gen2') ''' pinos = GPIO(debug=False) from openweather import openweather try: with open('config.txt') as json_data: config = json.load(json_data) piracicaba = openweather(config['api_key'], '3453643') except: print 'Erro na coneccao com a internet' from upm import pyupm_jhd1313m1 as LCD lcd = LCD.Jhd1313m1(0, 0x3E, 0x62) from upm import pyupm_servo as servo from upm import pyupm_temperature as upm import threading pino_sensor_temperatura = 0
import time import subprocess from wiringx86 import GPIOGalileoGen2 as GPIO gpio = GPIO(debug=False) lm35_pin = 16 photo_pin = 14 summ = 0 sample = 0 print("Setting Up all pins...") gpio.pinMode(lm35_pin, gpio.ANALOG_INPUT) gpio.pinMode(photo_pin, gpio.ANALOG_INPUT) print("Analog reading from pin A0") try: while (True): raw_value_lm35 = gpio.analogRead(lm35_pin) raw_value_photo = gpio.analogRead(photo_pin) milivolt = (raw_value_lm35 / 1024.0) * 5000 celcius = milivolt / 10 percent = 100 - (raw_value_photo / 1024.0 * 100) # summ += celcius # sample += 1 # avg = summ/sample print(celcius, percent)
import time import subprocess from wiringx86 import GPIOGalileoGen2 as GPIO gpio = GPIO(debug=False) presence_sensor = 4 gpio.pinMode(presence_sensor, gpio.INPUT) print("Reading Now") try: while (True): time.sleep(1) state = gpio.digitalRead(presence_sensor) print(state) except KeyboardInterrupt: print("\n\nCleaning Up...") gpio.cleanup()
class AutomaticWateringSystem(object): """ Main class for the Automatic Watering System (AWS) Will initiate the classes needed for a plant """ instances = {} def __init__(self, uuid, name, temperature_pin=None, magnetic_valve_pin=None, moisture_pin=None, debug=False, gpio_debug=False): """ Constructor :type uuid: str :param uuid: The ID from the database :type name: str :param name: The name of the plant :type temperature_pin: int :param temperature_pin: Which pin the temperature sensor is attached to :type magnetic_valve_pin: int :param magnetic_valve_pin: Which pin the magnetic valve is attached to :type moisture_pin: int :param moisture_pin: Which pin the moisture sensor is attached to :type debug: bool :param debug: :type gpio_debug: bool :param gpio_debug: Specify if the debug should be on/off for the GPIO library """ print_debug(debug, currentframe().f_code.co_name, u'Init %s' % name, __name__) all_params_str = u'UUID: {uuid}. Name: {name}. TP: {tp}. MVP: {mvp}. MP: {mp}'.format( uuid=uuid, name=name, tp=temperature_pin, mvp=magnetic_valve_pin, mp=moisture_pin ) print_debug(debug, currentframe().f_code.co_name, all_params_str, __name__) # Add the new instance to the instances-list AutomaticWateringSystem.instances[uuid] = self self.__name = name self.__temperature_pin = temperature_pin self.__magnetic_valve_pin = magnetic_valve_pin self.__moisture_pin = moisture_pin self.debug = debug # Get a uuid for the class so we can identify easier # self.__uuid = str(uuid4()) # type: uuid4 self.__uuid = uuid self.DB = Database.Database() self.db_own_plant = self.DB.get_own_plant_from_id(self.get_uuid) self.db_plant = self.DB.get_plant_from_id(self.db_own_plant.get('plant_id')) self.db_pump = self.DB.get_pump_from_id(self.db_own_plant.get('pump_id')) # Get a new instance of the GPIO self.gpio = GPIO(debug=gpio_debug) # type: GPIO # It has to be a magnetic valve connected! self.MagneticValve = None if magnetic_valve_pin is not None: print_debug(debug, currentframe().f_code.co_name, 'Initializing magnetic valve at pin %i' % magnetic_valve_pin, __name__) self.MagneticValve = MagneticValve(self.gpio, self.__uuid, magnetic_valve_pin, name, self.db_own_plant.get('pump_id'), debug) # type: MagneticValve else: error = EnvironmentError error.message = 'A magnetic valve is needed!' raise error self.TemperatureSensor = None if temperature_pin is not None: print_debug(debug, currentframe().f_code.co_name, 'Initializing temperature sensor at pin %i' % temperature_pin, __name__) self.TemperatureSensor = Temperature(self.gpio, self.__uuid, temperature_pin, name, 30, debug) # type: Temperature self.MoistureSensor = None if moisture_pin is not None: print_debug(debug, currentframe().f_code.co_name, 'Initializing moisture sensor at pin %i' % moisture_pin, __name__) self.MoistureSensor = Moisture(self.gpio, self.__uuid, moisture_pin, name, self.db_plant.get('min_moisture'), self.db_plant.get('max_moisture'), debug) # type: Moisture self.__run_count = 0 self.active = True # Run a check directly when a new instance is created self.__start_new_timer(0) def __start_new_timer(self, time=60): """ Starts a new timer :type time: int :param time: How many seconds the timer should be set to """ new_timer_uuid = str(uuid.uuid4()) print_debug(self.debug, currentframe().f_code.co_name, u'New timer will start after {time} second(s). AWS name: {name}. Timer UUID: {uuid}' .format(time=time, name=self.get_name, uuid=new_timer_uuid), __name__) self.timer = Timer(time, self.__run, [new_timer_uuid]) self.timer.start() def __run(self, timer_id): """ Run the different checks, and open the valve if needed! This function should not be called directly! Call __start_new_timer() instead! :type timer_id: str :param timer_id: A unique identifier for each timer """ self.__run_count += 1 print_debug(self.debug, currentframe().f_code.co_name, u'Timer executing. AWS name: {name}. Timer UUID: {timer_id}' .format(name=self.get_name, timer_id=timer_id), __name__) print_debug(self.debug, currentframe().f_code.co_name, u'Run count: %s' % self.__run_count, __name__) temp_exceed = False moist_deceed = False stats_dict = {Database.TABLE_STATISTICS_RUN_COUNT: self.__run_count} if self.TemperatureSensor: stats_dict[Database.TABLE_STATISTICS_TEMPERATURE_RAW] = self.TemperatureSensor.get_raw_read() stats_dict[Database.TABLE_STATISTICS_TEMPERATURE_MIN_CELSIUS] = self.TemperatureSensor.min_celsius stats_dict[Database.TABLE_STATISTICS_TEMPERATURE_MAX_CELSIUS] = self.TemperatureSensor.max_celsius stats_dict[Database.TABLE_STATISTICS_TEMPERATURE_CELSIUS] = self.TemperatureSensor.get_celsius() temp_exceed = self.TemperatureSensor.has_exceeded_threshold() if self.MoistureSensor: stats_dict[Database.TABLE_STATISTICS_MOISTURE_RAW] = self.MoistureSensor.get_raw_read() stats_dict[Database.TABLE_STATISTICS_MOISTURE_MIN_PERCENT] = self.MoistureSensor.min_percent stats_dict[Database.TABLE_STATISTICS_MOISTURE_MAX_PERCENT] = self.MoistureSensor.max_percent stats_dict[Database.TABLE_STATISTICS_MOISTURE_PERCENT] = self.MoistureSensor.get_percent_read() moist_deceed = self.MoistureSensor.has_deceeded_threshold() print_debug(self.debug, currentframe().f_code.co_name, u'Temp exceed: %s' % str(temp_exceed), __name__) print_debug(self.debug, currentframe().f_code.co_name, u'Moist deceed: %s' % str(moist_deceed), __name__) # Add statistics self.DB.add_statistic(self.get_uuid, **stats_dict) if moist_deceed: # Try to open the valve self.MagneticValve.send_open_valve_signal() print_debug(self.debug, currentframe().f_code.co_name, u'Timer done. AWS name: {name}. Timer UUID: {timer_id}' .format(name=self.get_name, timer_id=timer_id), __name__) self.__start_new_timer(10) # self.__start_new_timer() def cleanup(self): """ Cleanup all the things! """ print_debug(self.debug, currentframe().f_code.co_name, u'Cleanup ({name}, {uuid})!'.format(name=self.get_name, uuid=self.get_uuid), __name__) if self.TemperatureSensor: self.TemperatureSensor.cleanup() if self.MoistureSensor: self.MoistureSensor.cleanup() self.MagneticValve.cleanup() self.timer.cancel() self.gpio.cleanup() @property def get_name(self): return self.__name @property def get_uuid(self): return self.__uuid
def __init__(self, uuid, name, temperature_pin=None, magnetic_valve_pin=None, moisture_pin=None, debug=False, gpio_debug=False): """ Constructor :type uuid: str :param uuid: The ID from the database :type name: str :param name: The name of the plant :type temperature_pin: int :param temperature_pin: Which pin the temperature sensor is attached to :type magnetic_valve_pin: int :param magnetic_valve_pin: Which pin the magnetic valve is attached to :type moisture_pin: int :param moisture_pin: Which pin the moisture sensor is attached to :type debug: bool :param debug: :type gpio_debug: bool :param gpio_debug: Specify if the debug should be on/off for the GPIO library """ print_debug(debug, currentframe().f_code.co_name, u'Init %s' % name, __name__) all_params_str = u'UUID: {uuid}. Name: {name}. TP: {tp}. MVP: {mvp}. MP: {mp}'.format( uuid=uuid, name=name, tp=temperature_pin, mvp=magnetic_valve_pin, mp=moisture_pin ) print_debug(debug, currentframe().f_code.co_name, all_params_str, __name__) # Add the new instance to the instances-list AutomaticWateringSystem.instances[uuid] = self self.__name = name self.__temperature_pin = temperature_pin self.__magnetic_valve_pin = magnetic_valve_pin self.__moisture_pin = moisture_pin self.debug = debug # Get a uuid for the class so we can identify easier # self.__uuid = str(uuid4()) # type: uuid4 self.__uuid = uuid self.DB = Database.Database() self.db_own_plant = self.DB.get_own_plant_from_id(self.get_uuid) self.db_plant = self.DB.get_plant_from_id(self.db_own_plant.get('plant_id')) self.db_pump = self.DB.get_pump_from_id(self.db_own_plant.get('pump_id')) # Get a new instance of the GPIO self.gpio = GPIO(debug=gpio_debug) # type: GPIO # It has to be a magnetic valve connected! self.MagneticValve = None if magnetic_valve_pin is not None: print_debug(debug, currentframe().f_code.co_name, 'Initializing magnetic valve at pin %i' % magnetic_valve_pin, __name__) self.MagneticValve = MagneticValve(self.gpio, self.__uuid, magnetic_valve_pin, name, self.db_own_plant.get('pump_id'), debug) # type: MagneticValve else: error = EnvironmentError error.message = 'A magnetic valve is needed!' raise error self.TemperatureSensor = None if temperature_pin is not None: print_debug(debug, currentframe().f_code.co_name, 'Initializing temperature sensor at pin %i' % temperature_pin, __name__) self.TemperatureSensor = Temperature(self.gpio, self.__uuid, temperature_pin, name, 30, debug) # type: Temperature self.MoistureSensor = None if moisture_pin is not None: print_debug(debug, currentframe().f_code.co_name, 'Initializing moisture sensor at pin %i' % moisture_pin, __name__) self.MoistureSensor = Moisture(self.gpio, self.__uuid, moisture_pin, name, self.db_plant.get('min_moisture'), self.db_plant.get('max_moisture'), debug) # type: Moisture self.__run_count = 0 self.active = True # Run a check directly when a new instance is created self.__start_new_timer(0)
def __init__(self, pin): self.gpio = GPIO(debug=False) self.pin = pin self.gpio.pinMode(pin, self.gpio.INPUT)
from wiringx86 import GPIOGalileoGen2 as GPIO import time gpio = GPIO(debug=False) led = 13 dht11 = 8 print("Setting up Pins") gpio.pinMode(dht11, gpio.INPUT) gpio.pinMode(led, gpio.OUTPUT) data = [] for i in range(0, 500): data.append(gpio.digitalRead(dht11)) bit_count = 0 tmp = 0 count = 0 hum_bit = "" temp_bit = "" crc = "" try: while data[count] == 1: tmp = 1 count += 1 for i in range(0, 32): bit_count = 0
# This example is inspired on Arduino Analog Input example. # http://arduino.cc/en/Tutorial/AnalogInput # # This example will work "out of the box" on an Intel® Galileo Gen2 board. If # you are using a different board such as an Intel® Galileo, just change the # import below. wiringx86 uses the same API for all the boards it supports. # Import the time module enable sleeps between turning the led on and off. import time # Import the GPIOGalileoGen2 class from the wiringx86 module. from wiringx86 import GPIOGalileoGen2 as GPIO # Create a new instance of the GPIOGalileoGen2 class. # Setting debug=True gives information about the interaction with sysfs. gpio = GPIO(debug=False) pin = 13 analogpin = 14 print 'Setting up all pins...' # Set pin 14 to be used as an analog input GPIO pin. gpio.pinMode(analogpin, gpio.ANALOG_INPUT) # Set pin 13 to be used as an output GPIO pin. gpio.pinMode(pin, gpio.OUTPUT) print 'Analog reading from pin %d now...' % analogpin try: while(True): # Read the voltage on pin 14
from time import sleep import json from wiringx86 import GPIOGalileoGen2 as GPIO varSuhu = int(argv[1]) varKelembapan = int(argv[2]) varStatus=192 varReset=1 varon1=0 varon2=0 varon3=0 varon4=0 varon5=0 varon6=0 gpio = GPIO(debug=False) pin = 13 state = gpio.HIGH print 'setting up pin %d' % pin gpio.pinMode(pin,gpio.OUTPUT) gpio.pinMode(2,gpio.OUTPUT) gpio.pinMode(3,gpio.OUTPUT) gpio.pinMode(4,gpio.OUTPUT) gpio.pinMode(5,gpio.OUTPUT) gpio.pinMode(6,gpio.OUTPUT) print 'coba mengendalikan pin %d sekarang...' % pin
welcome2internet() print('cek koneksi 1') sendData2Server(APIkey, Suhu, Kelembapan, ReadON) print('cek koneksi 2') sendData2Server(APIkey, Suhu, Kelembapan, ReadON) print('cek koneksi 3') sendData2Server(APIkey, Suhu, Kelembapan, ReadON) print('cek koneksi 4') sendData2Server(APIkey, Suhu, Kelembapan, ReadON) print('cek koneksi 5') sendData2Server(APIkey, Suhu, Kelembapan, ReadON) ReadON=requestDataFromServer(APIkey,'readon') sendData2Server(APIkey, Suhu, Kelembapan, ReadON) gpio = GPIO(debug=False) gpio.pinMode(2,gpio.OUTPUT) gpio.pinMode(3,gpio.OUTPUT) gpio.pinMode(4,gpio.OUTPUT) gpio.pinMode(5,gpio.OUTPUT) gpio.pinMode(6,gpio.OUTPUT) gpio.pinMode(13,gpio.OUTPUT) #void loop() while True : sleep(2) print('??') ReadON=requestDataFromServer(APIkey,'readon') dataVar=ReadON for x in range(0,8): if x==0:
gpio40 pin8 gpio4 pin9 gpio10 pin10 gpio5 pin11 gpio15 pin12 gpio7 pin13 """ import os import os.path import time from wiringx86 import GPIOGalileoGen2 as GPIO gpio = GPIO(debug=False) from flask import Flask,url_for, render_template app = Flask(__name__) from flask import request from flask import json #Our robot mappings #For motor 1 dir1 = 5 #For motor 2 dir2 = 6 gpio.pinMode(dir1, gpio.OUTPUT) gpio.pinMode(dir2, gpio.OUTPUT)
# This example is inspired on Arduino Fade example. # http://arduino.cc/en/Tutorial/Fade # # This example will work "out of the box" on an Intel® Galileo Gen2 board. If # you are using a different board such as an Intel® Galileo, just change the # import below. wiringx86 uses the same API for all the boards it supports. # Import the time module enable sleeps between turning the led on and off. import time # Import the GPIOGalileoGen2 class from the wiringx86 module. from wiringx86 import GPIOGalileoGen2 as GPIO # Create a new instance of the GPIOGalileoGen2 class. # Setting debug=True gives information about the interaction with sysfs. gpio = GPIO(debug=False) pin = 3 brightness = 0 fadeAmount = 5 # Set pin 3 to be used as a PWM pin. print 'Setting up pin %d' % pin gpio.pinMode(pin, gpio.PWM) print 'Fading pin %d now...' % pin try: while(True): # Write brightness to the pin. The value must be between 0 and 255. gpio.analogWrite(pin, brightness) # Increment or decrement the brightness.
# # See license in LICENSE.txt file. # # This example is inspired on Arduino Button example. # http://arduino.cc/en/Tutorial/Button # # This example will work "out of the box" on an Intel® Galileo Gen2 board. If # you are using a different board such as an Intel® Galileo, just change the # import below. wiringx86 uses the same API for all the boards it supports. # Import the GPIOGalileoGen2 class from the wiringx86 module. from wiringx86 import GPIOGalileoGen2 as GPIO # Create a new instance of the GPIOGalileoGen2 class. # Setting debug=True gives information about the interaction with sysfs. gpio = GPIO(debug=False) pin = 13 button = 2 print 'Setting up pins %d and %d...' % (pin, button) # Set pin 13 to be used as an output GPIO pin. gpio.pinMode(pin, gpio.OUTPUT) # Set pin 2 to be used as an input GPIO pin. gpio.pinMode(button, gpio.INPUT) print 'Reading from pin %d now...' % button try: while(True): # Read the state of the button
import sys sys.path.append("../gpio") from wiringx86 import GPIOGalileoGen2 as GPIO import time gpio = GPIO(debug=False) user_pin = 0 internet_pin = 1 mote_pin = 2 alarm_pin = 3 presence_pin = 4 speaker_pin = 13 lm35_pin = 14 photo_pin = 16 print("Setting up all pins") gpio.pinMode(user_pin, gpio.OUTPUT) gpio.pinMode(internet_pin, gpio.OUTPUT) gpio.pinMode(mote_pin, gpio.OUTPUT) gpio.pinMode(alarm_pin, gpio.OUTPUT) gpio.pinMode(speaker_pin, gpio.OUTPUT) gpio.pinMode(presence_pin, gpio.INPUT) gpio.pinMode(lm35_pin, gpio.ANALOG_INPUT) gpio.pinMode(photo_pin, gpio.ANALOG_INPUT) while (True): print("Turning User Pin On") gpio.digitalWrite(user_pin, gpio.HIGH) time.sleep(0.2)
def __init__(self, pin, unit="c", debug=False): self.gpio = GPIO(debug=False) self.unit = unit self.pin = pin self.gpio.pinMode(self.pin, self.gpio.ANALOG_INPUT)
#!/usr/bin/python import socket, traceback import os import os.path import time import math from wiringx86 import GPIOGalileoGen2 as GPIO gpio = GPIO(debug=False) import thread #Stepper Motor Pins step = 0 direction = 1 #DC Motor Pins #For Motor 1 dir1 = 2 pwm1 = 3 brk1 = 4 #For Motor 2 dir2 = 8 pwm2 = 9 brk2 = 10 pwmvalue = 50 #Pin Mode Settings for Stepper and DC Motors
#!/usr/bin/python3 import sys sys.path.append("../gpio") import subprocess import threading import time import os from wiringx86 import GPIOGalileoGen2 as GPIO gpio = GPIO(debug=False) user_pin = 0 gpio.pinMode(user_pin, gpio.OUTPUT) class user(object): def __init__(self, path, MAC, name, last_ip="none"): self.connected = False self.scripts_path = path self.last_connected = 0 self.name = name self.mac_addr = MAC self.ip = "" self.last_ip = last_ip self.tries = 0 def validate_ip(self): valid = self.ip.split('.') if len(valid) == 4:
# This example is inspired on Arduino Analog Input example. # http://arduino.cc/en/Tutorial/AnalogInput # # This example will work "out of the box" on an Intel® Edison board. If # you are using a different board such as an Intel® Galileo Gen2, just change the # import below. wiringx86 uses the same API for all the boards it supports. # Import the time module enable sleeps between turning the led on and off. import time # Import the GPIOEdison class from the wiringx86 module. from wiringx86 import GPIOGalileoGen2 as GPIO # Create a new instance of the GPIOEdison class. # Setting debug=True gives information about the interaction with sysfs. gpio = GPIO(debug=False) analogpin = 14 print 'Setting up all pins...' # Set pin 14 to be used as an analog input GPIO pin. gpio.pinMode(analogpin, gpio.ANALOG_INPUT) # Set pin 13 to be used as an output GPIO pin. #gpio.pinMode(pin, gpio.OUTPUT) print 'Analog reading from pin %d now...' % analogpin try: while(True): # Read the voltage on pin 14 value = gpio.analogRead(analogpin)