Physical Computing

#include <Stepper.h>

//Motor
const int standbyPin = 7; //Set low when motor is idle to lower temperature. May affect holding torque
const int stepsPerRevolution = 200; //Defined by the motor
const int stepperRPM = 50;
const int stepsPerMs = stepsPerRevolution * stepperRPM / 60000;
bool busy = false; //Is the motor currently doing an instruction it received
unsigned long jobStart = 0; //When did the current job start (ms, from millis())
int jobLength = 0; //How many ms will the current job take

Stepper myStepper(stepsPerRevolution, 8, 9, 10, 11);

void setup() {
    // set the speed at 50 rpm:
    myStepper.setSpeed(stepperRPM);

    //Initialize the standby pin
    pinMode(standbyPin, INPUT);
    digitalWrite(standbyPin, HIGH);

    // initialize the serial port:
    Serial.begin(9600);
}

void loop() {
    //When a message from p5 is received
    if (Serial.available() > 0 && !busy) {
    // read the incoming byte:
    int inByte = Serial.read();

    //If it is a non-zero movement message
    if (inByte <= 200 && inByte != 0) {
        updatePosition(inByte); //Move motor to new position
    } else {
        informState(); //Inform that the motor is available
    }
    }

    checkCurrentState(); //Check if the motor is doing a job and update variable 'busy'
}

void updatePosition(int steps) { //Move motor
    if (steps <= 100) {
    //From 1 to 100 the steps are counterclockwise
    steps *= -1;
    } else {
    //From 101 to 200, the steps are actually 1-100 clockwise
    steps -= 100;
    }

    //Connect the motor
    //digitalWrite(standbyPin, HIGH);
    //Take the instructed steps
    myStepper.step(steps);
    busy = true;
    jobStart = millis();
    //Still need to figure out how to calculate this correctly
    //jobLength = ceil(abs(steps)/stepsPerMs);
    jobLength = 10;
}

void informState() {
    //Send the current state to p5
    Serial.write(busy);
}

void checkCurrentState() {
    if ( busy ) {
    //If estimated job duration time has passed
    if ( millis() - jobStart > jobLength) {
        //Set at not busy
        busy = false;

        //Disconnect motor
        //digitalWrite(standbyPin, LOW);

        informState();
    } else {
        busy = true;
    }
    }
}                     
                    

const serial = new p5.WebSerial();

let inData = 0;
let portButton;

//ml5 setup
let video;
let bodyPose;
let poses = [];
let centers = [];
// let connections;

let captureAvailable = false;

const globalConfidence = 0.1;

let song;

function preload() {
    // Load the bodyPose model
    bodyPose = ml5.bodyPose( {flipped: true});
    song = loadSound('assets/merry-go-round.mp3');
}


function setup() {
    createCanvas(640,480);
    // check to see if serial is available:
    if (!navigator.serial) {
    alert("WebSerial is not supported in this browser. Try Chrome or MS Edge.");
    noLoop();
    return;
    }
    startSerial();

    navigator.mediaDevices.enumerateDevices().then(function(devices) {
    devices.forEach(function(device) {
        if (device.label.includes('USB 2.0 PC Cam')) {
        const constraints = {
            video: {
                deviceId: device.deviceId
            },
            audio: false,
            flipped: true,
            };
            
            video = createCapture(constraints);
            video.elt.addEventListener('end', function(){
            console.log("Video stream ended, attempting to reconnect...");
            });
            video.size(640, 480);
            video.hide();
            bodyPose.detectStart(video, gotPoses);
            // Get the skeleton connection information
        //   connections = bodyPose.getSkeleton();
            captureAvailable = true;
        }
    });
    });
}

function draw() {
    background(255);
    if (!song.isPlaying()) {
        song.play();
    }
    // Draw the webcam video
    if(captureAvailable) {
        image(video, 0, 0, width, height);

        // Draw all centers;
        if(centers.length > 0) {
            centers.forEach(center => {
                noFill();
                stroke(0,255,0);
                line(center, 0, center, height);
            });
        }

        //Draw the distance between each person
        let orderedCenters = centers.slice();
        orderedCenters.sort((a, b) => a - b);
        for( let i = 0; i<orderedCenters.length; i ++) {
        if( i+1 < orderedCenters.length ){
            fill(0,255,0);
            const closestDistance = orderedCenters[i+1] - orderedCenters[i];
            if(closestDistance < proximity) {
                fill(0,0,255);
                stroke(0,0,255);
            }
            textAlign(CENTER);
            text(orderedCenters[i+1] - orderedCenters[i], orderedCenters[i] + (orderedCenters[i+1] - orderedCenters[i])/2, height/2 - 20);
            line(orderedCenters[i], height/2, orderedCenters[i+1], height/2);
        }
        }
    }else {
        textAlign(CENTER);
        text('External camera unavailable or loading :(', width/2, height/2);
    }
        
    //Draw audible area
    fill(220, 40);
    noStroke();
    rect( (width - audioRange)/2, 0, audioRange, height );
}

