I did a few very simple experiments with cable controls. I am not the best crafter, so I wanted to be very systematic about how to make my cable controls function.

The basic form of my cable control was a set of straws, punctuated with small diamond shape holes with a string anchored at the top of the and pulled through to the bottom (where I could pull it).

For this assignment, I varied whole size and distance between holes to see how it impacted behavior.

The setup is below:

You can see how the variables affected their movement here:

My favorite was #2, which had the largest hole at the top of the straw (in contrast to #1, which had the largest hole towards the bottom). The larger holes essentially folded first, making the motion that resulted more of a curl.

What might a mycelium computer interface look like? Could mycelium serve as conductive elements or are they better used as sensors or chemical actuators? Based on Stamets work, it seems as though ecological management is a natural point of collaboration between humans, computers, and fungi.

I would be interested in exploring these ideas within the context of extreme environments such as space. I plan to dig into the work NASA has already done in research the growth and use of fungi in space.

For this assignment, I programmed an ATTiny85 to run Neopixels when triggered by a capacitive touch sensor. I had a bit of previous experience working with an ATTiny85 + Neopixel combo, and began by trying to recreate that. Initially, I was a bit nervous that the soldering of my programming jig had introduced some integrity issues to the code uploaded to my ATTiny85, but I ran many tests with both Blink and Neopixel’s strand test and found that the jig (and each of my programmed chips) performed just fine.

The implementation of capacitive touch sensing was quite similar to my previous experiences working with it. I placed a 100k ohm resistor across pins 4 and 2 of my chip, using pin 2 as my input or sensing pin. You can see the behavior here:

The housing you see is a junk shelf find. The contraption is powered by two 3V coin cell batteries in series.

Basically, the code on the chip includes small tweaks to the sample code that comes with the Neopixels library and the capacitive sensor library. With a bit more time, I would have soldered my circuit, because as it stands, it is quite fragile.

For this assignment, we were tasked with experimenting within two different programs at various parts of our data pipeline. Results below:

Part 1: Experiments with Grafana

I came up with the following dashboard, focusing primarily on looking at humidity data over time, with relevant max values represented as well:

I used the following query for line chart:

For the temperature guage, I used the following query and settings:

For the humidity guage, I used the following query and settings:

Part 2: Experiments with Node Red

I made some adjustments to the workflow we did in class to make it so I recieved an alert whenever the humidity of one of our sensors went above a measurement of 20.

The workflow can be seen below:

I sent the alert to my NYU email, rather than my personal gmail.

Here’s a link to my workflow gist: https://gist.github.com/rashidakamal/5d830a73e96a584e857831d93c6bc685

I made very minimal changes to Don’s code in class to send notifications to my phone from the data send to the class’s MQTT broker from my device.

The adjust code is below (I’ve changed my phone number to just all 5’s):

const mqtt = require('mqtt');
const mqttClient = mqtt.connect(process.env.MQTT_SERVER);
var AWS = require('aws-sdk');
AWS.config.update({ region: 'us-east-1' });

mqttClient.on('connect', () => {
    console.log('MQTT Connected');
    mqttClient.subscribe('itp/device_rk/temperature');
});

mqttClient.on('message', (topic, message) => {
    console.log(topic, message.toString());
    const temperature = Number(message.toString());

    if (temperature > 70) {
        const alertMessage = `Temperature in Rashida's room ${temperature}°F exceeds the high temperature limit of 70°F`
        // mqttClient.publish('itp/device_xx/alert', alertMessage);
        sendSms('+15555555555', alertMessage);
    }
});

async function sendSms(number, message) {

    var params = {
        Message: message,
        PhoneNumber: number
    };

    try {
        // Send the message
        let response = await new AWS.SNS({ apiVersion: '2010-03-31' }).publish(params).promise();
        console.log(`MessageID is ${response.MessageId}`);
    } catch (e) {
        console.error(e, e.stack)
    }
}

Screenshot of proof:

Actuating something was also part of what was suggested for the assignment. I adjusted my old arduino code so that an LED blinked when my device published to an MQTT topic. Proof: