Category: blog

DCA Events WordPress Plugin displays events from the NMDCA Media Center Events API

See docs: https://github.com/NMHU-SSD/dca-events-wp-plugin

I have been working on a beacon based app for visitors with blind/low vision accessibility needs as a pilot project for Acadia National Park. The overall goal is to allow visitors to follow along tour path of 9 stops. To keep track of the visitors position, I am using the Estimote Indoor location beacons.

screen shots:

 

I have been working on two 55′ inch touch table interactives for the Anderson-Abruzzo Albuquerque International Balloon Museum and their upcoming exhibit on S.A. Andree’s failed attempt to get to the North Pole via hot air balloon in 1897.

Early Prototype screenshots:

The first touch table will be embedded in a antique table and housed in a space designed as a victorian study. The table will feature vintage diaries that contain content about SA Andree’s expedition plan and other polar expeditions at the time.

The second table will be embedded in an iceberg shape and housed in a space referred to as the Ice Room. The table will feature content based on the events of SA Andree’s flight and artifacts found at the crews final camp on White Island.

The framework for both interactives have been developed with Hammer.js, an open-source javascript gesture library and NW.js, a tool which packages and distributes node.js based web apps as desktop applications.

demo
demo code

Cystic Fibrosis is a recessive genetic disorder that affects the lungs, as well as pancreas, liver, and intestine. The CF gene produces a mutant protein that interferes with cells’ ability to manage chloride. This causes secretions throughout the body to thicken, and turn dry/gluey. In the ducts of the pancreas, the flow of digestive enzymes becomes blocked, making a child less able to absorb food, which leads to poor growth. However, the effects on the lungs are what make CF lethal. Thickened mucus will slowly fill the small airways of the lungs and harden, thus shrinking the lung capacity.Typically, a child with CF has to be monitored daily for energy levels, appetite, and cough frequency. This data is useful in determining treatments.

The Little Devices Lab at MIT focuses on the design, intervention, and policy spaces for DIY health technologies. By developing a series of medical technology prototyping kits, the Lab has provided new materials and “plug-and-play” components to help nurses and doctors expand their ideas and solutions for better patient care.

The Lab was approached by a parent/nurse to develop a wearable sensor to measure and record her child’s cough frequency. Ultimately, the wearable sensor would be able to transfer the data to a smart phone (or some other means for storing data) enabling physicians and parents to keep track of a child’s health.

Through the opportunities of the MSSD program, I was able to prototype the wearable cystic fibrosis cough monitor for the Little Devices Lab using open-source electronics and software.

My initial tests were to determine cough occurrences based on movement and sound. I began the project using an Arduino, as well as two breakout boards for accelerometer and microphone data. However, these components are bulky. When it comes to wearable electronics, size and power matter. Since the CF monitor is intended to be a wearable device, I researched other microcontrollers. The relatively small Flora and can be sewn into fabric and washed. It also makes use of rechargeable micro-lipo batteries. With the onboard 3.3v 150mA regulator, the Flora can power most common modules and sensors. I then migrated my tests from the Arduino version to the Flora.

For this prototype, I used a velcro strip as an armband to hold the components.

presentation

This Halloween I was tasked with designing a few themed interactives.

CHOOSE YOUR LEVEL OF FEAR

I came up with a couple of ideas, one being a choose your own adventure style interactive where participants can select a level of fear they are comfortable with. On a scale from 1 to 5 (1 being the lowest), participants are unknowingly selecting a possibly creepy halloween themed gif to be projected on a scrim in the hallway they will walk through.

SETUP

Using foam board, I constructed a basic control box to house all the electronic components.

The arduino is connected to breadboard with LEDs, potentiometer, and servo motor.

The arduino is also connected to a macbook with long HDMI cable connected to pico pocket projector mounted in the hall.

MOTORIZED SPIDERS

I planned to have spiders drop down from the ceiling when movement is detected. I started prototyping with servo motors but in order to wind up the spider in both directions, I then moved onto a couple DC toy hobby motors from Adafruit. However, working with DC motors was quite the challenge. There was so much troubleshooting involved and the hobby motors I got turned out not to be ideal. I had purchased a few different sized halloween spiders, but the motors torque and size could not handle the weight of any of the spiders. Due to this issue, I constructed some spiders out of pipe cleaners. Eventually, everything worked.

