Week 2 Progress

Goals for Week 2:

1. Confirm room location after discussing options with Stephanie Wanek
2. Look into projector vs. TV resources available from ATLAS
3. Have hardware ordered (Sparkfun and Amazon) and magnets purchased (McGuckin)
4. Complete 1 fractal visualization for user testing
5. Have transitions between Neopixel colors working with RFID tags
6. To-do list or timeline of UX stuff/milestones/user tests

What We Accomplished & Learned:

First, we came up with a list of user experience questions we want to test, and a rough timeline of when to test various parts of our project.

List of UX questions we want answered/tested:

Fractal Visuals

• How did you feel while looking at the fractals?
• Is anything about this overwhelming?
• How long would you want to watch this for?
• How would you change the speed or colors for a more calming experience?

Controls

• How quickly did you figure out what to do?
• Were you surprised by anything that happened?
• Describe anything that felt especially natural or unnatural?
• How did you feel about the size, weight, texture of the controls?

Order of Operations/User Flow

• Did you feel like there was a “right” way to experience or interact with the space?
• Were you confused by anything?

Ambience

• Did you feel calmer leaving the space than you did entering it?
• How long would you want to spend in this space?
• Describe anything that felt especially natural or unnatural?
• Is anything about this overwhelming?
• Would you visit this space again?
• What could we change to improve the experience for you?

UX Testing Timeline

Initial controls/fractal testing (Jan. 30th)

• Is changing environment with RFID cubes intuitive?
• Do people understand what to do with the phone slot?
• What do people like or dislike about the fractals?

User flow and interaction testing (Feb. 13th)

• Do people move through the experience like we expect them to (phone slot first, picking environment, watching fractals)?
• Are people confused about or struggling with anything?
• Initial impressions/advice for improving the experience?

Cohesiveness of experience/ambience testing (Mar. 5th)

• Did anything take away (or add to) your experience?
• Would you change anything about the layout or ambience of the space?
• What was your biggest takeaway from the experience?

RFID Tags and Neopixels

Next, we worked on getting our Neopixels to work seamlessly with our RFID technology, so that smooth color transitions will occur as the environment is changed by the user.

We started off by jumping back into our RFID prototype from last semester. The first thing to do was to clean up our code a bit and make it easier to read and more streamlined. Then, we converted the code from using the Adafruit Neopixel library to be using the FastLED library, since we had determined that FastLED would allow for more advanced functionality in our LED animations. This wasn’t too bad, but required some research and lots of documentation-reading, including this tutorial to get things working. One of the most confusing parts was using color correction to adjust for discrepancies in how the human eye views Neopixels and how they appear on a screen, but it turned out to be one line of code.

We also decided to start using HSV (hue, saturation, value) instead of the typical RGB notation for our colors, because FastLED supports it and it will hopefully make operations like dimming and brightening our LEDs simpler. We found a great bit of code from Mark Kriegsman (one of the developers of FastLED) that allowed for smooth color transitions towards a target color. First, we tested out the code with our system to see how it worked:

Then, we adapted to code to create smooth transitions between colors for different environments when the user places a new RFID tag on the reader. The code is flexible enough that it can transition between any two colors smoothly (or fading to/from black) as seen in the video below:

