The Unsorted Hat

STORYBOARD / CONCEPT

The title of this project, "The Unsorted Hat," refers to the buried and unsorted traumatic memories of people afflicted with Complex PTSD (C-PTSD). Because it is difficult to process deeply buried memories and let them go, people with C-PTSD tend to have intrusive thoughts that are tied to any of the 5 senses instead of full-fledged cinematic flashbacks. Because C-PTSD flashbacks/dissociation are more abstract and live inside the mind, it is difficult to externalize them or even express how one is feeling when these intrusive thoughts occur. This hat uses sound as an outlet for these intrusive thoughts. When it detects that the room has become too quiet, it plays a snippet of a caustic mental rant on loop until the room fills with noise again. This intervention externalizes how C-PTSD survivors have to cope with these thoughts by bringing them aurally to the surface and disrupting an outside environment.

Circuit

HARDWARE

What drives the hat's screaming is a simple circuit that comprises a microphone, a speaker, a DFPlayer Mini, and a Photon (please disregard the potentiometer, as it's irrelevant). The Photon already sends 3V to the breadboard to power the electronics, so there is no need for an external power source. The DFPlayer Mini reads a micro SD that contains a sound file that I recorded. Upon testing the microphone, I found that it doesn't have a very wide range and requires close proximity or extremely loud noises in order to pick up sound.

The hat itself was designed in Rhino and laser cut from cardboard. It measures approximately 16" in diameter, making it a very oversized and exaggerated hat that can fit all sizes. It has a compartment at the top to hold the circuit, as well as a whimsical (if not a little creepy) smiley face on the front. The humorous and cheery nature of the hat's packaging is juxtaposed with the upsetting, intense recordings that it plays.

Code

// Setup Variables
# define Start_Byte 0x7E
# define Version_Byte 0xFF
# define Command_Length 0x06
# define End_Byte 0xEF
# define Acknowledge 0x00 //Returns info with command 0x41 [0x01: info, 0x00: no info]
# define micPin A5

int volume;
int micReading;
const int sampleWindow = 50; // Sample window width in mS (50 mS = 20Hz)
unsigned int sample;

// Wrote by Ype Brada
void execute_CMD(byte CMD, byte Par1, byte Par2) // Excecute the command and parameters
{
    // Calculate the checksum (2 bytes)
    int16_t checksum = -(Version_Byte + Command_Length + CMD + Acknowledge + Par1 + Par2);
    // Build the command line
    byte Command_line[10] = { Start_Byte, Version_Byte, Command_Length, CMD, Acknowledge, Par1, Par2, checksum >> 8, checksum & 0xFF, End_Byte};
    //Send the command line to the module
    for (byte k=0; k<10; k++)
    {
        Serial1.write( Command_line[k]);
        }
    }

    /****************************************
    Example Sound Level Sketch for the 
    Adafruit Microphone Amplifier
    ****************************************/

void setup () {
    Serial.begin(9600);
    Serial1.begin(9600);
    execute_CMD(0x3F, 0, 0); // Send request for initialization parameters
    // Wait until initialization parameters are received
    while (Serial1.available()<10)
    // Pretty long delays between successive commands needed
    delay(10);
    // Initialize sound to very low volume. Adapt according used speaker and wanted volume
    execute_CMD(0x06, 0, 30);
    // Set the volume (0x00~0x30)
    }

void loop () {
  unsigned long startMillis= millis();  // Start of sample window
  unsigned int peakToPeak = 0;   // peak-to-peak level

  unsigned int signalMax = 0;
  unsigned int signalMin = 4096;

  // collect data for 50 mS
  while (millis() - startMillis < sampleWindow)
  {
     sample = analogRead(micPin);
     if (sample < 4096)  // toss out spurious readings
     {
        if (sample > signalMax)
        {
           signalMax = sample;  // save just the max levels
        }
        else if (sample < signalMin)
        {
           signalMin = sample;  // save just the min levels
        }
     }
  }
  peakToPeak = signalMax - signalMin;  // max - min = peak-peak amplitude
 //  double volts = (peakToPeak * 5.0) / 4096;  // convert to volts

  // Serial.println(peakToPeak);
    if (peakToPeak < 120) {
      execute_CMD(0x0D,0,1);
      delay(3000);
    }
    else {
      execute_CMD(0x11, 0, 0x00);
    }
}

Victoria Yong, Wei Wei (2019) - https://learn.adafruit.com/adafruit-microphone-amplifier-breakout/measuring-sound-levels Click to Expand

CODE

This Particle code allows the Photon to communicate with the DFPlayer Mini and the microphone. It measures sound in 50 ms increments and delays recording so that the hat does not pick up on its own sound when it is playing the file. When the increment's sound is below the threshold, the hat automatically plays the recording on the DFPlayer Mini. This code was modified from a DFPlayer sample in class and an example sound level measuring code from Adafruit, found at this link: https://learn.adafruit.com/adafruit-microphone-amplifier-breakout/measuring-sound-levels

In addition, I recorded a 15-second rant (based on accounts of C-PTSD survivors' intrusive thoughts) on Audacity and split the recording into 5 .mp3 files to upload to the DFPlayer Mini. I originally intended for the code to randomly select a recording from the group of 5, but because I wanted to keep things simple I uploaded only 1 file.

The creator of this ridiculous hat sporting her creation.

- https://vimeo.com/317251963

FINAL PRODUCT

In this video, the hat loops the recording ("You're one of the most selfish people I've ever seen!") again and again until I yell at the hat. Whenever it detects that I have stopped yelling, the hat plays the recording.

Start the Conversation

Share this Project

Found In

Objects of Memory

Courses

48528 Responsive Mobile Environments

· 18 members
This 15-week course introduces students to responsive mobile environments and encourages them to explore speculative terrains that intersect art, technology and design and space. Iteratively, intro...more

About

To externalize the intrusive memories of people who have Complex PTSD (C-PTSD), I created a whimsical-looking hat that plays looped recordings of intrusive sound-based memories. The hat starts screaming when the surrounding environment is quiet, thus disrupting the silence until there is enough noise and conversation in the room again. Because people who have C-PTSD have abstracted mental flashbacks, this project shows how snippets of buried traumatic memories can surface in everyday life.