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