SETUP

Again, I constructed another foam board box to be mounted to the ceiling/wall and house all the electronic components.

A PING sensor is long enough to be mounted to the side of the wall. This will be triggered when participants walk by.

Watch this video to see the interactives in action.

For further documentation of the Haunted Hallway project, feel free to download this PDF.

Conductive Rubber Cord (Stretch Sensor)

Similar to a thermistor, the program measures the analog voltage and converts that back to resistance. When stretched, resistance is detected and the conductive rubber cord lights an LED.

// Sensor pin - GND
// Sensor pin - Analog In 0, with 10K resistor to +5V
int LedPin = 13;    // LED connected to analog pin 13
int SensorPin = A0;    // Sensor connected to analog pin A0
 
 
void setup()
{
    // initialize serial communications
    Serial.begin(9600); 
}
 
void loop()
{
    // read the voltage from the voltage divider (sensor plus resistor)
    int sensor = analogRead(SensorPin);
    
    /*
    analog range to output
    map(value, fromLow, fromHigh, toLow, toHigh)
    value: the number to map
    fromLow: the lower bound of the value's current range
    fromHigh: the upper bound of the value's current range
    toLow: the lower bound of the value's target range
    toHigh: the upper bound of the value's target range
    */
    
    int output = map(sensor, 30, 70, 0, 255);
    
    // print out the result
    Serial.print("analog input: ");
    Serial.print(sensor,DEC);
    Serial.print(" output: ");
    Serial.println(output,DEC);
    
    analogWrite(LedPin, output);    
 
    // pause before taking the next reading
    delay(100); 
}

Conductive Rubber Cord from Adafruit

Sensor + Arduino + Xbee transmitting data to Raspberry Pi + Xbee that tweets if moisture has been detected.

How does it work?

The moisture sensor is an Arduino connected to Xbee Adaptor and a printed circuit board with 555 timer. Leads are connected to a sponge that send resistance data to the circuit board. Arduino reads the data, adds the time and transmits the data to an Xbee connected to a Raspberry Pi. The Raspberry Pi sends out a Tweet with moisture status, e.g., “Extreme Moisture”.

Materials

Xbee (transfer/recieve), breadboard, leads, sponge, Arduino Uno, Raspberry Pi, USB wifi dongle, printed circuit board for 555 timer to take moisture readings

Moisture sensor using a 555 timer IC (Express PCB)

A way of quantifying the amount of moisture in a porous medium is to measure its electrical resistance. Typically, the higher the water content lower its resistance. Under most circumstances the resistance is in the mega-ohm (million ohms) range. As a reference a 100 feet of copper wire that would be used in house wiring has the resistance of a few Ohms at most. A moist medium has one-million times more resistance. We wanted to make a sensor that will give a number that is compatible with the kinds of data that an Arduino can comfortably handle, that would be an integer and between 1 and 20,000 or so.

One way of doing this is to make an resistor-capacitor (RC) circuit we could somehow charge up the capacitor and let it discharge through the moist resistive medium. A common 555 timer integrated circuit chip (IC) uses an RC circuit for its time base. We have exploited this feature to make a moisture sensor that can be triggered and read by an Arduino. The 555 can be configured in a number of ways for this application, we chose to use as a monostable-multi vibrator, a one-shot. Send the circuit a trigger pulse and the 555 will produce an output whose duration is determined by the values or the resistor and capacitor used for its time base. In this case the resistor will be the moist medium and we can choose a capacitor that will produce a pulse of 100’s or a few thousand milliseconds long (0.1 sec to a few seconds).

We tested it with damp paper towels and sponges to determine that a 1uF capacitor works well giving a pulse out of about 500-1000 milliseconds. We decided to measure moisture in milliseconds. The shorter the time, the higher the water content of the medium. Since we were going to deploy a number of sensors we designed a small printed circuit board for the sensor sent our design off to expresspcb.com to make the bare board.

Arduino + Xbee  transmits to Raspberry PI + Xbee

Each setup has its own script for receiving or transmitting data.

Initial Raspberry Pi Set Up

To streamline the development process, we set up remote access via ssh. To complete this, we connected a usb wifi dongle to the Pi. The wifi connection is also important to the set up as we need internet access for the twitter implementation.

Serial Communication with the Raspberry Pi

During development, we researched Raspberry Pi GPIO and USB serial communications. One method for accessing the the GPIO pins is through UART, or universal asynchronous receiver/transmitter. UART is the piece of hardware that translates data between parallel and serial forms. By default, the the Raspberry Pi serial is configured to use the UART for console input and output. However, that means the Serial Port could not be used in our program. In order to access the dedicated UART pins on the raspberry pi, the serial ports needed to be reconfigured. After a few modifications, we can then receive communications. We later came to the decision to make use of an FTDI usb cable connected directly to an Xbee receiver.

We chose to use pySerial, a module that allows for access to the serial port in your python script. Like other python modules, pySerial needs to be installed and then imported in your program.

The serial data created by the moisture sensing circuit board is transmitted from the Arduino to Raspberry Pi between Xbees via radio frequency.

The Pi uses pySerial to accept that data. It begins by importing data from the specified USB port. Each Xbee that is transmitting data has been given a specific numerical name that is converted into a readable ID of Xbee 1 or Xbee 2 when its presence is detected.

Based on the values we were seeing in our tests, we specified any value of 3500 or above to mean that there is no moisture detected. A moisture status message is sent to the console and Twitter every time data is received. A value in the range of 700-1499 has a moisture status of “Extreme Moisture”. Likewise, 1500-2249 is “Medium Moisture”, and 2250-3500 is “Minimum Moisture.” Each time moisture is detected, the program resets itself to false and waits for the new data to be received.

Twitter Implementation
To access the Twitter API via Python, we chose to use Tweepy, the well known Twitter for Python library. In order to set up Authentication keys, we signed up for the Twitter Developer account.

What are Beacons/iBeacon?

Beacons are hardware that use Bluetooth Low Energy to advertise a Universally Unique Identifier (UUID) to devices, like a smartphone. iBeacon is Apple’s protocol for accessing the UUID data advertised by a Beacon. This technology allows for proximity sensing and indoor  positioning. For example, a device can alert a user if they are in range of a beacon and enable information based on that location.

Beacon hardware, such as Estimote or Gimbal, are fairly inexpensive. However, it is also really simple to build your own with a Raspberry Pi.

Resource: How to make a Pi Beacon from Radius Networks

Raspberry Pi Beacon transmitter

Using a Bluetooth LE Dongle connected to a Raspberry Pi and a script to transmit a UUID, the Raspberry Pi can act as a Beacon.

Resource: Installing Bluetooth on a Raspberry Pi from modmypi.com

To advertise the UUID on startup, I ran the script from /etc/rc.local

edit /etc/rc.local command

~$ sudo nano /etc/rc.local

While inside the editor, modify /etc/rc.local so that the raspberry pi can navigate to the directory of the beacon script and run it.

cd /home/pi/PiBeacon
sudo bash startBeacon

startBeacon script

stopBeacon script

 

iOS Beacon Receiver app
After reading the iBeacon documentation and researching the Estimote SDK, I developed a sample application that displays a different clickable icon based on the level of proximity to my Raspberry Pi Beacon. Depending on which icon is clicked, different content is displayed.

 

 

Levels of proximity:

Wifi
Install wifi dongle for internet access on the Pi

Twitter/Tweepy
Tweepy is a Python library for accessing the Twitter API. In order to use the library, I first had to set up Authentication keys by signing up for the Twitter Developer account.

sample python tweepy script:
Tweet.py

#!/usr/bin/env python

import sys
import tweepy

#api keys from twitter
CONSUMER_KEY = 'XXXXXXXXXX'
CONSUMER_SECRET = 'XXXXXXXXXX'
ACCESS_KEY = 'XXXXXXXXXX'
ACCESS_SECRET = 'XXXXXXXXXX'