Since we had that working, we wanted to take things one step farther and add another LED strip and a switch into the circuit. With two LED strips, we could more realistically simulate what our final project will look like. One strip functions as the room’s lighting (corresponding to the different environments), while the other strip will work with the phone slot (lighting up red when no phone is in place, or transitioning to green when a phone is present). As you can see in the video below, when the switch is triggered, the lights turn green and RFID tags can change the color of the room LED strip. If the switch is released (ie. a phone is removed from the slot), the switch lights turn back to red and the room LEDs fade back to black. Eventually, we will probably change this “standby” color from black to something else, but for now, the code works exactly as intended!

	#include <SPI.h>
	#include <MFRC522.h>
	#define SS_PIN 53 //SDA Pin
	#define RST_PIN 5
	MFRC522 mfrc522(SS_PIN, RST_PIN); // Instance of the mfrc522 class
	#include <FastLED.h> //FastLED library
	#define FIRST_STRIP_NUM_LEDS 5 //ONLY FOR FIRST LED STRIP
	#define SECOND_STRIP_NUM_LEDS 10 //ONLY FOR FIRST LED STRIP
	#define FIRST_DATA_PIN 22
	#define SECOND_DATA_PIN 24
	CRGB first_leds[FIRST_STRIP_NUM_LEDS]; //array for storing led colors
	CRGB second_leds[SECOND_STRIP_NUM_LEDS];
	// ~~~~~~~~~~~~~~~~~~~~~~ DEFINE COLORS ~~~~~~~~~~~~~~~~~~~~~~
	// Desert – Gold / brown
	CRGB desert = CHSV(40,255,255);
	// Underwater – Deep blues / dark
	CRGB water = CHSV(170,255,255);
	// Rainforest – Deep greens / dark
	CRGB forest = CHSV(105,255,255);
	// Grassland – Light greens / yellows
	CRGB grass = CHSV(73,255,255);
	// Beach – Light blues / tans
	CRGB beach = CHSV(130,255,255);
	CRGB targetColor;
	int switchPin;
	void setup() {
	//Initialize
	Serial.begin(9600);
	SPI.begin(); // Init SPI bus
	mfrc522.PCD_Init(); // Init MFRC522
	FastLED.setBrightness(50);
	FastLED.addLeds<NEOPIXEL, FIRST_DATA_PIN>(first_leds, FIRST_STRIP_NUM_LEDS).setCorrection(TypicalLEDStrip);
	FastLED.addLeds<NEOPIXEL, SECOND_DATA_PIN>(second_leds, SECOND_STRIP_NUM_LEDS).setCorrection(TypicalLEDStrip);
	Serial.println("RFID reading UID");
	delay(3000);
	pinMode(A14, INPUT);
	}
	void loop() {
	Serial.println(analogRead(A14));
	switchPin = analogRead(A14);
	if (switchPin < 900){
	fadeTowardColor( first_leds, SECOND_STRIP_NUM_LEDS, CRGB::Red, 5);
	fadeTowardColor( second_leds, SECOND_STRIP_NUM_LEDS, CRGB::Black, 5);
	FastLED.show();
	FastLED.delay(10);
	} else {
	fadeTowardColor( first_leds, SECOND_STRIP_NUM_LEDS, CRGB::Green, 5);
	FastLED.show();
	if ( mfrc522.PICC_IsNewCardPresent()){
	if ( mfrc522.PICC_ReadCardSerial()){
	if (mfrc522.uid.uidByte[0] == 0x19 && mfrc522.uid.uidByte[1] == 0xE8 && mfrc522.uid.uidByte[2] == 0xB3 && mfrc522.uid.uidByte[3] == 0xB0) {
	targetColor = desert;
	}
	if (mfrc522.uid.uidByte[0] == 0xC9 && mfrc522.uid.uidByte[1] == 0xFA && mfrc522.uid.uidByte[2] == 0x21 && mfrc522.uid.uidByte[3] == 0xB3) {
	targetColor = water;
	}
	if (mfrc522.uid.uidByte[0] == 0xF9 && mfrc522.uid.uidByte[1] == 0xEC && mfrc522.uid.uidByte[2] == 0xC4 && mfrc522.uid.uidByte[3] == 0xB1) {
	targetColor = forest;
	}
	if (mfrc522.uid.uidByte[0] == 0xC9 && mfrc522.uid.uidByte[1] == 0xB1 && mfrc522.uid.uidByte[2] == 0xB6 && mfrc522.uid.uidByte[3] == 0xB0) {
	targetColor = grass;
	}
	if (mfrc522.uid.uidByte[0] == 0x29 && mfrc522.uid.uidByte[1] == 0x8E && mfrc522.uid.uidByte[2] == 0xAD && mfrc522.uid.uidByte[3] == 0xB0) {
	targetColor = beach;
	}
	Serial.print("Tag UID:");
	for (byte i = 0; i < mfrc522.uid.size; i++) {
	Serial.print(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " ");
	Serial.print(mfrc522.uid.uidByte[i], HEX);
	}
	Serial.println();
	mfrc522.PICC_HaltA();
	delay(1000);
	}
	} else {
	}
	// fade all existing pixels toward bgColor by "5" (out of 255)
	fadeTowardColor( second_leds, SECOND_STRIP_NUM_LEDS, targetColor, 5);
	FastLED.show();
	FastLED.delay(10);
	}
	}
	// Helper function that blends one uint8_t toward another by a given amount
	void nblendU8TowardU8( uint8_t& cur, const uint8_t target, uint8_t amount)
	{
	if( cur == target) return;
	if( cur < target ) {
	uint8_t delta = target – cur;
	delta = scale8_video( delta, amount);
	cur += delta;
	} else {
	uint8_t delta = cur – target;
	delta = scale8_video( delta, amount);
	cur -= delta;
	}
	}
	// Blend one CRGB color toward another CRGB color by a given amount.
	// Blending is linear, and done in the RGB color space.
	// This function modifies 'cur' in place.
	CRGB fadeTowardColor( CRGB& cur, const CRGB& target, uint8_t amount)
	{
	nblendU8TowardU8( cur.red, target.red, amount);
	nblendU8TowardU8( cur.green, target.green, amount);
	nblendU8TowardU8( cur.blue, target.blue, amount);
	return cur;
	}
	// Fade an entire array of CRGBs toward a given background color by a given amount
	// This function modifies the pixel array in place.
	void fadeTowardColor( CRGB* L, uint16_t N, const CRGB& bgColor, uint8_t fadeAmount)
	{
	for( uint16_t i = 0; i < N; i++) {
	fadeTowardColor( L[i], bgColor, fadeAmount);
	}
	}

view raw NeopixelTransitions.ino hosted with ❤ by GitHub

Fractal Visualization

Over the past week we have been developing our p5.js prototypes we had made last semester for our project pitch. We looked more into equations for curves occurring in nature (namely logarithmic curves) and how to use polar / cartesian equations in p5.js. Also, since ultimately our fractal visualization will be recurring, we need our code to do that efficiently. Although we put a lot of work into testing out how to do this, all of our attempts either overwhelmed the computer or got very visually overstimulating as it recurred (not what we want our user experience to be). So, here is the link to our p5.js sketch after working on it this week. We cleaned up the code a bit (there was previously a substantial amount of chaotic commented-out bits). From here we want to begin to intentionally incorporate color transitions that will match the lights, and successfully make our visualization recursive. By next week we hope to have two other variations of fractal visualizations to compare it with so we can gauge what users like / don’t like about each one.

Ordering Hardware

Last semester, we researched and calculated everything that we would need for our installation, and created a Bill of Materials with prices, quantities and descriptions for each item. This made ordering our parts pretty quick! However, we wanted to check things over with our mentor, Arielle Hein, before we committed, since she is an electronics wizard. Specifically, we were interested in whether the 5V 20A power supply we picked out would work well with around 450 LEDs. Arielle took a look at this and the rest of our materials for us, confirming that everything looked good.

We ordered the LED strips, power supply, and power supply adapter from Amazon. From Sparkfun, we ordered a pack of 10kΩ resistors and a stranded core wire pack so that we can start constructing our circuits.

ATLAS Room and Equipment Status

Last, we wanted to check in with Stephanie Wanek, the Chief of Operations for the ATLAS Institute, on the status of potential rooms in the ATLAS building that we could use to construct our project in. We emailed her about this and an equipment inquiry (specifically, whether we could use a projector for our fractal visualizations) last week. Stephanie emailed us back notifying us that everything was being sorted out, but she didn’t have an answer for us yet because the room and equipment availability for the semester was still being discussed. She promised that she would have more information for us soon!