Project 1: Team Bedazzled Gremlin

Concept:
The two of us were very interested in exploring the telematic connection through two vastly different types of spaces, specifically between a private versus a public setting. We ended up designing these two devices that interact in a sort of ‘call and response’ where one signals to the other if there is a problem and the other device has the ability to execute the solution.

The narrative here is between these two creatures who seek to support each other in their vastly different environments. The gremlin lays open, with its treasures exposed as it sleeps, only alerting the Furrypine when loud sounds are detected so it can receive aid in return.

Process Imagery:

Process:
Over the course of several weeks we made quite a few adjustments to the project, with many different attempts and iterations.

The Gremlin took several weeks of careful testing and small adjustments. The process slowly progressed from developing the pleats themselves to the mechanics of how they should move. Different attempts and small adjustments all came together at the end for a refined result.

Constructing the Furrypine was relatively straightforward. The main challenge came in refining the code so that it vibrates in response to a signal from the Gremlin and does not send too many signals to the Gremlin at once when it is touched.

Execution:
The project came together as a Gremlin in a public space and a in a private space.

The Gremlin was constructed through a piece of muslin sewn together to establish several knife pleats. These pleats were strengthened by stitching the flapped edges of them along with inserting a small weight inside each pleat. This was done to encourage a flat and closed state. Between the flat pleats is the precious treasure of the Gremlin.

The Furrypine consists of a small piece of furry fabric that is sewn to a piece of conductive fabric. Conductive threads extend from the conductive fabric and connect to the Bluefruit and peak out of the fur in order to create the touch sensor. The combination of the conductive and furry fabrics is then sewn onto the horns of a hobby servomotor.

Together, the two creatures communicate through sound and touch. When a loud noise is detected on the side of the Gremlin, the Furrypine begins to tremble and shake, asking for anyone nearby to help the Gremlin. Once the Furrypine is touched, the Gremlin will receive the signal to drop its pleats closed, protecting its treasure and ideally startling anyone nearby who might be interesting in stealing the gems.

Gremlin Code:

import time
from adafruit_circuitplayground import cp
    # Import the low-level hardware libraries.
import board
import pwmio
import digitalio
import analogio
import pulseio
import supervisor
import sys
    # Import the Adafruit helper library.
from adafruit_motor import servo

    # Initialize hardware.

    # Create a PWMOut object on pad SDA A5 to generate control signals.
pwm = pulseio.PWMOut(board.A5, frequency=50)

    # Create a Servo object which controls a hobby servo using the PWMOut.
actuator = servo.Servo(pwm, min_pulse=1000, max_pulse=2000)

     # When there is a loud sound put the servo motor in a position where it sucks air out of the pneumatic.
actuator.angle = 180
nextMove = time.monotonic_ns()
cycles = 0
while True:
    #print(actuator.angle)
    #actuator.angle = 180
    now = time.monotonic_ns()
    if cp.loud_sound(400):
        print("sound")
        time.sleep(2)

    if supervisor.runtime.serial_bytes_available:
        line = sys.stdin.readline()
        tokens = line.split()
        cycles = 1
        #print("hi")
        #print(actuator.angle)
    while cycles >= 1:
        now = time.monotonic_ns()
        if abs(actuator.angle - 180) < 0.1:
            actuator.angle = 10
            nextMove = now + 3000000000
            #print("yes")
            #print(now)
        if now &gt;= nextMove:
            #print("here")
            actuator.angle = 180
            cycles -= 1

Furrypine Code:

# Write your code here :-)
    # SPDX-FileCopyrightText: 2021 ladyada for Adafruit Industries
    # SPDX-License-Identifier: MIT

   # """
    #This example prints out sound levels using the sound sensor on a Circuit Playground Bluefruit.
    #Try making sounds towards the board to see the values change.

    #NOTE: This example does NOT support Circuit Playground Express.
    # SPDX-FileCopyrightText: 2021 ladyada for Adafruit Industries
    # SPDX-License-Identifier: MIT

    #"""
    #This example lights up the NeoPixels on a Circuit Playground Bluefruit in response to a loud sound.
    #Try snapping or clapping near the board to trigger the LEDs.

    #NOTE: This example does NOT support Circuit Playground Express.