function gotPoses(results) {
    // Save the output to the poses variable
    poses = results;

    centers = [];
    //Run through poses and get the centers
    for (let i = 0; i < poses.length; i++) {
        let person = poses[i];
        let center = false;
        if(person.nose.confidence > globalConfidence){
            center = person.nose.x;
        }else if(person.right_eye.confidence > globalConfidence && person.left_eye.confidence > globalConfidence){
            center = person.right_eye.x - person.left_eye.x;
            const person_span = person.right_eye.x - person.left_eye.x;
            center = person.left_eye.x + person_span/2;
        }else if(person.right_shoulder.confidence > globalConfidence && person.left_shoulder.confidence > globalConfidence){
            center = person.right_shoulder.x - person.left_shoulder.x;
            const person_span = person.right_shoulder.x - person.left_shoulder.x;
            center = person.left_shoulder.x + person_span/2;
        }else {
            let minX = Infinity;
            let maxX = -Infinity;
            person.keypoints.forEach(keypoint => {
                if(keypoint.confidence > 0.1) {
                    minX = min(minX, keypoint.x);
                    maxX = max(maxX, keypoint.x);
                }
            });
            const person_span = maxX - minX;
            center = minX + person_span/2;
        }

        if(center !== false ){
            centers.push(center);
        }
    }


    if( centers.length > 0 ){
        // targetPos = map(width/2 - centers[0], -width/2, width/2, 3, -3, true); //distance from center of screen to center of person
        // if(Math.abs(Math.floor(targetPos)) == 1) {
        //     targetPos = 0;
        // }

        if(centers.length >= 2){
            const closestPair = findClosestPair(centers);
            if( Math.abs(closestPair[0] - closestPair[1]) < proximity ) {
                follow(closestPair[0]);
            }
        }else {
            avoid();
        }
    }
}

let audioRange = 140;

function avoid() {
    for (const person of centers) {
        if(person > (width - audioRange)/2 && person < (width + audioRange)/2) {
            targetPos = random(-20, 20);
            console.log('avoided');
            break;
        }
    }
}

let proximity = 70;

function follow( coord ){
    targetPos = map(width/2 - coord, -width/2, width/2, 3, -3, true); //distance from center of screen to center of person
    console.log('followed');
}

function findClosestPair(arr) {
    if (arr.length < 2) {
        return null; // Not enough numbers to compare
    }
    
    // Step 1: Sort the array in ascending order
    arr.sort((a, b) => a - b);
    
    // Step 2: Initialize variables to track the closest pair and the smallest difference
    let minDiff = Infinity;
    let closestPair = [];
    
    // Step 3: Iterate through the sorted array to find the smallest difference
    for (let i = 1; i < arr.length; i++) {
        let diff = Math.abs(arr[i] - arr[i - 1]);
    
        if (diff < minDiff) {
        minDiff = diff;
        closestPair = [arr[i - 1], arr[i]];
        }
    }
    
    return closestPair;
    }

function startSerial() {
    // if serial is available, add connect/disconnect listeners:
    navigator.serial.addEventListener("connect", portConnect);
    navigator.serial.addEventListener("disconnect", portDisconnect);
    // check for any ports that are available:
    serial.getPorts();
    // if there's no port chosen, choose one:
    serial.on("noport", makePortButton);
    // open whatever port is available:
    serial.on("portavailable", openPort);
    // handle serial errors:
    serial.on("requesterror", portError);
    // handle any incoming serial data:
    serial.on("data", serialEvent);
    serial.on("close", makePortButton);
}

/* SERIAL CALLBACK FUNCTIONS */

// if there's no port selected, 
// make a port select button appear:
function makePortButton() {
    // create and position a port chooser button:
    portButton = createButton("choose port");
    portButton.position(10, 10);
    // give the port button a mousepressed handler:
    portButton.mousePressed(choosePort);
}

