def __init__(self):
self.con = IPConnection()
self.master = Master(self.uid_master, self.con)
self.motion = MotionDetector(self.uid_motion, self.con)
self.poti_left = RotaryPoti(self.uid_poti_left, self.con)
self.poti_right = RotaryPoti(self.uid_poti_right, self.con)
self.io = IO4(self.uid_io, self.con)
print "---" + str(15^15)
print "---" + str(15^14)
def cb_enumerate(self, uid, connected_uid, position, hardware_version,
firmware_version, device_identifier, enumeration_type):
if enumeration_type == IPConnection.ENUMERATION_TYPE_CONNECTED or \
enumeration_type == IPConnection.ENUMERATION_TYPE_AVAILABLE:
self.log("cb_enumerate() id {} - Found device: ident={}, position={}".format(uid, device_identifier, position))
if device_identifier == IO4.DEVICE_IDENTIFIER:
self.log("cb_enumerate() id {} - Creating IO4 device object".format(uid))
self.io = IO4(uid, self.con)
self.io.set_debounce_period(1000)
if position == 'a':
self.log("cb_enumerate() id {} - Configuring IO4 device object at position a (switches).".format(uid))
self.io.register_callback(self.io.CALLBACK_INTERRUPT, self.io_switch)
self.io.set_configuration(15, 'i', True)
# Enable interrupt on pin 0 and 1
self.io.set_interrupt(1 << 0)
self.io.set_interrupt(1 << 1)
self.set_ziel_geschlecht(self.io.get_value())
else:
self.log("cb_enumerate() id {} - Configuring IO4 device object at position ? (lights, shutdown).".format(uid))
self.io.set_configuration((1 << 0) | (1 << 1), "o", True)
elif device_identifier == RotaryPoti.DEVICE_IDENTIFIER:
self.log("cb_enumerate() id {} - Creating RotaryPoti device object".format(uid))
self.poti_volume = RotaryPoti(uid, self.con)
self.poti_volume.set_position_callback_period(100)
self.poti_volume.register_callback(self.poti_volume.CALLBACK_POSITION, self.poti_volume_changed)
elif device_identifier == Master.DEVICE_IDENTIFIER:
self.log("cb_enumerate() id {} - Creating Master device object".format(uid))
self.master = Master(uid, self.con)
else:
self.log("cb_enumerate() id {} - Could not register unknown device bricklet".format(uid))
class emulate:
def poti_cb(self,position):
print(str(position))
self.device.emit(uinput.ABS_Z, position) #Setzt den Wert des Joysticks auf den Wert des Potis
def __init__(self):
#uinput Bereich
self.events = (
uinput.BTN_A, #Es wird mindestens ein Button benötigt (seltsam)
uinput.ABS_Z + (-150, 150, 0, 0), #Erstellt Joystick Achse Z, kleinster Wert des Potis ist -150, größter Wert ist +150
)
self.device = uinput.Device(self.events, "TF Virutal HID Joystick")
#TinkerForge Bereich
ipcon = IPConnection()
self.poti = RotaryPoti("aBQ", ipcon) #UID ändern!
ipcon.connect("127.0.0.1", 4223) #IP / Port anpassen
self.poti.set_position_callback_period(50)
self.poti.register_callback(self.poti.CALLBACK_POSITION, self.poti_cb) #Sobald der Callback auslöst wird die Funktion poti_cb aufgerufen
def cb_enumerate(self, uid, connected_uid, position, hardware_version, firmware_version, device_identifier, enumeration_type):
if enumeration_type == IPConnection.ENUMERATION_TYPE_CONNECTED or enumeration_type == IPConnection.ENUMERATION_TYPE_AVAILABLE:
if device_identifier == LEDStrip.DEVICE_IDENTIFIER and uid == self.UID_LED_STRIP_ONE: #LED-Strip 1
try:
self.led_strip_1 = LEDStrip(uid, self.ipcon)
log.info('LED-Strip 1 initialized.')
except Error as e:
log.error('LED-Strip 1 init failed: ' + str(e.description))
self.led_strip_1 = None
elif device_identifier == LEDStrip.DEVICE_IDENTIFIER and uid == self.UID_LED_STRIP_TWO: #LED-Strip 2
try:
self.led_strip_2 = LEDStrip(uid, self.ipcon)
log.info('LED-Strip 2 initialized.')
except Error as e:
log.error('LED-Strip 2 init failed: ' + str(e.description))
self.led_strip_2 = None
elif device_identifier == MultiTouch.DEVICE_IDENTIFIER: # MulitTouch for changing colors etc.
try:
self.multi_touch = MultiTouch(uid, self.ipcon)
self.multi_touch.register_callback(self.multi_touch.CALLBACK_TOUCH_STATE, self.cb_buttons)
self.multi_touch.set_electrode_config(0x0FFF)
self.multi_touch.recalibrate()
log.info('Set proximity off.')
log.info('Multi-Touch initialized.')
except Error as e:
log.error('Multi-Touch init failed: ' + str(e.description))
self.multi_touch = None
elif device_identifier == RotaryPoti.DEVICE_IDENTIFIER: # Rotary Poti for picking a color or changing the saturation
try:
self.rotary_poti = RotaryPoti(uid, self.ipcon)
self.rotary_poti.register_callback(self.rotary_poti.CALLBACK_POSITION, self.cb_position)
self.rotary_poti.set_position_callback_period(50)
log.info('Rotary Poti initialized.')
except Error as e:
log.error('Rotary Poti init failed: ' + str(e.description))
self.rotary_poti = None
# -*- coding: utf-8 -*-
HOST = "localhost"
PORT = 4223
UID = "2wx" # Change to your UID
from tinkerforge.ip_connection import IPConnection
from tinkerforge.bricklet_rotary_poti import RotaryPoti
# Callback function for position callback (parameter has range -150 to 150)
def cb_position(position):
print('Position: ' + str(position))
if __name__ == "__main__":
ipcon = IPConnection() # Create IP connection
poti = RotaryPoti(UID, ipcon) # Create device object
ipcon.connect(HOST, PORT) # Connect to brickd
# Don't use device before ipcon is connected
# Set Period for position callback to 0.05s (50ms)
# Note: The position callback is only called every 50ms if the
# position has changed since the last call!
poti.set_position_callback_period(50)
# Register position callback to function cb_position
poti.register_callback(poti.CALLBACK_POSITION, cb_position)
raw_input('Press key to exit\n') # Use input() in Python 3
ipcon.disconnect()
from tinkerforge.brick_dc import DC
from tinkerforge.bricklet_rotary_poti import RotaryPoti
dc = None
# Callback function for position callback (parameter has range -150 to 150)
def cb_position(position):
velocity = 0xFFFF / 2 * position / 150 # Velocity: -32767/32767
print('Set Position/Velocity: ' + str(position) + '/' + str(velocity))
dc.set_velocity(velocity)
if __name__ == "__main__":
ipcon = IPConnection() # Create IP connection
dc = DC(UID_DC, ipcon) # Create DC brick device object
poti = RotaryPoti(UID_POTI, ipcon) # Create rotary poti device object
ipcon.connect(HOST, PORT) # Connect to brickd
poti.set_position_callback_period(50) # set callback period to 50ms
poti.register_callback(poti.CALLBACK_POSITION, cb_position)
dc.enable()
dc.set_acceleration(0xFFFF) # Full acceleration
raw_input('Press Enter to exit\n') # Use input() in Python 3
dc.disable()
ipcon.disconnect()
class PiTinkerforgeStack:
host = '192.168.178.27' #raspi
#host = '127.0.0.1' #localhost
port = 4223
uid_master = '6JKxCC'
uid_motion = 'oRL'
uid_poti_left = 'ejC'
uid_poti_right = 'ejm'
uid_io = 'hcs'
female = False
def __init__(self):
self.con = IPConnection()
self.master = Master(self.uid_master, self.con)
self.motion = MotionDetector(self.uid_motion, self.con)
self.poti_left = RotaryPoti(self.uid_poti_left, self.con)
self.poti_right = RotaryPoti(self.uid_poti_right, self.con)
self.io = IO4(self.uid_io, self.con)
print "---" + str(15^15)
print "---" + str(15^14)
def connect(self):
print "Connecting to host " + self.host + " on port " + str(self.port)
self.con.connect(self.host, self.port)
self.set_ziel_geschlecht(self.io.get_value())
def disconnect(self):
print "Disconnecting from host " + self.host
self.con.disconnect()
def motion_detected(self):
print "CALLBACK!!"
self.insult()
def insult(self):
ziel_geschlecht = "m"
if self.female:
ziel_geschlecht = "f"
speak_next_insult(ziel_geschlecht, self.poti_left.get_position(), self.poti_right.get_position())
def motion_cycle_ended(self):
print "READY for motion detection!"
def io_switch(self, interrupt_mask, value_mask):
print "IO4 triggered"
print('Interrupt by: ' + str(bin(interrupt_mask)))
print('Value: ' + str(bin(value_mask)))
#print('Val1: ' + str(value_mask))
if interrupt_mask == 1:
print "Sex switched..."
# button 1 switched
self.set_ziel_geschlecht(value_mask)
elif interrupt_mask == 2:
print "Insult button pressed..."
button_up = value_mask&2
print "value_mask =" + str(button_up)
if button_up == 2:
self.insult()
print "io_switch() end"
def set_ziel_geschlecht(self, value_mask):
is_on = value_mask^14
if is_on:
print "MALE"
self.female = False
else:
print "FEMALE"
self.female = True
def register_callbacks(self):
print "Registering callback to motion detector..."
#self.motion.register_callback(self.motion.CALLBACK_MOTION_DETECTED, self.motion_detected)
self.motion.register_callback(self.motion.CALLBACK_DETECTION_CYCLE_ENDED, self.motion_cycle_ended)
self.io.set_debounce_period(1000)
self.io.register_callback(self.io.CALLBACK_INTERRUPT, self.io_switch)
# Enable interrupt on pin 0
self.io.set_interrupt((1 << 0) | (1 << 1))
#self.io.set_interrupt(1 << 1)
print "register done"
#!/usr/bin/env python
# -*- coding: utf-8 -*-
HOST = "localhost"
PORT = 4223
UID = "2wx" # Change to your UID
from tinkerforge.ip_connection import IPConnection
from tinkerforge.bricklet_rotary_poti import RotaryPoti
if __name__ == "__main__":
ipcon = IPConnection() # Create IP connection
poti = RotaryPoti(UID, ipcon) # Create device object
ipcon.connect(HOST, PORT) # Connect to brickd
# Don't use device before ipcon is connected
# Get current position of poti (return value has range -150 to 150)
position = poti.get_position()
print('Position: ' + str(position))
raw_input('Press key to exit\n') # Use input() in Python 3
ipcon.disconnect()
class PiTinkerforgeStack:
#host = '192.168.178.36' #raspi
#host = '127.0.0.1' #localhost
host = 'brickd'
port = 4223
female = False
io = None
poti_left = None
poti_volume = None
master = None
def __init__(self):
syslog.openlog('insultr-tf', 0, syslog.LOG_LOCAL4)
self.con = IPConnection()
# Register IP Connection callbacks
self.con.register_callback(IPConnection.CALLBACK_ENUMERATE,
self.cb_enumerate)
self.con.register_callback(IPConnection.CALLBACK_CONNECTED,
self.cb_connected)
self.insultr = Insultr()
self.set_volume(50)
self.log("---" + str(15^15))
self.log("---" + str(15^14))
def log(self, msg):
syslog.syslog(msg)
print msg
def connect(self):
self.log("Connecting to host " + self.host + " on port " + str(self.port))
self.con.connect(self.host, self.port)
self.con.enumerate()
def disconnect(self):
self.log("Disconnecting from host " + self.host)
self.con.disconnect()
# Callback handles device connections and configures possibly lost
# configuration of lcd and temperature callbacks, backlight etc.
def cb_enumerate(self, uid, connected_uid, position, hardware_version,
firmware_version, device_identifier, enumeration_type):
if enumeration_type == IPConnection.ENUMERATION_TYPE_CONNECTED or \
enumeration_type == IPConnection.ENUMERATION_TYPE_AVAILABLE:
self.log("cb_enumerate() id {} - Found device: ident={}, position={}".format(uid, device_identifier, position))
if device_identifier == IO4.DEVICE_IDENTIFIER:
self.log("cb_enumerate() id {} - Creating IO4 device object".format(uid))
self.io = IO4(uid, self.con)
self.io.set_debounce_period(1000)
if position == 'a':
self.log("cb_enumerate() id {} - Configuring IO4 device object at position a (switches).".format(uid))
self.io.register_callback(self.io.CALLBACK_INTERRUPT, self.io_switch)
self.io.set_configuration(15, 'i', True)
# Enable interrupt on pin 0 and 1
self.io.set_interrupt(1 << 0)
self.io.set_interrupt(1 << 1)
self.set_ziel_geschlecht(self.io.get_value())
else:
self.log("cb_enumerate() id {} - Configuring IO4 device object at position ? (lights, shutdown).".format(uid))
self.io.set_configuration((1 << 0) | (1 << 1), "o", True)
elif device_identifier == RotaryPoti.DEVICE_IDENTIFIER:
self.log("cb_enumerate() id {} - Creating RotaryPoti device object".format(uid))
self.poti_volume = RotaryPoti(uid, self.con)
self.poti_volume.set_position_callback_period(100)
self.poti_volume.register_callback(self.poti_volume.CALLBACK_POSITION, self.poti_volume_changed)
elif device_identifier == Master.DEVICE_IDENTIFIER:
self.log("cb_enumerate() id {} - Creating Master device object".format(uid))
self.master = Master(uid, self.con)
else:
self.log("cb_enumerate() id {} - Could not register unknown device bricklet".format(uid))
# Callback handles reconnection of IP Connection
def cb_connected(self, connected_reason):
# Enumerate devices again. If we reconnected, the Bricks/Bricklets
# may have been offline and the configuration may be lost.
# In this case we don't care for the reason of the connection
self.con.enumerate()
def motion_detected(self):
self.log("CALLBACK!!")
self.insult()
def insult(self):
self.insultr.speak_next_insult()
def set_volume(self, volume_percent=50):
set_volume_cmd = 'amixer sset Master {}%'.format(volume_percent)
self.log("set_volume() Setting volume with command: " + set_volume_cmd)
os.system(set_volume_cmd)
def set_volume_from_poti(self):
if self.poti_volume:
position = self.poti_volume.get_position()
self.poti_volume_changed(position)
else:
self.set_volume(50)
def poti_volume_changed(self, position=0):
self.log("poti_volume_changed() poti was set to position {}".format(position))
if position > 150:
position = 150
if position < -150:
position = -150
MIN_VOLUME = 25.0
MAX_VOLUME = 90.0
poti_percent = ((position + 150.0) / 300.0) # between 0.0 and 1.0
volume_percent = MIN_VOLUME + ((MAX_VOLUME-MIN_VOLUME)*poti_percent)
self.set_volume(volume_percent)
def motion_cycle_ended(self):
self.log("READY for motion detection!")
def io_switch(self, interrupt_mask, value_mask):
self.log("io_switch() IO4 triggered")
self.log("io_switch() Interrupt by {} / {} ".format(str(bin(interrupt_mask)), interrupt_mask))
self.log('io_switch() Value: ' + str(bin(value_mask)))
try:
self.set_volume_from_poti()
if interrupt_mask == 1:
self.log("io_switch() Sex switched...")
# button 1 switched
self.set_ziel_geschlecht(value_mask)
elif interrupt_mask == 2:
self.log("io_switch() Insult button pressed...")
button_up = value_mask&2
self.log("io_switch() value_mask =" + str(button_up))
if button_up == 2:
self.insult()
else:
self.log("io_switch() Don't know what to do with interrupt_mask {}".format(interrupt_mask))
except Error as e:
self.log("io_switch() ERROR:{}".format(e))
self.log("io_switch() end")
def set_ziel_geschlecht(self, value_mask):
is_on = value_mask^14
if is_on:
self.log("sex was set to MALE")
self.female = False
self.insultr.set_maennlich()
self.io.set_configuration(1 << 0, "o", True)
self.io.set_configuration(1 << 1, "o", False)
else:
self.log("sex was set to FEMALE")
self.female = True
self.insultr.set_weiblich()
self.io.set_configuration(1 << 0, "o", False)
self.io.set_configuration(1 << 1, "o", True)
def register_callbacks(self):
self.log("Registering callback to motion detector...")
self.motion.register_callback(self.motion.CALLBACK_MOTION_DETECTED, self.motion_detected)
self.motion.register_callback(self.motion.CALLBACK_DETECTION_CYCLE_ENDED, self.motion_cycle_ended)
self.io.set_debounce_period(1000)
self.io.register_callback(self.io.CALLBACK_INTERRUPT, self.io_switch)
# Enable interrupt on pin 0
self.io.set_interrupt((1 << 0) | (1 << 1))
#self.io.set_interrupt(1 << 1)
self.log("register done")
class led_strips:
HOST = "localhost"
PORT = 4223
UID_LED_STRIP_ONE = "jGy"
UID_LED_STRIP_TWO = "jHE"
MODE = 0
MODE_HUE = 1
MODE_SATURATION = 2
MODE_VALUE = 3
MODE_VELOCITY = 4
MODE_COLOR_GRADIENT = 5
MODE_COLOR_DOT = 6
MODE_COLOR_FADING = 7
MODE_COLOR_RANDOMLY = 8
MODE_LEDS = 9
MODE_OFF = 10
MODE_STRIPS = 0
MODE_LEFT_STRIP = 1
MODE_RIGHT_STRIP = 2
MODE_BOTH_STRIPS = 3
POSITION_HUE = 1
POSITION_SATURATION = 1
POSITION_VALUE = 0.3
POSITION_VELOCITY = 1
R = [255]*16
G = [0]*16
B = [0]*16
MAX_LEDS = 16
ACTIVE_LEDS = 16
ipcon = None
led_strip_1 = None
led_strip_2 = None
multi_touch = None
rotary_poti = None
def __init__(self):
# Create IP Connection
self.ipcon = IPConnection()
while True:
try:
self.ipcon.connect(led_strips.HOST, led_strips.PORT)
break
except Error as e:
log.error('Connection error: ' + str(e.description))
time.sleep(1)
except socket.error as e:
log.error('Socket error: ' + str(e))
time.sleep(1)
# Register IP Connection callbacks
self.ipcon.register_callback(IPConnection.CALLBACK_ENUMERATE, self.cb_enumerate)
self.ipcon.register_callback(IPConnection.CALLBACK_CONNECTED, self.cb_connected)
while True:
try:
self.ipcon.enumerate()
break
except Error as e:
log.error('Enumerate error: ' + str(e.description))
time.sleep(1)
# Callback handels device connections and configures possibly lost configuration
def cb_enumerate(self, uid, connected_uid, position, hardware_version, firmware_version, device_identifier, enumeration_type):
if enumeration_type == IPConnection.ENUMERATION_TYPE_CONNECTED or enumeration_type == IPConnection.ENUMERATION_TYPE_AVAILABLE:
if device_identifier == LEDStrip.DEVICE_IDENTIFIER and uid == self.UID_LED_STRIP_ONE: #LED-Strip 1
try:
self.led_strip_1 = LEDStrip(uid, self.ipcon)
log.info('LED-Strip 1 initialized.')
except Error as e:
log.error('LED-Strip 1 init failed: ' + str(e.description))
self.led_strip_1 = None
elif device_identifier == LEDStrip.DEVICE_IDENTIFIER and uid == self.UID_LED_STRIP_TWO: #LED-Strip 2
try:
self.led_strip_2 = LEDStrip(uid, self.ipcon)
log.info('LED-Strip 2 initialized.')
except Error as e:
log.error('LED-Strip 2 init failed: ' + str(e.description))
self.led_strip_2 = None
elif device_identifier == MultiTouch.DEVICE_IDENTIFIER: # MulitTouch for changing colors etc.
try:
self.multi_touch = MultiTouch(uid, self.ipcon)
self.multi_touch.register_callback(self.multi_touch.CALLBACK_TOUCH_STATE, self.cb_buttons)
self.multi_touch.set_electrode_config(0x0FFF)
self.multi_touch.recalibrate()
log.info('Set proximity off.')
log.info('Multi-Touch initialized.')
except Error as e:
log.error('Multi-Touch init failed: ' + str(e.description))
self.multi_touch = None
elif device_identifier == RotaryPoti.DEVICE_IDENTIFIER: # Rotary Poti for picking a color or changing the saturation
try:
self.rotary_poti = RotaryPoti(uid, self.ipcon)
self.rotary_poti.register_callback(self.rotary_poti.CALLBACK_POSITION, self.cb_position)
self.rotary_poti.set_position_callback_period(50)
log.info('Rotary Poti initialized.')
except Error as e:
log.error('Rotary Poti init failed: ' + str(e.description))
self.rotary_poti = None
# Callback handels reconnection of IP Connection
def cb_connected(self, connected_reason):
if connected_reason == IPConnection.CONNECT_REASON_AUTO_RECONNECT:
log.info('Auto reconnect.')
while True:
try:
self.ipcon.enumerate()
break
except Error as e:
log.error('Enumerate error:' + str(e.description))
time.sleep(1)
# Check which mode is set: the left LED strip, the right LED strip or both LED strips
def set_mode(self, mode, i, leds, r, b, g):
if self.MODE_STRIPS == self.MODE_BOTH_STRIPS:
self.led_strip_1.set_rgb_values(i, leds, r, b, g)
self.led_strip_2.set_rgb_values(i, leds, r, b, g)
elif self.MODE_STRIPS == self.MODE_LEFT_STRIP:
self.led_strip_1.set_rgb_values(i, leds, r, b, g)
elif self.MODE_STRIPS == self.MODE_RIGHT_STRIP:
self.led_strip_2.set_rgb_values(i, leds, r, b, g)
# Turn off the LED strips depending on the given mode
def leds_off(self):
r = [0]*self.MAX_LEDS
g = [0]*self.MAX_LEDS
b = [0]*self.MAX_LEDS
self.set_mode(self.MODE_STRIPS, 0, self.MAX_LEDS, r, b, g)
# Some simple color functions to turn the strips to red, green or blue
def led_strips_red(self):
r = [255]*self.MAX_LEDS
g = [0]*self.MAX_LEDS
b = [0]*self.MAX_LEDS
self.set_mode(self.MODE_STRIPS, 0, self.MAX_LEDS, r, b, g)
def led_strips_green(self):
r = [0]*self.MAX_LEDS
g = [255]*self.MAX_LEDS
b = [0]*self.MAX_LEDS
self.set_mode(self.MODE_STRIPS, 0, self.MAX_LEDS, r, b, g)
def led_strips_blue(self):
r = [0]*self.MAX_LEDS
g = [0]*self.MAX_LEDS
b = [255]*self.MAX_LEDS
self.set_mode(self.MODE_STRIPS, 0, self.MAX_LEDS, r, b, g)
# Match the hue (color) to the position by the rotary poti.
def set_hue(self, position):
# The position returned by the rotary poti (o to +300) must be mapped to 0°-360° in the HSV colorspace
hue = ((position / 360) * 432)
# Convert the HSV color (hue,saturation,value) to the RGB color
# The function expects hue to be in the range 0-1 not 0-360
r, g, b = colorsys.hsv_to_rgb(hue/360, self.POSITION_SATURATION, self.POSITION_VALUE)
#print('Hue: {0:.1f}'.format(hue),'Saturation: {0:.2f}'.format(self.POSITION_SATURATION),'Value: {0:.2f}'.format(self.POSITION_VALUE))
# Build the LED strip
self.build_led_strip(r, g, b)
# Save the value in the variable
self.POSITION_HUE = hue/360
# Match the saturation to the position by the rotary poti.
def set_saturation(self, position):
# The position returned by the rotary poti must be mapped to 0-1 in the HSV colorspace
saturation = (position / 300)
# Convert the HSV color (hue,saturation,value) to the RGB color
r, g, b = colorsys.hsv_to_rgb(self.POSITION_HUE, saturation, self.POSITION_VALUE)
#print('Hue: {0:.1f}'.format(self.POSITION_HUE*360),'Saturation: {0:.2f}'.format(saturation),'Value: {0:.2f}'.format(self.POSITION_VALUE))
# Build the LED strip
self.build_led_strip(r, g, b)
# Save the value in the variable
self.POSITION_SATURATION = saturation
# Match the value to the position by the rotary poti.
def set_value(self, position):
# The position returned by the rotary poti must be mapped to 0-1 in the HSV colorspace
value = (position / 300)
# Convert the HSV color (hue,saturation,value) to the RGB color
r, g, b = colorsys.hsv_to_rgb(self.POSITION_HUE, self.POSITION_SATURATION, value)
#print('Hue: {0:.1f}'.format(self.POSITION_HUE*360),'Saturation: {0:.2f}'.format(self.POSITION_SATURATION),'Value: {0:.2f}'.format(value))
# Build the LED strip
self.build_led_strip(r, g, b)
# Save the value in the variable
self.POSITION_VALUE = value
# NOT USED AT THE MOMENT
# The veolcity for some functions can be adjusted by the rotary poti.
def set_velocity(self, position):
velocity = (position / 3)
#print('Velocity: {0:0.1f}'.format(velocity))
# Save the velocity in the variable
self.POSITION_VELOCITY = velocity
# Function to generate a rainbow gradient. Can be adjusted by the velocity.
def set_color_gradient(self, position):
# use all LEDs for the gradient
active_leds = self.MAX_LEDS
loop_counter = 0
r = []
g = []
b = []
for led in list(range(active_leds)):
rv, gv, bv = colorsys.hsv_to_rgb(1.*led/active_leds, self.POSITION_SATURATION, self.POSITION_VALUE)
r.append(int(rv*255))
g.append(int(gv*255))
b.append(int(bv*255))
for leds in range(active_leds):
#print("Loop counter: " + str(loop_counter))
first_red = r.pop(0)
r.append(first_red)
first_green = g.pop(0)
g.append(first_green)
first_blue = b.pop(0)
b.append(first_blue)
#print('R: ' + str(r) + '\n','G: ' + str(g) + '\n','B: ' + str(b) + '\n')
self.set_mode(self.MODE, 0, self.MAX_LEDS, r, b, g)
loop_counter = loop_counter + 1
time.sleep(0.075)
# Fade and change the color for the whole strip
def set_color_gradient_fading(self):
# Outer loop for changing the color
for hue in range(0, 360, 30):
hue = (hue / 360)
#print("Hue: " + str(hue))
# Inner loop for fading the actual color
for value in range(1, 21):
value = value / 20
#print("Value: " + str(value))
r, g, b = colorsys.hsv_to_rgb(hue, self.POSITION_SATURATION, value)
self.build_led_strip(r, g, b)
time.sleep(0.075)
for value in reversed(range(1, 21)):
value = value / 20
#print("Value: " + str(value))
r, g, b = colorsys.hsv_to_rgb(hue, self.POSITION_SATURATION, value)
self.build_led_strip(r, g, b)
time.sleep(0.075)
# The LEDs are fading from 0.1 to 1.0 in the value space. The fading can be adjusted by the velocity.
def set_color_fading(self, position):
loop_counter = 0
while loop_counter < 5:
#print("Loop counter: " + str(loop_counter))
for value in range(1, 21):
value = value / 20
#print("Value: " + str(value))
r, g, b = colorsys.hsv_to_rgb(self.POSITION_HUE, self.POSITION_SATURATION, value)
self.build_led_strip(r, g, b)
time.sleep(0.075)
for value in reversed(range(1, 21)):
value = value / 20
#print("Value: " + str(value))
r, g, b = colorsys.hsv_to_rgb(self.POSITION_HUE, self.POSITION_SATURATION, value)
self.build_led_strip(r, g, b)
time.sleep(0.075)
loop_counter = loop_counter + 1
# Only one LED is active and moves from one end to the other end of the strip.
def set_color_dot(self, position):
# Build the initial array
r = self.R[0]
g = self.G[0]
b = self.B[0]
r = [r]
g = [g]
b = [b]
r.extend([0]*15)
g.extend([0]*15)
b.extend([0]*15)
#print('R: ' + str(r) + '\n','G: ' + str(g) + '\n','B: ' + str(b) + '\n')
# Now get the dot moving
i = 0
while i < 15:
dot_r = r[i]
dot_g = g[i]
dot_b = b[i]
r[i] = 0
g[i] = 0
b[i] = 0
r[i+1] = dot_r
g[i+1] = dot_g
b[i+1] = dot_b
#print('R: ' + str(r) + '\n','G: ' + str(g) + '\n','B: ' + str(b) + '\n')
i = i + 1
self.set_mode(self.MODE, 0, self.MAX_LEDS, r, b, g)
time.sleep(0.1)
while i > 0:
dot_r = r[i]
dot_g = g[i]
dot_b = b[i]
r[i] = 0
g[i] = 0
b[i] = 0
r[i-1] = dot_r
g[i-1] = dot_g
b[i-1] = dot_b
#print('R: ' + str(r) + '\n','G: ' + str(g) + '\n','B: ' + str(b) + '\n')
i = i - 1
self.set_mode(self.MODE, 0, self.MAX_LEDS, r, b, g)
time.sleep(0.1)
# Build random color values and place them randomly on the strips.
def set_color_randomly(self, position):
active_leds = self.ACTIVE_LEDS
"""
r = []
g = []
b = []
# 1. Variant
for led in list(range(active_leds)):
rv = random.randrange(1, 256)
gv = random.randrange(1, 256)
bv = random.randrange(1, 256)
r.append(rv)
g.append(gv)
b.append(bv)
# 2. Variant
for led in list(range(active_leds)):
rv, gv, bv = colorsys.hsv_to_rgb(1.*led/active_leds, self.POSITION_SATURATION, self.POSITION_VALUE)
r.append(int(rv*255))
g.append(int(gv*255))
b.append(int(bv*255))
for leds in range(active_leds):
random.shuffle(r)
random.shuffle(g)
random.shuffle(b)
print('R: ' + str(r) + '\n','G: ' + str(g) + '\n','B: ' + str(b) + '\n')
self.set_mode(self.MODE, 0, self.MAX_LEDS, r, b, g)
time.sleep(0.075)
"""
# 3. Variant
for leds in range(active_leds):
r = []
g = []
b = []
range_leds = list(range(active_leds))
random.shuffle(range_leds)
#print("LEDs: " + str(range_leds))
for led in range_leds:
rv, gv, bv = colorsys.hsv_to_rgb(1.*led/active_leds, self.POSITION_SATURATION, self.POSITION_VALUE)
r.append(int(rv*255))
g.append(int(gv*255))
b.append(int(bv*255))
#print('R: ' + str(r) + '\n','G: ' + str(g) + '\n','B: ' + str(b) + '\n')
self.set_mode(self.MODE, 0, self.MAX_LEDS, r, b, g)
time.sleep(0.1)
# Extend the LEDs from 1 LED to 16 LEDs per strip. Like the fading, but here the LEDs can be adjusted by the rotary poti.
def set_leds(self, position):
# The rotary poti can set the number of LEDs which should be used
active_leds = (position / 300) * self.MAX_LEDS
active_leds = int(math.ceil(active_leds))
#print('Active LEDs: ' + str(active_leds))
# Get the color values from the variables
r = self.R[0]
g = self.G[0]
b = self.B[0]
#print('R: ' + str(r),'G: ' + str(g),'B: ' + str(b))
# Now build the list with the active leds
r = [r]*active_leds
g = [g]*active_leds
b = [b]*active_leds
#print('R: ' + str(r) + '\n','G: ' + str(g) + '\n','B: ' + str(b) + '\n')
# Now add the remaining dark leds to the list
dark_leds = 16 - active_leds
#print('Dark LEDs: ' + str(dark_leds))
r.extend([0]*dark_leds)
g.extend([0]*dark_leds)
b.extend([0]*dark_leds)
#print('R: ' + str(r) + '\n','G: ' + str(g) + '\n','B: ' + str(b) + '\n')
# Now get it to the strips
self.set_mode(self.MODE, 0, self.MAX_LEDS, r, b, g)
# Save the value in the variable
self.ACTIVE_LEDS = active_leds
# Helper function to generate the output for the LED strips
def build_led_strip(self, r, g, b):
r = int(r*255)
g = int(g*255)
b = int(b*255)
#print('R: ' + str(r),'G: ' + str(g),'B: ' + str(b))
# Get the actual number of LEDs which should be used
active_leds = self.ACTIVE_LEDS
r = [r]*active_leds
g = [g]*active_leds
b = [b]*active_leds
# Now add the remaining dark leds to the list
dark_leds = 16 - active_leds
r.extend([0]*dark_leds)
g.extend([0]*dark_leds)
b.extend([0]*dark_leds)
#print('R: ' + str(r) + '\n','G: ' + str(g) + '\n','B: ' + str(b) + '\n')
# Now get it to the strips
self.set_mode(self.MODE, 0, self.MAX_LEDS, r, b, g)
# Save the values in the variables
self.R = r
self.G = g
self.B = b
# Callback function for position callback (parameter has range -150 to 150)
def cb_position(self, position):
# Print the position for debuging
#print('Position: ' + str(position))
# Always add +150 to the position value so that it will start on the left by 0 and to the right it will end by 300
position = position + 150
# Select in which MODE it is called
if self.MODE == self.MODE_HUE:
self.set_hue(position)
elif self.MODE == self.MODE_SATURATION:
self.set_saturation(position)
elif self.MODE == self.MODE_VALUE:
self.set_value(position)
elif self.MODE == self.MODE_VELOCITY:
self.set_velocity(position)
elif self.MODE == self.MODE_COLOR_GRADIENT:
self.set_color_gradient(position)
elif self.MODE == self.MODE_COLOR_DOT:
self.set_color_dot(position)
elif self.MODE == self.MODE_COLOR_FADING:
self.set_color_fading(position)
elif self.MODE == self.MODE_COLOR_RANDOMLY:
self.set_color_randomly(position)
elif self.MODE == self.MODE_LEDS:
self.set_leds(position)
# Callback function for button callback
def cb_buttons(self, button_state):
for i in range(12):
if button_state & (1 << i):
if i == 0:
self.MODE_STRIPS = self.MODE_LEFT_STRIP
elif i == 1:
self.MODE = self.MODE_HUE
elif i == 2:
self.MODE = self.MODE_COLOR_GRADIENT
elif i == 3:
self.MODE_STRIPS = self.MODE_BOTH_STRIPS
elif i == 4:
self.MODE = self.MODE_SATURATION
elif i == 5:
self.set_color_gradient_fading()
elif i == 6:
self.MODE_STRIPS = self.MODE_RIGHT_STRIP
elif i == 7:
self.MODE = self.MODE_VALUE
elif i == 8:
self.MODE = self.MODE_COLOR_FADING
elif i == 9:
#self.MODE = self.MODE_OFF
self.MODE = self.MODE_COLOR_RANDOMLY
elif i == 10:
self.MODE = self.MODE_LEDS
elif i == 11:
self.MODE = self.MODE_COLOR_DOT