auth = tweepy.OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET)
auth.set_access_token(ACCESS_KEY, ACCESS_SECRET)
api = tweepy.API(auth)
api.update_status(sys.argv[1])

terminal command:

python Tweet.py "Hello, from my Pi"

I connected a picam and a thermal printer to a raspberry pi. When you press a button, the camera will take a picture and immediately print the image.

Materials

Raspberry Pi
PiCam
Mini Thermal Receipt Printer
breadboard
jumper wires
10k resistor
button

Thermal Printer Tutorials

Little Box of Geek Project from Geek Gurl Diaries
Part 1
Part 2

Picam Tutorial

Python PiCam Setutp from Raspberry Pi

Gustave Baumann was born in Germany and emigrated to the United States at the age of ten. While he is known as an American artist, primarily as a printmaker, his marionette skills were deeply rooted in his German heritage.

The New Mexico Museum of Art in Santa Fe owns a collection of over seventy marionettes carved by artist Gustave Baumann during the 1920s and 30s. Their age and fragility means that they are rarely displayed and never used as designed. Figuring out a way to surface this collection and to encourage an interactive experience has been a goal for the collection’s curators for a long time.

The museum approached the development team from Media Arts & Technology at New Mexico Highlands University. In order to allow visitors to interact with a rarely seen collection, five of these unique marionettes have been scanned via photogrammetry. Using current technology, the scans have been repurposed to demonstrate the articulation of the marionettes.

The project involves the Microsoft Kinect hardware and software written for Unity3d to allow the user to embody a marionette. I recently prototyped another version which uses the Leap Motion Controller hardware and Javascript to provide the user with the fine-tuned experience of controlling a marionette’s movements.

The Leap Motion Controller has a significantly finer range than the Kinect and is an ideal solution to complete the user experience. Using the Javascript framework for Leap, marionette data is attached to ragdoll physics bodies which respond to fine movements of the user’s fingers and hands. The idea was to mimic the control planes used by traditional puppeteers, but I discovered the Leap hardware has some sensitivity issues sensing the roll of a user’s hand. Pitch and yaw are easily readable, but this would give an incomplete experience, so I modified the metaphor to give the feeling of controlling the strings directly with the user’s fingers.

The Baumann Marionettes Interactive will be included in the exhibit “Gustave Baumann: A Santa Fe Legend”, which opened at the Las Cruces Museum of Art in February 2014.

demo site: lpb-riannetrujillo.com/marionettes

I’m interested in gesture based interfaces and have been learning about the Leap Motion controller, which is a device that senses hands, fingers and multiple gestures, allowing you to interact with content in a new way.

Below is some source code I wrote for an example that tracks a color changing circle to your fingers. If you have a Leap, check out the demo.

index.html

main.js

document.addEventListener("DOMContentLoaded", init);

var canvas;
var ctx;

function init() { 
	
	canvas = document.getElementById("leap-canvas");

	// fullscreen
	canvas.width = document.body.clientWidth;
	canvas.height = document.body.clientHeight;

	// create a rendering context
	ctx = canvas.getContext("2d");
	ctx.translate(canvas.width/2,canvas.height);

	//change color of pointable at interval
	setInterval(color, 50);
	
	
	// listen to Leap Motion
	Leap.loop(draw);
	
}

function color() {

	//rgb color
	this.r = Math.floor(Math.random() * 255);
	this.g = Math.floor(Math.random() * 255);
	this.b = Math.floor(Math.random() * 255);
	
    ctx.fillStyle = "rgb("+ this.r +", "+ this.g +", "+ this.b +")";
    
}

// render each frame
function draw(obj) {
  // clear last frame
  ctx.clearRect(-canvas.width/2,-canvas.height,canvas.width,canvas.height);
  
  // render circles based on pointable positions
  var pointablesMap = obj.pointablesMap;
  for (var i in pointablesMap) {
    // get the pointable's position
    var pointable = pointablesMap[i];
    var pos = pointable.tipPosition;

    // create a circle for each pointable
    var radius = Math.min(600/Math.abs(pos[2]),20);
    ctx.beginPath();
    ctx.arc(pos[0]-radius/2,-pos[1]-radius/2,radius,0,2*Math.PI);
    ctx.fill();	

   }	

}

