class NightLight(nonblocking_timer):
def __init__(self):
super(NightLight, self).__init__()
pixels = neopixel.NeoPixel(NEOPIXEL, 10, auto_write=1, brightness=1.0)
pixels.fill((0, 0, 0))
pixels.show()
self._on = False
self._animator = PixelAnimator(pixels)
self._irSensor = AnalogIn(IR_PROXIMITY)
self._irInput = DigitalInOut(REMOTEIN)
self._irInput.direction = Direction.INPUT
self._irOutput = DigitalInOut(REMOTEOUT)
self._irOutput.direction = Direction.OUTPUT
self._microphone = DigitalInOut(MICROPHONE_DATA)
self._irOutput.direction = Direction.INPUT
def stop(self):
print('stop')
self._irSensor.deinit()
self._irInput.deinit()
def next(self):
# print("ir: %d mic: %d" % (self._irSensor.value, self._irOutput.value))
self._animator.next()
def bistmon(self, quadno, monsig=False):
min = 0 if quadno < 4 else 3
max = 3 if quadno < 4 else 6
for i in range(min, max):
self.gp.bist(i, True)
if quadno == i:
self.gp.quad[i].get_pin(1).value = 1
self.gp.quad[i].get_pin(3).value = monsig
else:
self.gp.quad[i].get_pin(1).value = 0
self.gp.quad[i].get_pin(3).value = 0
time.sleep(0.2)
if quadno < 3:
p = AnalogIn(board.LQ)
else:
p = AnalogIn(board.RQ)
val = p.value
self.gp.quad[quadno].get_pin(1).value = 0
self.gp.quad[quadno].get_pin(3).value = 0
for i in range(min, max):
self.gp.bist(i, False)
p.deinit()
del p
del i
del min
del max
return val
def setup():
# fingers corssed, the seeding makes sense to really get random colors...
apin = AnalogIn(analog_input)
random.seed(apin.value)
apin.deinit()
# let's go!
nextcolor()
strip.write()
class AnalogIn(object):
"""Basic analog input."""
def __init__(self, pin):
self._pin = AnalogIn_(pin)
def deinit(self):
self._pin.deinit()
@property
def value(self):
return self._pin.value
@property
def max_adc(self):
return MAX_ADC
def setup():
global fade
# Random number generator is seeded from an unused 'floating'
# analog input - this helps ensure the random color choices
# aren't always the same order.
pin = AnalogIn(board.A0)
random.seed(pin.value)
pin.deinit()
for he in range(n_horns):
for wi in range(n_waves):
random_wave(he, wi)
fade = 233 + n_leds / 2
if fade > 233:
fade = 233
def _get_linear_position(self, tail_to_tip=True):
self._wiper.deinit()
l_wiper = AnalogIn(self._wiper_pin)
self._ref.switch_to_input(pull=Pull.DOWN)
if tail_to_tip: # Read from tail end
self._v1.value = 1
time.sleep(0.001)
value = self._get_voltage(l_wiper)
self._v1.value = 0
else:
self._v2.value = 1
time.sleep(0.001)
value = self._get_voltage(l_wiper)
self._v2.value = 0
l_wiper.deinit()
self._wiper = DigitalInOut(self._wiper_pin)
self._wiper.direction = Direction.OUTPUT
self._wiper.value = 0
self._ref.switch_to_output(value=False)
return self._get_millimeters(value)
def battery_check_state():
global red_led_pwm, green_led_pwm, blue_led_pwm, keypad_rows, masterLEDDutyCycle
led_blink_count = 0
# de-init A0 pin from keypad temp
keypad_rows[0].deinit()
# give the pin a bit to fully de-initialize
time.sleep(0.075)
battery_voltage_pin = AnalogIn(board.A0)
battery_voltage = get_voltage(battery_voltage_pin) * 2
print("Battery Voltage: ", battery_voltage)
# if voltage drops below 5 then blink LEDs 3 times
if battery_voltage < 5:
while led_blink_count < 3:
red_led_pwm.duty_cycle = masterLEDDutyCycle
time.sleep(0.20)
red_led_pwm.duty_cycle = 0
blue_led_pwm.duty_cycle = masterLEDDutyCycle
time.sleep(0.20)
blue_led_pwm.duty_cycle = 0
green_led_pwm.duty_cycle = masterLEDDutyCycle
time.sleep(0.20)
green_led_pwm.duty_cycle = 0
led_blink_count += 1
# de-init battery_voltage_pin
battery_voltage_pin.deinit()
# give the pin a bit to fully de-initialize
time.sleep(0.075)
# re-init keyboard pin for key on keypad
keypad_rows[0] = digitalio.DigitalInOut(board.A0)
def _get_linear_force(self):
self._wiper.deinit()
l_wiper = AnalogIn(self._wiper_pin)
self._ref.value = 0
self._v1.switch_to_output(value=True)
self._v2.switch_to_input()
time.sleep(0.001)
wiper_1 = l_wiper.value
self._v2.switch_to_output(value=True)
self._v1.switch_to_input()
time.sleep(0.001)
wiper_2 = l_wiper.value
l_wiper.deinit()
self._wiper = DigitalInOut(self._wiper_pin)
self._wiper.direction = Direction.OUTPUT
self._wiper.value = 0
self._v1.direction = Direction.OUTPUT
self._v1.value = 0
self._v2.value = 0
return ((
(wiper_1 + wiper_2) / 2) * self._VOLTAGE) / self._ANALOG_RESOLUTION
class PiperJoystickAxis:
def __init__(self, pin, outputScale=20.0, deadbandCutoff=0.1, weight=0.2):
self.pin = AnalogIn(pin)
self.outputScale = outputScale
self.deadbandCutoff = deadbandCutoff
self.weight = weight
self.alpha = self._Cubic(self.deadbandCutoff)
def deinit(self):
self.pin.deinit()
# Cubic function to map input to output in such a way as to give more precision
# for lower values
def _Cubic(self, x):
return self.weight * x**3 + (1.0 - self.weight) * x
# Eliminate the jump present in the deadband, but use the cubic function to give
# more precision to lower values
#
def _cubicScaledDeadband(self, x):
if abs(x) < self.deadbandCutoff:
return 0
else:
return (self._Cubic(x) -
(copysign(1, x)) * self.alpha) / (1.0 - self.alpha)
# The analog joystick output is an unsigned number 0 to 2^16, which we
# will scale to -1 to +1 for compatibility with the cubic scaled
# deadband article. This will then remap and return a value
# still in the range -1 to +1. Finally we multiply by the requested scaler
# an return an integer which can be used with the mouse HID.
#
def readJoystickAxis(self):
return int(
self._cubicScaledDeadband((self.pin.value / 2**15) - 1) *
self.outputScale)
class Peripherals:
"""Peripherals Helper Class for the MagTag Library"""
# pylint: disable=too-many-instance-attributes, too-many-locals, too-many-branches, too-many-statements
def __init__(self):
# Neopixels
self.neopixels = neopixel.NeoPixel(board.NEOPIXEL, 4, brightness=0.3)
self._neopixel_disable = DigitalInOut(board.NEOPIXEL_POWER)
self._neopixel_disable.direction = Direction.OUTPUT
self._neopixel_disable.value = False
# Battery Voltage
self._batt_monitor = AnalogIn(board.BATTERY)
# Speaker Enable
self._speaker_enable = DigitalInOut(board.SPEAKER_ENABLE)
self._speaker_enable.direction = Direction.OUTPUT
self._speaker_enable.value = False
# Light Sensor
self._light = AnalogIn(board.LIGHT)
# Buttons
self.buttons = []
for pin in (board.BUTTON_A, board.BUTTON_B, board.BUTTON_C, board.BUTTON_D):
switch = DigitalInOut(pin)
switch.direction = Direction.INPUT
switch.pull = Pull.UP
self.buttons.append(switch)
def play_tone(self, frequency, duration):
"""Automatically Enable/Disable the speaker and play
a tone at the specified frequency for the specified duration
It will attempt to play the sound up to 3 times in the case of
an error.
"""
if frequency <= 0:
raise ValueError("The frequency has to be greater than 0.")
self._speaker_enable.value = True
attempt = 0
# Try up to 3 times to play the sound
while attempt < 3:
try:
simpleio.tone(board.SPEAKER, frequency, duration)
break
except NameError:
pass
attempt += 1
self._speaker_enable.value = False
def deinit(self):
"""Call deinit on all resources to free them"""
self.neopixels.deinit()
self._neopixel_disable.deinit()
self._speaker_enable.deinit()
for button in self.buttons:
button.deinit()
self._batt_monitor.deinit()
self._light.deinit()
@property
def battery(self):
"""Return the voltage of the battery"""
return (self._batt_monitor.value / 65535.0) * 3.3 * 2
@property
def neopixel_disable(self):
"""
Enable or disable the neopixels for power savings
"""
return self._neopixel_disable.value
@neopixel_disable.setter
def neopixel_disable(self, value):
self._neopixel_disable.value = value
@property
def speaker_disable(self):
"""
Enable or disable the speaker for power savings
"""
return not self._speaker_enable.value
@speaker_disable.setter
def speaker_disable(self, value):
self._speaker_enable.value = not value
@property
def button_a_pressed(self):
"""
Return whether Button A is pressed
"""
return not self.buttons[0].value
@property
def button_b_pressed(self):
"""
Return whether Button B is pressed
"""
return not self.buttons[1].value
@property
def button_c_pressed(self):
"""
Return whether Button C is pressed
"""
return not self.buttons[2].value
@property
def button_d_pressed(self):
"""
Return whether Button D is pressed
"""
return not self.buttons[3].value
@property
def any_button_pressed(self):
"""
Return whether any button is pressed
"""
return False in [self.buttons[i].value for i in range(0, 4)]
@property
def light(self):
"""
Return the value of the light sensor. The neopixel_disable property
must be false to get a value.
.. code-block:: python
import time
from adafruit_magtag.magtag import MagTag
magtag = MagTag()
while True:
print(magtag.peripherals.light)
time.sleep(0.01)
"""
return self._light.value
wave_type = 0 # 0 = square wave, 1 = triangle wave
value_frame = 1 # start-of-frame value
value_pixel = 2 # pixel-to-pixel value
inc_frame = 3 # frame-to-frame increment
inc_pixel = 4 # pixel-to-pixel inc
wave_h = 0 # hue
wave_s = 1 # saturation
wave_v = 2 # brightness
# Random number generator is seeded from an unused 'floating'
# analog input - this helps ensure the random color choices
# aren't always the same order.
pin = AnalogIn(board.A0)
random.seed(pin.value)
pin.deinit()
# generate a non-zero random number for frame and pixel increments
def nz_random():
random_number = 0
while random_number <= 0:
random_number = random.randint(0, 15) - 7
return random_number
while True:
w = i = n = s = v = r = g = b = v1 = s1 = 0
speaker.frequency = 444
time.sleep(.5)
# tone 3
speaker.frequency = 494
time.sleep(.5)
speaker.duty_cycle = OFF
######################### MAIN LOOP ##############################
randomSeedPin = AnalogIn(board.A0)
random.seed(randomSeedPin.value)
randomSeedPin.deinit()
# randomize the starting button
activeButtonId = random.randint(0, 4)
i = 0
while True:
# spin internal neopixel LED around for pretty lightssss
dot[0] = wheel(i & 255)
activeButton = buttons[activeButtonId]
activeButtonLed = buttonLeds[activeButtonId]
if i < 125:
activeButtonLed.value = True
else:
time.sleep(.5)
speaker.frequency = 444
time.sleep(.5)
# tone 3
speaker.frequency = 494
time.sleep(.5)
speaker.duty_cycle = OFF
######################### MAIN LOOP ##############################
randomSeedPin = AnalogIn(board.A0)
random.seed(randomSeedPin.value)
randomSeedPin.deinit()
# randomize the starting button
activeButtonId = random.randint(0,4)
i = 0
while True:
# spin internal neopixel LED around for pretty lightssss
dot[0] = wheel(i & 255)
activeButton = buttons[activeButtonId]
activeButtonLed = buttonLeds[activeButtonId]
if i < 125:
activeButtonLed.value = True
else:
class Peripherals:
"""Peripherals Helper Class for the FunHouse Library"""
# pylint: disable=too-many-instance-attributes, too-many-locals, too-many-branches, too-many-statements
def __init__(self):
# Dotstars
self.dotstars = adafruit_dotstar.DotStar(board.DOTSTAR_CLOCK,
board.DOTSTAR_DATA,
5,
brightness=0.3)
# Light Sensor
self._light = AnalogIn(board.LIGHT)
# Buttons
self._buttons = []
for pin in (board.BUTTON_DOWN, board.BUTTON_SELECT, board.BUTTON_UP):
switch = DigitalInOut(pin)
switch.direction = Direction.INPUT
switch.pull = Pull.DOWN
self._buttons.append(switch)
# Cap Tocuh Pads
self._ctp = []
for pin in (
board.CAP6,
board.CAP7,
board.CAP8,
board.CAP13,
board.CAP12,
board.CAP11,
board.CAP10,
board.CAP9,
):
cap = touchio.TouchIn(pin)
self._ctp.append(cap)
# LED
self._led = DigitalInOut(board.LED)
self._led.direction = Direction.OUTPUT
# PIR Sensor
self._pir = DigitalInOut(board.PIR_SENSE)
self._pir.direction = Direction.INPUT
@staticmethod
def play_tone(frequency, duration):
"""Automatically Enable/Disable the speaker and play
a tone at the specified frequency for the specified duration
It will attempt to play the sound up to 3 times in the case of
an error.
"""
if frequency <= 0:
raise ValueError("The frequency has to be greater than 0.")
attempt = 0
# Try up to 3 times to play the sound
while attempt < 3:
try:
simpleio.tone(board.SPEAKER, frequency, duration)
break
except NameError:
pass
attempt += 1
def set_dotstars(self, *values):
"""Set the dotstar values to the provided values"""
for i, value in enumerate(values[:len(self.dotstars)]):
self.dotstars[i] = value
def deinit(self):
"""Call deinit on all resources to free them"""
self.dotstars.deinit()
for button in self._buttons:
button.deinit()
for ctp in self._ctp:
ctp.deinit()
self._light.deinit()
self._led.deinit()
self._pir.deinit()
@property
def button_down(self):
"""
Return whether Down Button is pressed
"""
return self._buttons[0].value
@property
def button_sel(self):
"""
Return whether Sel Button is pressed
"""
return self._buttons[1].value
@property
def button_up(self):
"""
Return whether Up Button is pressed
"""
return self._buttons[2].value
@property
def any_button_pressed(self):
"""
Return whether any button is pressed
"""
return True in [button.value for button in enumerate(self._buttons)]
@property
def captouch6(self):
"""
Return whether CT6 Touch Pad is touched
"""
return self._ctp[0].value
@property
def captouch7(self):
"""
Return whether CT7 Touch Pad is touched
"""
return self._ctp[1].value
@property
def captouch8(self):
"""
Return whether CT8 Touch Pad is touched
"""
return self._ctp[2].value
@property
def slider(self):
"""
Return the slider position value in the range of 0.0-1.0 or None if not touched
"""
val = 0
cap_map = b"\x01\x03\x02\x05\x04\x0c\x08\x18\x10"
for cap in range(5):
raw = self._ctp[cap + 3].raw_value
if raw > 15000:
val += 1 << (cap)
for i, pos in enumerate(tuple(cap_map)):
if val == pos:
print(i, len(cap_map) - 1)
return round(i / (len(cap_map) - 1), 1)
return None
@property
def light(self):
"""
Return the value of the light sensor. The neopixel_disable property
must be false to get a value.
.. code-block:: python
import time
from adafruit_funhouse import FunHouse
funhouse = FunHouse()
while True:
print(funhouse.peripherals.light)
time.sleep(0.01)
"""
return self._light.value
@property
def led(self):
"""
Return or set the value of the LED
"""
return self._led.value
@led.setter
def led(self, value):
self._led.value = bool(value)
@property
def pir_sensor(self):
"""
Return the value of the PIR Sensor
"""
return self._pir.value
def is_dry():
analog_in = AnalogIn(board.A3)
global last_moisure_value
last_moisure_value = get_moisture_value(analog_in)
analog_in.deinit()
return last_moisure_value <= 400
