def __init__(self): if(Ax12.port == None): #Binden der seriellen Schnittstellen Ax12.port = serial.Serial("/dev/ttyO4", baudrate=1000000, timeout=0.003) Ax12.port2 = serial.Serial("/dev/ttyO2", baudrate=1000000, timeout=0.003) if(not Ax12.gpioSet): GPIO.setwarnings(False) #GPIO.setmode(GPIO.BCM) GPIO.setup(Ax12.RPI_DIRECTION_PIN, GPIO.OUT) Ax12.gpioSet = True self.direction(Ax12.RPI_DIRECTION_RX)
import json, requests import Adafruit_BBIO.GPIO as GPIO import time from threading import Timer, Thread, Event from datetime import datetime from pytz import timezone timetoken = '0' url = 'http://pubsub.pubnub.com/subscribe/sub-c-ef558a8a-2444-11e6-be83-0619f8945a4f/smartOutlet/0/' outletPin = ['P8_11', 'P8_13', 'P8_15', 'P8_17'] GPIO.setwarnings(False) GPIO.cleanup() for i in range(0, 4): print "pin init:", i GPIO.setup(outletPin[i], GPIO.OUT) GPIO.output(outletPin[i], GPIO.LOW) time.sleep(1) GPIO.output(outletPin[i], GPIO.HIGH) class durationThread(Thread): def __init__(self, event): Thread.__init__(self) self.stopped = event def run(self): while not self.stopped.wait(1): durationOnff()
#import RPi.GPIO as GPIO import Adafruit_BBIO.GPIO as GPIO from bitstring import BitArray import logging logging.basicConfig() GPIO.setwarnings(False) class adg5409: def __init__(self): self.logger = logging.getLogger("AD5409") self.logger.setLevel(logging.INFO) self.A0 = "P8_17" self.A1 = "P8_18" self.setup_pins() def setup_pins(self): #GPIO.setmode(GPIO.BCM) #use BCM numbering from breakout board GPIO.setup(self.A0, GPIO.OUT) GPIO.setup(self.A1, GPIO.OUT) def set_mux(self,value): if value < 0 or value > 3: self.logger.error("Mux has to be between 0 and 3") return -1 tmp_bit = BitArray(2)
def raw_distance(self, sample_size=11, sample_wait=0.2): """Return an error corrected unrounded distance, in cm, of an object adjusted for temperature in Celcius. The distance calculated is the median value of a sample of `sample_size` readings. Speed of readings is a result of two variables. The sample_size per reading and the sample_wait (interval between individual samples). Example: To use a sample size of 5 instead of 11 will increase the speed of your reading but could increase variance in readings; value = sensor.Measurement(trig_pin, echo_pin) r = value.raw_distance(sample_size=5) Adjusting the interval between individual samples can also increase the speed of the reading. Increasing the speed will also increase CPU usage. Setting it too low will cause errors. A default of sample_wait=0.1 is a good balance between speed and minimizing CPU usage. It is also a safe setting that should not cause errors. e.g. r = value.raw_distance(sample_wait=0.03) """ if self.unit == "imperial": self.temperature = (self.temperature - 32) * 0.5556 elif self.unit == "metric": pass else: raise ValueError( "Wrong Unit Type. Unit Must be imperial or metric") speed_of_sound = 343 * math.sqrt(1 + (self.temperature / 273.15)) sample = [] # setup input/output pins GPIO.setwarnings(False) #GPIO.setmode(self.gpio_mode) GPIO.setup(self.trig_pin, GPIO.OUT) GPIO.setup(self.echo_pin, GPIO.IN) for distance_reading in range(sample_size): GPIO.output(self.trig_pin, GPIO.LOW) time.sleep(sample_wait) GPIO.output(self.trig_pin, True) time.sleep(0.00001) GPIO.output(self.trig_pin, False) echo_status_counter = 1 while GPIO.input(self.echo_pin) == 0: if echo_status_counter < 1000: sonar_signal_off = time.time() echo_status_counter += 1 else: raise SystemError("Echo pulse was not received") while GPIO.input(self.echo_pin) == 1: sonar_signal_on = time.time() time_passed = sonar_signal_on - sonar_signal_off distance_cm = time_passed * ((speed_of_sound * 100) / 2) sample.append(distance_cm) sorted_sample = sorted(sample) # Only cleanup the pins used to prevent clobbering # any others in use by the program GPIO.cleanup((self.trig_pin, self.echo_pin)) return sorted_sample[sample_size // 2]
def signal_handler(sig, frame): gpio.cleanup() exit(0) signal.signal(signal.SIGINT, signal_handler) left = "P9_11" right = "P9_12" all_pins = [left, right] print(all_pins) gpio.cleanup() gpio.setwarnings(1) for pin in all_pins: gpio.setup(pin, gpio.OUT) while True: print("LOW") gpio.output(left, gpio.LOW) gpio.output(right, gpio.LOW) raw_input("Press Enter to continue...") print("LEFT") gpio.output(left, gpio.HIGH) gpio.output(right, gpio.LOW)
def init(self): """ Preform the hardware initialization sequence """ # Interface initialization: GPIO.setwarnings(False) GPIO.setup(RST_PIN, GPIO.OUT) GPIO.setup(DC_PIN, GPIO.OUT) GPIO.setup(CS_PIN, GPIO.OUT) GPIO.setup(BUSY_PIN, GPIO.IN) self.spi.msh = 2000000 self.spi.mode = 0b00 # EPD hardware init # The specifics of how this works or what "power optimization" actually means # are unclear to me, so I'm leaving it as-is. self.reset() self.send_command(POWER_SETTING) self.send_data(0x03) # VDS_EN, VDG_EN self.send_data(0x00) # VCOM_HV, VGHL_LV[1], VGHL_LV[0] self.send_data(0x2b) # VDH self.send_data(0x2b) # VDL self.send_data(0x09) # VDHR self.send_command(BOOSTER_SOFT_START) self.send_data(0x07) self.send_data(0x07) self.send_data(0x17) # Power optimization self.send_command(0xF8) self.send_data(0x60) self.send_data(0xA5) # Power optimization self.send_command(0xF8) self.send_data(0x89) self.send_data(0xA5) # Power optimization self.send_command(0xF8) self.send_data(0x90) self.send_data(0x00) # Power optimization self.send_command(0xF8) self.send_data(0x93) self.send_data(0x2A) # Power optimization self.send_command(0xF8) self.send_data(0xA0) self.send_data(0xA5) # Power optimization self.send_command(0xF8) self.send_data(0xA1) self.send_data(0x00) # Power optimization self.send_command(0xF8) self.send_data(0x73) self.send_data(0x41) self.send_command(PARTIAL_DISPLAY_REFRESH) self.send_data(0x00) self.send_command(POWER_ON) self.wait_until_idle() self.send_command(PANEL_SETTING) self.send_data(0xAF) # KW-BF KWR-AF BWROTP 0f self.send_command(PLL_CONTROL) self.send_data(0x3A) # 3A 100HZ 29 150Hz 39 200HZ 31 171HZ self.send_command(VCM_DC_SETTING_REGISTER) self.send_data(0x12) self.delay_ms(2) self.set_lut() # EPD hardware init end self._init_performed = True
class ADS80422: GPIO.setwarnings(False) pin_anem = 0 pin_dir = 0 pin_rain = 0 _currentRainCount = 0 _currentWindCount = 0 _currentWindSpeed = 0.0 _currentWindDirection = 0.0 _lastWindTime = 0 _lastRainTime = 0 _shortestWindTime = 0 _currentRainMin = 0 _sampleTime = 5.0 _selectedMode = ASYNC_MODE _startSampleTime = 0 def __init__(self, pin_anem, pin_dir, pin_rain): self._logger = logging.getLogger('ADS80422.ADS80422') ADS80422.pin_anem = pin_anem ADS80422.pin_dir = pin_dir ADS80422.pin_rain = pin_rain GPIO.setup(pin_anem, GPIO.IN) GPIO.setup(pin_rain, GPIO.IN) # when a falling edge is detected on port pinAnem, regardless of whatever # else is happening in the program, the function callback will be run GPIO.add_event_detect(ADS80422.pin_anem, GPIO.RISING, callback=self._service_interrupt_anemometer, bouncetime=20) GPIO.add_event_detect(ADS80422.pin_rain, GPIO.RISING, callback=self._service_interrupt_rain, bouncetime=20) ADC.setup() def voltage_to_degrees(self, value, default_wind_direction): if fuzzy_compare(1.38, value): return 0.0 if fuzzy_compare(0.71, value): return 22.5 if fuzzy_compare(0.81, value): return 45 if fuzzy_compare(0.15, value): return 67.5 if fuzzy_compare(0.16, value): return 90.0 if fuzzy_compare(0.12, value): return 112.5 if fuzzy_compare(0.32, value): return 135.0 if fuzzy_compare(0.22, value): return 157.5 if fuzzy_compare(0.51, value): return 180 if fuzzy_compare(0.43, value): return 202.5 if fuzzy_compare(1.11, value): return 225 if fuzzy_compare(1.05, value): return 247.5 if fuzzy_compare(1.66, value): return 270.0 if fuzzy_compare(1.45, value): return 292.5 if fuzzy_compare(1.56, value): return 315.0 if fuzzy_compare(1.24, value): return 337.5 return default_wind_direction # ### Wind Direction Section ### def get_wind_direction(self): value = ADC.read(ADS80422.pin_dir) voltage_value = value * 1.8000 direction = self.voltage_to_degrees(voltage_value, ADS80422._currentWindDirection) self._logger.debug('Current wind direction {0:.2f})'.format(direction)) return direction def get_wind_direction_voltage(self): value = ADC.read(ADS80422.pin_dir) voltage_value = value * 1.8000 self._logger.debug( 'Current wind direction voltage {0:.3f})'.format(voltage_value)) return voltage_value # def accessInternalCurrentWindDirection(self): # return SDL_Pi_Weather_80422._currentWindDirection; # ### Wind Speed Section ### def set_acquisition_mode(self, selected_mode, sample_time): ADS80422._sampleTime = sample_time ADS80422._selectedMode = selected_mode if ADS80422._selectedMode == ASYNC_MODE: self._start_wind_sample(ADS80422._sampleTime) def _start_wind_sample(self, sample_time): ADS80422._startSampleTime = micros() ADS80422._sampleTime = sample_time def _get_wind_speed_when_sampling(self): compare_value = ADS80422._sampleTime * 1000000 if (micros() - ADS80422._startSampleTime) >= compare_value: # sample time exceeded, calculate currentWindSpeed time_span = micros() - ADS80422._startSampleTime ADS80422._currentWindSpeed = ( float(ADS80422._currentWindCount) / float(time_span)) * WIND_FACTOR * 1000000.0 ADS80422._currentWindCount = 0 ADS80422._startSampleTime = micros() return ADS80422._currentWindSpeed def get_wind_speed(self): if ADS80422._selectedMode == ASYNC_MODE: ADS80422._currentWindSpeed = self._get_wind_speed_when_sampling() else: # km/h * 1000 msec ADS80422._currentWindCount = 0 # delay(ADS80422._sampleTime*1000) ADS80422._currentWindSpeed = ( float(ADS80422._currentWindCount) / float(ADS80422._sampleTime)) * WIND_FACTOR return ADS80422._currentWindSpeed def get_wind_gust(self): latest_time = ADS80422._shortestWindTime / 1000000.0 ADS80422._shortestWindTime = 0xffffffff if latest_time == 0: return 0 else: return (1.0 / float(latest_time)) * WIND_FACTOR def reset_wind_gust(self): ADS80422._shortestWindTime = 0xffffffff # ### Rain Section ### def get_rain_total(self): # mm of rain - we get two interrupts per bucket rain_amount = 0.2794 * float(ADS80422._currentRainCount) ADS80422._currentRainCount = 0 return rain_amount def reset_rain_total(self): ADS80422._currentRainCount = 0 def _service_interrupt_anemometer(self, channel): self._logger.debug( 'Service Interrupt Anenmometer: {0:s})'.format(channel)) current_time = micros() - ADS80422._lastWindTime ADS80422._lastWindTime = micros() if current_time > 1000: ADS80422._currentWindCount += 1 if current_time < ADS80422._shortestWindTime: ADS80422._shortestWindTime = current_time def _service_interrupt_rain(self, channel): self._logger.debug('Service Interrupt Rain: {0:s})'.format(channel)) current_time = micros() - ADS80422._lastRainTime ADS80422._lastRainTime = micros() if current_time > 500: ADS80422._currentRainCount += 1 if current_time < ADS80422._currentRainMin: ADS80422._currentRainMin = current_time