Download from Github

After a brief introduction to Processing and reading Making Things See by Greg Borenstein, I developed a few projects using Processing and the Kinect.

In order to use the Kinect with Processing, I used the Simple OpenNI library, which is an OpenNI and NITE wrapper.

“Eat Me, Drink Me” Project
Using physical 3D printed objects as an interface, Alice (of Wonderland) will grow or shrink depending on which object the user picks.

Wii Paint is a desktop application I wrote in Objective-C. It works in use with a Wii Remote, a battery operated IR Sensor Bar, and DarwiinRemote, an application that maps keyboard keys to Wii Remote buttons.

Keyboard Keys for WiiPaint Desktop application:
n is for new canvas (clears the screen)
b goes back in the array of colors
c goes forward n the array of colors

Using IR mode will map mouse movements to Wii Remote movements with an IR Sensor.

Darwiin Preferences:

THE TIMELINE
Life’s origins is represented as series of events depicted through earth’s geosphere and biosphere. The exhibit timeline also includes specimens and illustrations of early earth, as well as the formation of earth.

THE PROJECT
Design and develop an interactive version of the exhibit timeline.

KEY COMPONENTS
text (bio/geo content)
images (earth illustrations)
audio/video (scientist interviews)
easily up-dateable (by museum staff)
designed for iPad (for use in exhibit)
accessible on the web (for use in classroom)

DESIGN & DEVELOPMENT
Use of the following:
HTML5/CSS3 + Canvas XML
Javascript
fancybox + jQuery

THE CHALLENGES
The overall challenge of this project has been the fact that it is still early in the HTML5 adoption cycle and there is limited documentation on Canvas implementation.

ISSUES
– Re-sizing based on browser window
– Click Coordinates
– Drawing Video on iPad

SOLUTIONS
– Cross-browser/platform Testing
– Use Open Source Frameworks/Libraries/Tools (fancybox)

Demo Site (best viewed in Chrome Browser): lpb-riannetrujillo.com/emergence

Below is a short example of my use of CSS media queries for the Alcoves 12.0 responsive website.

Navigation HTML

Navigation CSS

nav {
    width: auto;
    height: auto;
    margin-top: -80px;
    margin-right: 40px;
    padding: 0;
    float: right;
    /* background */
    background: #404c5f;
}

nav ul {list-style: none;}

nav ul li {
	float: left;
	position: relative;
}

nav ul li a {
	font-weight: bold;
	color: #fff;
	display: block;
	padding: 10px 20px;
	text-decoration: none;
}

