class TheClapper:
"""
Turn LEDs in a counter-clockwise fashion with randomly generated colors.
When you clap your hand loudly, the pixels will stop changing and the
program exits. Clap again and they start moving again.
"""
def __init__(self):
self.p = PyMataCpx()
print('Clap your hands loudly to stop the neopixels from moving.')
print('Clap again, to start them up')
self.p.cpx_microphone_start(self.listen)
self.go = True
while True:
try:
# run the light show
for neopixel in range(0, 10):
if self.go:
self.p.cpx_pixels_clear()
self.p.cpx_pixels_show()
r = random.randint(0, 254)
g = random.randint(0, 254)
b = random.randint(0, 254)
self.p.cpx_pixel_set(neopixel, r, g, b)
self.p.cpx_pixels_show()
time.sleep(.2)
else:
self.p.cpx_pixels_clear()
self.p.cpx_pixels_show()
time.sleep(.001)
except KeyboardInterrupt:
# If you press control-C, cleanly exit
self.p.cpx_pixels_clear()
self.p.cpx_pixels_show()
self.p.cpx_close_and_exit()
def listen(self, data):
"""
Turn off the light show and exit
:param data: data[0] = 2 indicating this is analog data
data[1] = pin attached to mic- pin 4
data[3] = readings from microphone
"""
if data[2] > 600:
# self.p.cpx_pixels_clear()
# self.p.cpx_pixels_show()
self.go = not self.go
class CpxGateway(GatewayBase, threading.Thread):
"""
This class is the interface class for the Circuit Playground
Express supporting Scratch 3.
"""
def __init__(self,
*subscriber_list,
back_plane_ip_address=None,
subscriber_port='43125',
publisher_port='43124',
process_name='CpxGateway',
publisher_topic=None,
log=False):
"""
:param subscriber_list: a tuple or list of subscription topics.
:param back_plane_ip_address:
:param subscriber_port:
:param publisher_port:
:param process_name:
"""
# initialize parent
super(CpxGateway,
self).__init__(subscriber_list=subscriber_list,
back_plane_ip_address=back_plane_ip_address,
subscriber_port=subscriber_port,
publisher_port=publisher_port,
process_name=process_name)
self.log = log
if self.log:
fn = str(pathlib.Path.home()) + "/cpxgw.log"
self.logger = logging.getLogger(__name__)
logging.basicConfig(filename=fn, filemode='w', level=logging.DEBUG)
sys.excepthook = self.my_handler
self.publisher_topic = publisher_topic
self.cpx = PyMataCpx()
atexit.register(self.shutdown)
# hold the time of the last analog data to be received.
# use to determine if connectivity is gone.
self.last_analog_data_time = None
# start up all the sensors
self.cpx.cpx_accel_start(self.tilt_callback)
self.cpx.cpx_button_a_start(self.switch_callback)
self.cpx.cpx_button_b_start(self.switch_callback)
self.cpx.cpx_slide_switch_start(self.switch_callback)
self.cpx.cpx_light_sensor_start(self.analog_callback)
self.cpx.cpx_microphone_start(self.analog_callback)
self.cpx.cpx_temperature_start(self.analog_callback)
for touch_pad in range(1, 8):
self.cpx.cpx_cap_touch_start(touch_pad, self.touchpad_callback)
threading.Thread.__init__(self)
self.daemon = True
# start the watchdog thread
self.start()
# start the banyan receive loop
try:
self.receive_loop()
except:
pass
# except KeyboardInterrupt:
# except KeyboardInterrupt:
# self.cpx.cpx_close_and_exit()
# sys.exit(0)
# os._exit(1)
def init_pins_dictionary(self):
pass
def play_tone(self, topic, payload):
"""
This method plays a tone on a piezo device connected to the selected
pin at the frequency and duration requested.
Frequency is in hz and duration in milliseconds.
Call set_mode_tone before using this method.
:param topic: message topic
:param payload: {"command": "play_tone", "pin": “PIN”, "tag": "TAG",
“freq”: ”FREQUENCY”, duration: “DURATION”}
"""
self.cpx.cpx_tone(payload['freq'], payload['duration'])
def additional_banyan_messages(self, topic, payload):
if payload['command'] == 'pixel':
self.set_pixel(payload)
def set_pixel(self, payload):
self.cpx.cpx_pixel_set(payload['pixel'], payload['red'],
payload['green'], payload['blue'])
self.cpx.cpx_pixels_show()
def digital_write(self, topic, payload):
"""
This method performs a digital write to the board LED
:param topic: message topic
:param payload: {"command": "digital_write", "pin": “PIN”, "value": “VALUE”}
"""
if payload['value']:
self.cpx.cpx_board_light_on()
else:
self.cpx.cpx_board_light_off()
# The CPX sensor callbacks
def tilt_callback(self, data):
"""
Report the tilt of the express board
Take the raw xyz data and transform it to
positional strings.
:param data: data [0] = data mode 32 is analog.
data[1] = the pin number - this is a pseudo pin number
data[2] = x value
data[3] = y value
data[4] = z value
"""
x = data[2]
y = data[3]
z = data[4]
# Convert raw Accelerometer values to degrees
x_angle = int((math.atan2(y, z) + math.pi) * (180 / math.pi))
y_angle = int((math.atan2(z, x) + math.pi) * (180 / math.pi))
h = v = -1
if 175 < x_angle < 185 and 265 < y_angle < 275:
h = v = 0 # 'flat'
elif h or v:
if 180 <= x_angle <= 270:
v = 1 # up
elif 90 <= x_angle <= 180:
v = 2 # down
if 180 <= y_angle <= 270:
h = 3 # left
elif 270 <= y_angle <= 360:
h = 4 # right
payload = {'report': 'tilted', 'value': [v, h]}
self.publish_payload(payload, 'from_cpx_gateway')
def switch_callback(self, data):
"""
This handles switches a, b, and slide
:param data: data[1] - a=4 b=5, slice=7,
"""
if data[1] == 4:
switch = 'a'
elif data[1] == 5:
switch = 'b'
else:
# 0 = right, 1 = left
switch = 'slide'
payload = {'report': switch, 'value': data[2]}
self.publish_payload(payload, 'from_cpx_gateway')
def analog_callback(self, data):
"""
This handles the light, temperature and sound sensors.
It also sets up a "watchdog timer" and if there is no activity
for > 1 second will exit.
:param data: data[1] - 8 = light, temp = 9, 10 = sound,
"""
self.last_analog_data_time = time.time()
if data[1] == 8:
sensor = 'light'
elif data[1] == 9:
sensor = 'temp'
else:
sensor = 'sound'
payload = {'report': sensor, 'value': round(data[2], 2)}
self.publish_payload(payload, 'from_cpx_gateway')
def touchpad_callback(self, data):
"""
Build and send a banyan message for the pad and value
:param data: data[1] = touchpad and data[2] = boolean value
"""
payload = {'report': 'touch' + str(data[1]), 'value': int(data[2])}
self.publish_payload(payload, 'from_cpx_gateway')
def shutdown(self):
try:
self.cpx.cpx_close_and_exit()
sys.exit(0)
except serial.serialutil.SerialException:
pass
def my_handler(self, xtype, value, tb):
"""
for logging uncaught exceptions
:param xtype:
:param value:
:param tb:
:return:
"""
self.logger.exception("Uncaught exception: {0}".format(str(value)))
def run(self):
if not self.last_analog_data_time:
self.last_analog_data_time = time.time()
while True:
if time.time() - self.last_analog_data_time > 1.0:
print('Watchdog timed out - exiting.')
os._exit(1)
time.sleep(1)