Created: December 12th, 2021
0
Problem Space:
Interaction with music has been digitized, which leads to the loss of social interaction among people as well as tangible interaction with the music. We want to combine the aspects that users want from both types.
Our project is a semi-analog, semi-digital music player that combines the aspects of customization, curation, and algorithmic suggestions from digital music streaming services with the tangible aspects of more analog music technologies that current listeners also enjoy. The physical design of the product is similar to that of a record player.
Approach
PRODUCT:
There is a ‘base player’ (analogous to a record player) on which users can place one ‘playlist card’ (analogous to a single record). Each playlist card is connected to a specific digital playlist on Spotify that the user can choose and customize.
The playlist cards can be shared among any users that already have the base player as each card has a uniquely identifiable RFID tag that any player can read. This aspect allows this product to be used as a means of physical interaction with others: you can customize a playlist for someone on a playlist card (similar to how people “burned a CD” for their friends and family) and give it as a physical gift to others (or share it).
The base player will have a RFID tag reader that can read the digital data transmitted by the RFID tags embedded into the playlist cards. Each RFID tag transmits a unique ID signal, so we can identify which tag (or playlist) is currently placed on the player. Using Spotify’s API, we can then allow the specific playlist to be played on a user-specified speaker.
AMBIENCE:
The product itself is not inherently ambient in that users can either choose to actively utilize it to listen to music or they can play it as background music. We focused on creating a seamless design and experience for the user so that they could use it as an ambient device in the background in situations where they want to. For instance, to simplify the music streaming interface filled with numerous elements (album cover, user information, track information, etc.) that is common in applications like Spotify, we only wanted to have three simple buttons on the interface for on/off, pause/play, and skip.
The physical base player was also designed to have a calming look and blend in with whatever environment it is placed in. We used simple materials and colors (plywood, frosted acrylic and black acrylic) and a rectangular prism shape reminiscent of a record player.
Precedents
1. Juuke: https://www.instructables.com/Juuke-a-RFID-Music-Player-for-Elderly-and-Kids/
This product uses RFID technology to identify different song cards and play the corresponding song. It is a physical music player focused on ease of use.
It uses an Arduino Uno and music is played from the DFPlayer, a mini MP3 player designed for Arduinos. This product does not utilize internet connectivity, however, and uses a microSD card with pre-stored tracks.
I think that this product is a good example of moving music streaming into a more analog and tangible interface and serves as good inspiration for our product. In our project, we want to add the feature of connecting to existing music streaming services, from which we would gain access to millions without having the burden of storage.
2. Prizm: https://www.kickstarter.com/projects/prizm/prizm-turn-your-speakers-into-a-learning-music-pla
This product is a learning music player/speaker that senses the environment of the user (number of people, who is present, day, time, etc.) - i.e., it detects a specific context - and plays the right type of music you prefer in that specific context. You can add to the data my pressing the heart button (which also adds the song to your playlists). It connects to different music streaming services such as Spotify (and also free Souncloud accounts!) While the scope of this product is beyond the feasibility of a project we can pursue within a couple weeks, it is a very cool precedent that we can get inspiration from.
While our currently proposed project only takes in manual inputs, we could also use the programming aspect of IOT to create some sort of user-defined automated database about ‘context’. For instance, depending on the time of day, maybe the user wants to listen to different types/genres of ‘sad’ or ‘happy’ music.
This product also has an interesting connection feature: if someone else is with the user, the speaker can merge your music taste with theirs and choose songs that both people will enjoy.
For our project, we want to incorporate a connectivity component by letting users select songs for other users. It would be fun to think about how we can ‘merge’ various users’ music tastes through simpler means.
Storyboard:
In this process, we envision our project as a card-based music player which contains functions below
Choose Playlist:
By putting the card on the player, the Spotify API should reach to one's smart device and play the playlist accordingly.
Record or Edit the Playlist:
By clicking some button, users should be able to create their own playlist into a physical card. And the user could decorate the card.
Share:
Users can customize the card and give the card to friends who also have the player.
Prototype:
We planned to incorporate an RFID tag reader to the circuit so that when the user scans an RFID tag, the gramophone will play a preset playlist. However, we have met many difficulties when building up the gramophone like the RFID is not working properly. Hence, we came up with a backup plan to have simpler functionalities while still demonstrating our initial concept. We have three buttons that correspond to specific songs that matches the current mood. For example, the red button will play a song that can release your anger, and the yellow button can play a song that is happy.
Process:
Regarding the product design, we made a music box consisting of wood, frosted acrylic, and black acrylic. We designed a 3D model of the box and laser cut the pieces to put together.
To create the circuitry, we wired up three push buttons to be used as inputs indicating which song should be played.
We then used the IFTTT platform to translate the physical push of the buttons into a command to play a specific song. Initially, we tried to use the Spotify module to add the specific song to the queue (which was the closest functionality available on IFTTT to just playing the song), but that led to an error on the Spotify app as well. Instead, we decided to use the Android phone module so that the song could be played from the default music player on someone's Android device.
// This #include statement was automatically added by the Particle IDE.
#include "MFRC522.h"
long lastPublishedAt = 0;
int publishAfter = 1000;
int redPin = D4;
int greenPin = D3;
int bluePin = D2;
int ledRed = D5;
int ledGreen = D6;
int ledBlue = D7;
#define SS_PIN SS
#define RST_PIN D8
MFRC522 mfrc522(SS_PIN, RST_PIN); // Create MFRC522 instance.
String id = "";
long lastDetection = -1;
String lastDetected = "";
int redetectAfter = 10000;
void setup() {
pinMode(redPin, INPUT_PULLUP);
// pinMode(yellowPin, INPUT_PULLUP);
pinMode(greenPin, INPUT_PULLUP);
pinMode(bluePin, INPUT_PULLUP);
pinMode(ledRed,OUTPUT);
pinMode(ledGreen,OUTPUT);
pinMode(ledBlue,OUTPUT);
Serial.begin(9600); // Initialize serial communications with the PC
mfrc522.setSPIConfig(); // sets up SPI config
mfrc522.PCD_Init(); // Initialize RC522 card
Serial.println("Start Scanning");
Particle.publish( "started" );
}
void loop() {
int redVal = digitalRead(redPin);
int greenVal = digitalRead(greenPin);
int blueVal = digitalRead(bluePin);
if (redVal == LOW){
publishRedEvent();
digitalWrite(ledRed,HIGH);
delay(1000);
digitalWrite(ledRed,LOW);
}
if (greenVal == LOW){
publishGreenEvent();
digitalWrite(ledGreen,HIGH);
delay(1000);
digitalWrite(ledGreen,LOW);
}
if (blueVal == LOW){
publishBlueEvent();
digitalWrite(ledBlue,HIGH);
delay(1000);
digitalWrite(ledBlue,LOW);
}
// Look for new cards
if ( ! mfrc522.PICC_IsNewCardPresent()) {
return;
}
// Serial.println("New card Detected");
// Read tapped card data
if ( ! mfrc522.PICC_ReadCardSerial()) {
return;
}
// discover the id of the last item;
String rfid_card_id = "";
for (byte i = 0; i < mfrc522.uid.size; i++) {
// Create a RFID Hexdecimal String
rfid_card_id += String(mfrc522.uid.uidByte[i], HEX);
// Serial.print(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " ");
}
// Convert to Uppercase
rfid_card_id.toUpperCase();
// if a card hasn't been detected in x seconds/
// update
if( lastDetection + redetectAfter < millis() && rfid_card_id == "3CD8FA37" ){
lastDetection = millis();
Particle.publish("rme2019/memoryspaces/activity/location1", rfid_card_id );
}
delay(100);
}
void publishRedEvent() {
if(lastPublishedAt + publishAfter < millis() ){
String eventName = "red";
Particle.publish(eventName, "data");
lastPublishedAt = millis();
}
}
void publishGreenEvent() {
if(lastPublishedAt + publishAfter < millis() ){
String eventName = "green";
Particle.publish(eventName, "data");
lastPublishedAt = millis();
}
}
void publishBlueEvent() {
if(lastPublishedAt + publishAfter < millis() ){
String eventName = "blue";
Particle.publish(eventName, "data");
lastPublishedAt = millis();
}
}
String detectID(){
String rfid_card_id = "";
for (byte i = 0; i < mfrc522.uid.size; i++) {
// Create a RFID Hexdecimal String
rfid_card_id += String(mfrc522.uid.uidByte[i], HEX);
// Serial.print(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " ");
}
// Convert to Uppercase
rfid_card_id.toUpperCase();
return rfid_card_id;
}
Reflection and Critique:
I think our project was overall successful, but due to some technical limitations, we didn't succeed in achieving the results we envisioned, which is something I would like to remedy in the future. Secondly, in terms of product design, we should become more retro and make the card round to cover the RFID, making it more like a player.