import time
from adafruit_circuitplayground import cp
    # Import the low-level hardware libraries.
import supervisor
import board
import pwmio
import digitalio
import analogio
import pulseio
import sys
    # Import the Adafruit helper library.
from adafruit_motor import servo

# Configure the NeoPixel LED array for bulk update using show().
cp.pixels.auto_write = False

    # Initialize hardware.

    # Create a PWMOut object on pad SDA A5 to generate control signals.
pwm = pulseio.PWMOut(board.A5, frequency=50)

    # Create a Servo object which controls a hobby servo using the PWMOut.
actuator = servo.Servo(pwm, min_pulse=1000, max_pulse=2000)

     # When there is a loud sound put the servo motor in a position where it sucks air out of the pneumatic.
actuator.angle = 10

# The display update rate is precisely regulated using the following timer variables.
# The default is 20 Hz frame rate as set by step_interval.
step_timer    = 0.0
last_time     = time.monotonic()
step_interval = 0.05
nextTouch = time.monotonic_ns()
nextMovement = time.monotonic_ns()

# The core model state is an array of state variables.  Note that the state is
# modeled for 12 uniformly spaced positions, even though only ten are populated
# with NeoPixels.  This state is abstract but might represent heat moving
# through a ring of material.
state = [0.0] * 12  # create 12 element array of zeros
actuator.angle = 30
cyclesLeft = 0
while True:
        # Measure elapsed time and wait until the update timer has elapsed.
    now = time.monotonic()
    touchNow = time.monotonic_ns()
    motorNow = time.monotonic_ns()
    interval = now - last_time
    last_time = now
    step_timer -= interval

    if step_timer < 0.0:
        step_timer += step_interval

        # Apply a first-order diffusion model to the state.  This loop creates a new
        # array to replace the previous state.  The modulo operator (%) is used to 'wrap
        # around' the end of the array to close the loop.
        N = len(state)
        new = [0.0] * N
        for i in range(N):
            new[i] = 0.9 * state[i] + 0.05 * state[(i-1) % N] + 0.05 * state[(i+1) % N]

        # Replace the previous state.
        state = new

        # Apply a slow decay to represent leakage outside the ring.
        for i in range(N):
            state[i] = 0.97 * state[i]

        # Apply touch inputs as excitation blended into nearby samples.
        if cp.touch_A3 and touchNow &gt;= nextTouch:
            nextTouch = touchNow + 3000000000
            print("touch")
            state[11] += 0.1 * (1.0 - state[11])

        # Update the LED colors to reflect the state.  Note that states 0 and 6
        # are invisible as these positions do not have LEDs.
        for i, s in enumerate(state):
            if i != 0 and i != 6:
                # Clamp the state value between 0.0 and 1.0.
                value = min(max(s, 0.0), 1.0)

                # Map the state index to an LED position index.
                pos = i-1 if i < 6 else i-2

                # Map 0.0 to dim blue and 1.0 to bright red.
                cp.pixels[pos] = (255 * value, 0, 50 * (1.0 - value))


        cp.pixels.show()

        if supervisor.runtime.serial_bytes_available:
            line = sys.stdin.readline()
            tokens = line.split()
            cyclesLeft = 10
        if cyclesLeft &gt; 0:
            if abs(actuator.angle - 30) < 0.1 and motorNow &gt;= nextMovement:
                actuator.angle = 10
                nextMovement = motorNow + 250000000
            elif motorNow &gt;= nextMovement:
                actuator.angle = 30
                nextMovement = motorNow + 250000000
                cyclesLeft -= 1

Conclusion and Reflection:
If there was more time, we would have liked to take these devices and explore them in the public-private context that they were intended to be explored in. Additionally, it would have been helpful to work with these devices for a few days in this context. Interacting with these devices over a longer period of time, especially with the Gremlin transmitting sound data from the University Center, will create a better understanding of how we would perceive and engage with these devices.

The construction of the Gremlin itself would also change slightly. We thought it could be interesting to explore how the pleats would respond in a basket-like or cavernous shape, resembling more where we’d expect the Gremlin to live. Similarly with the Furrypine, we would have liked the ability for it to be entirely wireless, and for all the components to be entirely contained within the body, giving it more of a feeling of a small timid and curled up creature.