simple_RGB_driver/simple_RGB_driver_OLD.py at master · osxdude/simple_RGB_driver · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
"""
See README.md
"""

import time
import RGB_Driver
"""import os"""

"""class RGB_Driver(object):

    def pwm(pin, angle):
		print "servo[" + str(pin) + "][" + str(angle) + "]"
		with open('/dev/servoblaster','w') as s:
			f.write(str(pin) + "=" + str(angle))

	def __init__(self, pwm = None, red_pin = 0, green_pin = 1, blue_pin = 2):
		if pwm is None:
			self.pwm = self.pwm()
		else:
			print "Fuck yourself"
		self.red_pin = red_pin
		self.green_pin = green_pin
		self.blue_pin = blue_pin

	@staticmethod
	def convert_eight_to_twelve_bit(eight_bit):
		""""""The PWM chip has 10 bit resolution, so we need to
		convert regular 8 bit rgb codes
		>>> RGB_Driver.convert_eight_to_ten_bit(0)
		0
		>>> RGB_Driver.convert_eight_to_ten_bit(255)
		4080
		>>> RGB_Driver.convert_eight_to_ten_bit(128)
		2048
		""""""
		return eight_bit<<4

	def set_rgb(self, red_value, green_value, blue_value):
		""""""The rgb values must be between 0 and 4095""""""
		#print "R: %d, G: %d, B: %d" % (red_value, green_value, blue_value)
		pwm(self.red_pin, red_value)
		pwm(self.green_pin, green_value)
		pwm(self.blue_pin, blue_value)

	@staticmethod
	def sanitize_int(x):
		if x<0:
			return 0
		elif x>4095:
			return 4095
		else:
			return int(x)

	@staticmethod
	def randrange(start, stop, step=1):
		""""""A slightly modified version of randrange which allows start==stop""""""
		if start == stop:
			return start
		else:
			return randrange(start, stop, step)

	def fade_rgb(self, from_red, from_green, from_blue, to_red, to_green, to_blue, steps, delay):
		""""""Fade from one rgb value to another in steps, waiting for delay ms between each step
		all rgb values must be 10 bit ints (between 0 and 1023)""""""
		red_step = float(to_red - from_red)/steps
		green_step = float(to_green - from_green)/steps
		blue_step = float(to_blue - from_blue)/steps
		for step in range(0, steps+1):
			red_value = self.sanitize_int(from_red + red_step*step)
			green_value = self.sanitize_int(from_green + green_step*step)
			blue_value = self.sanitize_int(from_blue + blue_step*step)
			self.set_rgb(red_value, green_value, blue_value)
			time.sleep(delay)

	@staticmethod
	def get_next_random_value(current_value, minimum_allowed, maximum_allowed, max_walk):
		""""""Generate the next random value, given the current, max, and min values of that channel
		as well as the maximum change (walk) allowed""""""
		min = current_value - max_walk
		if min<minimum_allowed:
			min = minimum_allowed
		elif min<0:
			min = 0

		max = current_value + max_walk
		if max>maximum_allowed:
			max = maximum_allowed
		elif max>4095:
			max=4095

		return RGB_Driver.randrange(min, max)


	def random_walk(self, min_red, min_green, min_blue, max_red, max_green, max_blue, random_time, delay, max_walk):
		begin = time.time()
		red = self.randrange(min_red, max_red)
		green = self.randrange(min_green, max_green)
		blue = self.randrange(min_blue, max_blue)
		self.set_rgb(red, green, blue)
		time.sleep(delay)
		while time.time()-begin<random_time:
			red = self.get_next_random_value(red, min_red, max_red, max_walk)
			green = self.get_next_random_value(green, min_green, max_green, max_walk)
			blue = self.get_next_random_value(blue, min_blue, max_blue, max_walk)
		self.set_rgb(red, green, blue)
		time.sleep(delay)


"""
if __name__ == '__main__':
	import argparse
	parser = argparse.ArgumentParser(description='drive a rgb led strip through a pwm module')

	parser.add_argument('-rf', '--red-fade', nargs=2, type=int, default=[0, 0], help="The beginning and end values for red in fade mode.  Max and min values for red in random mode.")
	parser.add_argument('-gf', '--green-fade', nargs=2, type=int, default=[0, 0], help="The beginning and end values for green in fade mode.  Max and min values for green in random mode..")
	parser.add_argument('-bf', '--blue-fade', nargs=2, type=int, default=[0, 0], help="The beginning and end values for blue in fade mode.  Max and min values for blue in random mode..")
	parser.add_argument('-r', '--red', nargs=1, type=int, default=[0], help="The beginning and end values for red in static mode.")
	parser.add_argument('-g', '--green', nargs=1, type=int, default=[0], help="The beginning and end values for green in static mode.")
	parser.add_argument('-b', '--blue', nargs=1, type=int, default=[0], help="The beginning and end values for blue in static mode.")
	parser.add_argument('-c', '--static', action="store_true", help="Specify when using the static RGB value arguments.")
	parser.add_argument('-s', '--steps', type=int, default=100, help="Number of steps in the fade.  Not used with --random")
	parser.add_argument('-d', '--delay', type=float, default=0.005, help="Number of seconds between the steps or random changes, can be a float")
	parser.add_argument('-o', '--turn-off', action='store_true', help="Turn off when the fade or random event is over.")
	parser.add_argument('--red-pin', type=int, choices=range(0,16), default=0, help="The red pwm pin")
	parser.add_argument('--green-pin', type=int, choices=range(0,16), default=1, help="The green pwm pin")
	parser.add_argument('--blue-pin', type=int, choices=range(0,16), default=2, help="The blue pwm pin")
	parser.add_argument('--repeat', type=int, default=1, help="Repeat the fade this many times.  Unused with --random.")
	parser.add_argument('--reverse', action="store_true", help="Reverse the fade, to return back to the initial state.  Unused with --random.")
	parser.add_argument('--random', action="store_true", help="Move around randomly between the max and min values specified with --red --green and --blue.  Use with --time and --max-random-walk")
	parser.add_argument('--time', type=int, default=10, help="Used with --random.  Move randomly for this many seconds")
	parser.add_argument('--max-random-walk', type=int, default=10, help="The max that each channel will be allowed to change between steps in random mode.")
	args = parser.parse_args()


	driver = RGB_Driver(red_pin = args.red_pin, green_pin = args.green_pin, blue_pin = args.blue_pin)
	try:
		if args.random is False:
			for repeat in xrange(0, args.repeat):
				print "Repetition %d" % repeat
				driver.fade_rgb(args.red_fade[0], args.green_fade[0], args.blue_fade[0], args.red_fade[1], args.green_fade[1], args.blue_fade[1], args.steps, args.delay)
		if args.reverse:
			driver.fade_rgb(args.red_fade[0], args.green_fade[0], args.blue_fade[0], args.red_fade[1], args.green_fade[1], args.blue_fade[1], args.steps, args.delay)
		if args.static:
			driver.set_rgb(args.red[0], args.green[0], args.blue[0])
		else:
		# We need to sort the values to make sure randrange works correctly
			args.red.sort()
			args.green.sort()
			args.blue.sort()
			driver.random_walk(args.red_fade[0], args.green_fade[0], args.blue_fade[0], args.red_fade[1], args.green_fade[1], args.time, args.delay, args.max_random_walk)
	finally:
		if args.turn_off:
			driver.set_rgb(0, 0, 0)