// make the port selector window appear:
function choosePort() {
    if (portButton) portButton.show();
    serial.requestPort();
}

// open the selected port, and make the port 
// button invisible:
function openPort() {
    // wait for the serial.open promise to return,
    // then call the initiateSerial function
    serial.open().then(initiateSerial);

    // once the port opens, let the user know:
    function initiateSerial() {
        console.log("port open");
        serial.print(201);
    }
    // hide the port button once a port is chosen:
    if (portButton) portButton.hide();
}

// pop up an alert if there's a port error:
function portError(err) {
    alert("Serial port error: " + err);
}
// read any incoming data as a string
// (assumes a newline at the end of it):
let targetPos = 0;
let timeoutIndex = null;

function serialEvent() {
    inData = Number(serial.read());
    //console.log(inData);

    //Available for moving motor
    if(inData == 0 ) {
        clearTimeout(timeoutIndex);

        setTimeout( function(){
            let dataToSend = Math.floor(targetPos);
            if( dataToSend < 0 ){
                dataToSend = abs(dataToSend);
                dataToSend += 100;
            }
            if(dataToSend != 0 ){
                //console.log(dataToSend);
            }
    
            //console.log(dataToSend);
    
            serial.print(dataToSend);
            targetPos = 0;
        }, 100);
        
    }//else, it is busy, wait for the 0.
}

// try to connect if a new serial port 
// gets added (i.e. plugged in via USB):
function portConnect() {
    console.log("port connected");
    serial.getPorts();
}

// if a port is disconnected:
function portDisconnect() {
    serial.close();
    console.log("port disconnected");
}

function closePort() {
    serial.close();
}                 
                    

#define MOZZI_CONTROL_RATE 128
#include <Mozzi.h>
#include <Oscil.h>
#include <tables/sin2048_int8.h>

//Oscillator for first frequency
Oscil <2048, MOZZI_AUDIO_RATE> aSin(SIN2048_DATA);

//Oscillator for second frequency
Oscil <2048, MOZZI_AUDIO_RATE> aSin2(SIN2048_DATA);

//Oscillator for third frequency
Oscil <2048, MOZZI_AUDIO_RATE> aSin3(SIN2048_DATA);

//Oscillator for fourth frequency
Oscil <2048, MOZZI_AUDIO_RATE> aSin4(SIN2048_DATA);

//Oscillator for vibrato
Oscil <2048, MOZZI_CONTROL_RATE> kVib(SIN2048_DATA);

int freq = 900;
float vibrato = 0;
int combinedOutput = freq;

void setup() {
    startMozzi();
    aSin.setFreq(400);
    aSin2.setFreq(400);
    aSin3.setFreq(400);
    aSin4.setFreq(400);
    kVib.setFreq(6.5f);
}

void updateControl() {
    int trimmerL = mozziAnalogRead<10>(2);
    int trimmerR = mozziAnalogRead<10>(3);

    vibrato = map(constrain(trimmerR, 0 , 1024), 0, 1024, 2, 60) * kVib.next();
    freq = map(constrain(trimmerL, 0 , 1024), 0, 1024, 300, 10000);
    aSin.setFreq(freq + vibrato / 2);
    aSin2.setFreq(freq + 100 + vibrato);
    aSin3.setFreq(freq + 200 + vibrato);
    aSin4.setFreq(freq + 300 + vibrato);
}

AudioOutput updateAudio() {
    combinedOutput = aSin.next() + aSin2.next() + aSin3.next() + aSin4.next(); // Mix the audio signals
    return MonoOutput::from8Bit((combinedOutput / 4)); // Normalize output
}

void loop() {
    audioHook();
}                        
                    

/*
    September 15-16 2024
    Nasif Rincón

    Relaxing breath visualizer
    A simple device that senses breath as sound and
    visualizes the depth of the breath by filling out
    an LED matrix screen.
*/

#include <MAX7219.h>
//Library: https://github.com/michaelkubina/Arduino_MAX7219_LED_Matrix_Library

//LED Matrix Variables
#define DATAPIN     18
#define CLOCKPIN    19
#define CSPIN       11

MAX7219 Matrix(1, DATAPIN, CLOCKPIN, CSPIN);

//Breath sensor variables
int raw = 0;
float filtered = 0;
int baseline = 520;