nav ul li a:hover {color: #7791ae;}
nav ul li:hover, active {background: none;}
nav  ul li ul { display:none;  background: #4c617a; }
nav  ul li:hover ul { display:block; position:absolute;}
nav  ul li ul li {color:#fff; width: 180px; display:inline-block; float: left;}
nav ul li:hover ul li {background: none;  }
nav ul li:hover ul a {padding: 5px 20px;}
nav ul li:hover ul a:hover {background: #647d99; }


@media screen and (max-width: 720px) {
  nav {
	width: 100%;
	height: auto;
	margin: 0;
	padding: 0;
        position: relative;
	/* box shadow */
	-webkit-box-shadow: inset 0 1px 0 rgba(255,255,255,.1), 0 0px 1px rgba(0,0,0,.4);
	-moz-box-shadow: inset 0 1px 0 rgba(255,255,255,.1), 0 0px 1px rgba(0,0,0,.4);
        box-shadow: inset 0 1px  rgba(255,255,255,.1), 0 0px 1px rgba(0,0,0,.4);
    }

    nav ul li a {
	font-weight: bold;
	color: #fff;
	display: block;
	padding: 10px 40px;
	text-decoration: none;
    }
    
    nav ul li a:hover {color: #fff;}
    nav ul li:hover, active{background: #58595b;}
}

I’m currently in my third term of the program interning at The New Mexico Museum of Art, as well as the New Mexico Museum of Natural History & Science.

At The New Mexico Museum of Art I was tasked with creating a gallery kiosk to showcase artists from the Alcove Shows. Alcove 12.0 included the work of 45 artists from across the state of New Mexico. Five new artists were exhibited every five weeks. The Kiosk would allow visitors to preview work from previous weeks. Throughout the remainder of the internship, I programmed various gallery interactives to include additional videos and/or photos for exhibits. I also designed templates to be used for events, as well as a redesign and style guide for creating  email blasts.

While at the New Mexico Museum of Natural History & Science, I was able to revisit an exhibit I worked on as a student in 2011. As part of National Science Foundation funding, Emergence: A New View of Life’s Origins  exhibit was to provide educational resources and teacher materials. I redesigned the Emergence website and included a resources section. I also designed promotional materials. Promo materials and resources that could be placed on custom USB drives were mailed to science education teachers in New Mexico.

Overall, I think being able to gain experience in various institutions has prepared me for future employment.  My experience with AmeriCorps has been invaluable.

Last week, I attended Museums and the Web in one of my favorite cities, Portland. I served as a conference volunteer, as well as a representative for NMHU and AmeriCorps. It was a really great experience being able to network with others in the museum and technology field.

Here is a short video I compiled after my trip.

Below is a Black Jack text based game I developed in C++.

blackjack.cpp file

//============================================================================
// Name        : blackjack.cpp
// Author      : Rianne Trujillo
// Version     :
// Copyright   : 
// Description : Black Jack in C++
//============================================================================

#include 
#include 

#include "dealer.h"
#include "player.h"

using namespace std;

int main() {

	//display game title
	cout << "BLACKJACK\n" << endl;

	//player class + human instance
	Player human;
	//if playerName is set to default, ask for name
	if (human.name=="default") {
		std::string playerName;
		cout << "Enter Your Name: ";
		cin >> playerName;
		human.name = playerName;
		cout<<endl;
	}

	//Print Greeting
	cout << "Welcome " << human.name << ". Let's Play!\n" << endl;

	human.newGame();

	return 0;

}

player.cpp file

/*
 * player.cpp
 */


#include "player.h"
#include "dealer.h"

Player::Player () {
	name="default";
}


void Player::play21(void) {

	//randomize the cards
	srand((int) time(0));

	//classes+instances
	Dealer dealer;
	Player player;

	// deal the cards
	int person = dealer.dealCards(2, "Your Cards:");
	std::cout << " = " << person;
	std::cout << "\n";
	int computer = dealer.dealCards(2, "Computer's Cards:");
	std::cout <<" = " << computer;
	std::cout << "\n";
	// Ask if human wants a hit
	//player.hit(person);

	char takeHit = 'y';
		while (takeHit != 'n') {
			if (person < 21) {
				//does the player want a hit?
				std::cout << "\nDo you want a hit (y/n)? ";
				std::cin >> takeHit;
				//If yes
				if (takeHit == 'y'){
					//Deal a card
					person += dealer.dealCards(1,"\nHit:");
					std::cout << "\n";
					//total
					std::cout << "Total: " << person << "\n";

				} else //the player does not want another card
				takeHit ='n';
			} else {
				//the player has busted
				if (person > 21)
				std::cout <<"\nYOU BUSTED!\n";
				takeHit ='n';
			}
		}

	//Determine if computer takes a hit
	while ((computer < person) && (computer <= 21) && (person <= 21)) {
		std::cout << "\n";
		computer += dealer.dealCards(1,"The Computer took a card: ");
	}

	//show who won.
	dealer.determineWinner(person, computer);

}

void Player::newGame(void){
	char keepPlaying;
	//set variable for keepPlaying char to n
	keepPlaying = 'n';

	do {//do play21 function while keepPlaying = y
		play21();

		//ask for keepPlaying input
		std::cout << "\nDo you want to play another hand (y/n)?";
		std::cin >> keepPlaying;
		std::cout << "\n";

	} while (keepPlaying=='y');

	if  (keepPlaying=='n')  {//if no, print game over
		std::cout << "\nGAME OVER.\nThanks For playing!";
	}

}

player.h file

/*
 * player.h
 */

#ifndef PLAYER_H_
#define PLAYER_H_

#include 
#include 

class Player {
	public:
	// properties:
	std::string name;
	void play21(void);
	void newGame(void);
	Player();

private:
	std::string playerName;

};


#endif /* PLAYER_H_ */

dealer.cpp file

/*
 * dealer.cpp
 */

//dealer  shuffles cards and
//gives card to players when they ask for hit

#include "dealer.h"
#include "player.h"

Dealer::Dealer() {
	personScore = 0;
	computerScore = 0;

}


int Dealer::dealCards(int numCards, std::string message){
	//deal cards
	//set cardDealt and totalValue to 0
	int cardDealt = 0;
	int totalValue = 0;
	//print players cards to the screen
	std::cout << message << " ";
	//deal the number of required cards
	for (int i = 1 ; i <= numCards ; i++){
		//deal a card between 1 and 10
		cardDealt = Shuffle(1, 10);
		//if card dealt is equal to 1
		if (cardDealt == 1){
			//and if total value of card dealt is less than 10
			if (totalValue+=cardDealt > 10)
			//card is 11
			cardDealt =11;
			//card is 1
			else {cardDealt =1;}
		}

		//accumulate the card values
		//totalValue is equal to the number of cards dealt
		totalValue += cardDealt;
		std::cout << cardDealt << " ";
	}
	//return total value
	return totalValue;
}


void Dealer::determineWinner(int person, int computer) {
	this->computerScore=computer;
	this->personScore=person;

	//Display total scores
	std::cout <<"\nYour Score: " << person;
	std::cout <<"\nComputer Score: " << computer;
	std::cout << "\n";

	//Display winner
	//if person is equal to computer, its a tie
	//if person = 21, or => computer, or computer is > than 21, person wins
	//else computer wins
	if (person == computer)
	std::cout << "\nTie";
	else if ((person == 21 || person >= computer|| computer > 21) && (person <= 21))
	std::cout <<"\nYou Won!\n";
	else
	std::cout <<"\nThe Computer Won!\n";
}

int Dealer::Shuffle(int lowerLimit, int upperLimit) {
	//returns a random number within the given boundary
	return 1 + rand() % (upperLimit - lowerLimit + 1);
}

dealer.h file

/*
 * dealer.h
 */

#ifndef DEALER_H_
#define DEALER_H_

#include 
#include 

class Dealer {
public:
	int dealCards(int numCards, std:: string message);
	void determineWinner(int person, int computer);
	int Shuffle(int lowerLimit, int upperLimit);
	Dealer();

private:
	int personScore;
	int computerScore;

};

#endif /* DEALER_H_ */

When my previous Americorp internship ended in August 2011, I decided to re-enroll for a full time position. In October, I continued interning at the same institution, while splitting time at the New Mexico Department of Cultural Affairs. Over the course of a year, I was able to continue utilizing and developing my skills.

At The Albuquerque Museum of Art and History, I was able to design and develop an iOS App that provided artwork and artist information for the ISEA2012 Exhibition installed at the Albuquerque Museum of Art & History.  I was also given the opportunity to design posters, brochures, and educational booklets. During Albuquerque’s centennial, I created a scavenger hunt using SCVNGR. I designed signage for how to play as well as a recognizable stickers to be placed near Artworks related to the scavenger hunt.

At the New Mexico Department of Cultural Affairs, I designed and developed the backend for the Office of Archaeological Studies Pottery Typology Project Website. The admin side interface allows users to enter pottery based types into a database. I also provided content management and developed registration forms for the New Mexico Association of Museum Annual Conference.

In September of 2012, I took a course in Javascript. Below is a simple random word haiku generator I wrote.

html file

.js file

After graduating from New Mexico Highlands University in May 2011, I enrolled in the AmeriCorps Cultural Technology program. Soon, I began a minimum time position as an intern at The Albuquerque Museum of Art and History. My scope of work consisted of recording and editing audio, as well as designing and developing a mobile audio tour of the museum’s sculpture garden.