void setup() {
    Serial.begin(9600);
    pinMode(A3, INPUT);
    pinMode(5, INPUT_PULLUP);
    Matrix.clearDisplay(1);

    Matrix.setLed(1, 3, 3, true);
    Matrix.setLed(1, 4, 3, true);
    Matrix.setLed(1, 3, 4, true);
    Matrix.setLed(1, 4, 4, true);
}

void loop() {

    if (!digitalRead(5) == HIGH) {
        baseline = analogRead(A3);
        return;
    }

    raw = abs( baseline - analogRead(A3) );
    //Filtering based on the work of Mads Hobye http://www.diva-portal.org/smash/get/diva2:1404339/FULLTEXT01.pdf#page=195
    filtered = filtered * 0.999 + raw * 0.001;

    //Animation
    Matrix.clearDisplay(1);

    if ( filtered > 3 ) {
      levelFive();
    } else if ( filtered > 2.5 ) {
      levelFour();
    } else if ( filtered > 2 ) {
      levelThree();
    } else if ( filtered > 1.5 ) {
      levelTwo();
    } else if ( filtered > 1 ) {
      levelOne();
    } else {
      levelZero();
    }

    //Intensity
    Matrix.setIntensity(1, constrain(filtered, 1, 15) * 2 );
}

void levelZero() {
    Matrix.setLed(1, 3, 3, true);
    Matrix.setLed(1, 4, 3, true);
    Matrix.setLed(1, 3, 4, true);
    Matrix.setLed(1, 4, 4, true);
}

void levelOne() {
    for ( int row = 2; row < 6; row++ ) {
        for ( int col = 2; col < 6; col++ ) {
            if ( (col == 2 && row == 2) || (col == 5 && row == 2) || (col == 5 && row == 5) || (col == 2 && row == 5) ) {
                continue;
            }
            Matrix.setLed(1, row, col, true);
        }
    }
}

void levelTwo() {
    for ( int row = 1; row < 7; row++ ) {
        for ( int col = 1; col < 7; col++ ) {
            if ( (col == 1 && row == 1) || (col == 2 && row == 1) || (col == 5 && row == 1) || (col == 6 && row == 1) ||
                (col == 1 && row == 6) || (col == 2 && row == 6) || (col == 5 && row == 6) || (col == 6 && row == 6) ||
                (col == 1 && row == 2) || (col == 6 && row == 2) ||
                (col == 1 && row == 5) || (col == 6 && row == 5) ) {
                continue;
            }
            Matrix.setLed(1, row, col, true);
        }
    }
}


void levelThree() {
    for ( int row = 0; row < 8; row++ ) {
        for ( int col = 0; col < 8; col++ ) {
            if ( (col == 0 && row == 0) || (col == 1 && row == 0) || (col == 2 && row == 0) || (col == 5 && row == 0) || (col == 6 && row == 0) || (col == 7 && row == 0) ||
                (col == 0 && row == 1) || (col == 1 && row == 1) || (col == 6 && row == 1) || (col == 7 && row == 1) ||
                (col == 0 && row == 2) || (col == 7 && row == 2) ||
                (col == 0 && row == 5) || (col == 7 && row == 5) ||
                (col == 0 && row == 6) || (col == 1 && row == 6) || (col == 6 && row == 6) || (col == 7 && row == 6) ||
                (col == 0 && row == 7) || (col == 1 && row == 7) || (col == 2 && row == 7) || (col == 5 && row == 7) || (col == 6 && row == 7) || (col == 7 && row == 7) ) {
                continue;
            }
            Matrix.setLed(1, row, col, true);
        }
    }
}

void levelFour() {
    for ( int row = 0; row < 8; row++ ) {
        for ( int col = 0; col < 8; col++ ) {
            if ( (col == 0 && row == 0) || (col == 1 && row == 0) || (col == 6 && row == 0) || (col == 7 && row == 0) ||
                (col == 0 && row == 1) || (col == 7 && row == 1) ||
                (col == 0 && row == 6) || (col == 7 && row == 6) ||
                (col == 0 && row == 7) || (col == 1 && row == 7) || (col == 6 && row == 7) || (col == 7 && row == 7) ) {
                continue;
            }
            Matrix.setLed(1, row, col, true);
        }
    }
}

void levelFive() {
    for ( int row = 0; row < 8; row++ ) {
        for ( int col = 0; col < 8; col++ ) {
            Matrix.setLed(1, row, col, true);
        }
    }
}