In this book, the author talks about 3 specific areas that effect the “feel” of a game. He describes feel as being, “Real-time control of virtual objects in a simulated space, with interactions emphasized by polish”.

Real-Time Control
This is comprised of a interactivity between at least tow participants. Each participant actively communicates with each other though a combination of input and output feedback. Bellow, Swink describes this process as it pertains to computer games and their participants.

The user has some intent, which is expressed to the computer in the form of the user’s input. The computer reconciles this input with its own internal model and outputs the results. The user then perceives the changes, thinks about how they compare to the original intent, and formulates a new action, which is expressed to the computer through another input.

Simulated Spaces
These are are comprised of physical interaction that take place in a virtual space. Through the use of level design, collision detection, and physics, the game designer is able to give meaning to the games movement. The surrounding visuals offer a frame of reference for the player to get the impression of speed. “Using the avatar as a channel for expression and perception, we experience game worlds at the tactile, physical level of the world around us.”

Polish
Polish is comprised of all this tiny details that “artificially enhance” a players interaction without changing any of the games core functionality. Examples of these could be dust particles on ground, sound effects, camera shakes. These effects, add the games overall appeal and allow for the game to seem more “real”.

Bellow is a quick exercise that I coded taking some of the concepts that Steve Swink speaks about in his first chapter. There is no goal in this simulation, just wanted to see if I could evoke a feeling while i walked around.

First Person Shooter using Unity 3d
The controls are:

• move: A,S,W,D keys
• jump: Space
• head movement : Mouse
• shoot: Right Mouse Click
• fullscreen: Left Mouse Click > Go Fullscreen

Please view the full post to see the Unity content.

In this exercise I spent most of my time on the “polish”, mainly because it allowed me to learn how to code small details that help in adding to a user’s immersion. Some of these include a far from refined particle effect when you shoot the terrain, slight head bobbing motion when your avatar runs, and some ambiant noise and background music to further capture a “feeling”. Obviously there are loads of other effects that I could add to this experiment, but I think it helped me get a better understanding of what Steve Swink was getting at in his chapter.

In a Gamastra article called “Q&A: Kaos On Homefront, Importance Of ‘Authenticity’ In Online Shooters“, when asked about the story element of Homefront, they noted that there aren’t traditional cut scenes, just some backstory, and in game narrative:

We’re not doing any kind of cut scenes or anything like that; it’s really about the atmosphere and the ambiance… I think it’s just up to us to really accentuate the atmospheric elements that really help create that fun experience for the player that feels different and feels unique.

Reference:
Swink, Steve (2008-10-13). Game Feel: A Game Designer’s Guide to Virtual Sensation (Morgan Kaufmann Game Design Books). Morgan Kaufmann. Kindle Edition.

In a world where we all feel so “connected”, the people that matter most have no method of remotely interacting with us.  My 1 1/2 year has no twitter, or Facebook account to update.  She doesn’t check into fourSquare every time we go to grandma’s house. Even with mobile phones and Skype video conferencing, there is no direct method of me interacting with her without the assistance and supervision of an adult. So basically, we could only interact with each other when another adult has both the time and is willing to put in the effort to set up an environment for us to communicate.

This got me thinking “how can my daughter and I interact during my work hours?”  The first thing I did was identify the main characteristics of my daughter, back when I first started working on this project:

• My daughter was one year old.
• Her vocal communication ability was in the preliminary stages of development
• Her motor skills where still not fully developed, so complex tasks like using a keyboard or mouse where not possible.
• She needs adult assistance to use our everyday communication tools that available to us (moble and land-line phones, computers, etc).

At this young age, children are extremely dependent on their parents and other adults for just about everything.  However, there are also several activities that come as naturally as breathing and eating to a child. Two of those activities that i observed where exploration and play, many times triggered by a common catalyst of curiosity.

Children gradually explore their environment and toys and interacted with them, mastering the new skills that they learn along the way. Quickly they are able to identify all sorts of toy input locations which triggered various types of output, such as audio and visual feedback.

Many people are quick to suggest that we need to expose children to computers at an early age, I don’t disagree.  However, there is no reason that we need to take a child to a some cold desk, when where they are already in-front of their toy box. Why not instead bring the computer to them, in their own natural environment, and make them available on their own terms. Computers come in various shapes and sizes, and are all around us. In washing machines, toasters, and most of the objects we interact with on a daily basis have them. Just look around you right now, I’m sure you would be surprised on the amount of digital technology that is surrounding you at this moment.

Digital toys, and interactive plush dolls are nothing new. Companies suck as Leap Frog have thrived on making toys which have been getting smarter and smarter. With the introduction of micro-controllers embedded deep inside their soft cuddly exterior, there are endless possibilities.  So that was my answer, I would prototype a interactive based toy solution, that both an adult and child could easily use to communicate with each other.  It is too easy to go into fantasy land with a project like this, so here were my self-imposed rules:

1. The toy must not cost more then $39 retail, since that is my personal breaking point for interactive toys.
2. It must work anywhere, and not be totally dependent on a network connection.
3. The child must need zero guidance to interact with the toy.
4. The toy must promote exploration
5. There must be some learning activities.
6. I must be able to interact with the toy from my office

Putting it all Together

I knew that I would like a toy that enabled “me” to interact with my child via audio or video, however I started seeing that as an obvious solution and not very cost of effective.  Why should parents be forced to buy individual toys for each person that would like to interact with the child?  My daughter has a mother, aunts, grandparents, etc. Would it be feasible of me buying one for each person?  More importantly, would the child be able to interact with such a fragmented family of toys at such an early age? What would be the total cost, $39 a piece? That is pretty steep, and won’t work as a solution in my opinion.  Taking all these questions into account gave me my “ah-ha” moment.  My family and I are part of my daughter’s social network, as exclusive as it may be. Looking at the toy as a social network would mean incorporating several functions that a typical social network would have.  I decided that the most important social network functions that my toy should support where:

• Avatars
• Buddy List
• Messaging

The Birth of my ChatterPillar

I decided to go with a completely modular design, so I could play off the metaphor of a family unit. One unit, one toy, multiple facets. Each facet containing unique actions associated to that family member. The modular design would also allow me to add and remove modules as I please.  This allows my toy to take a very literal approach to a buddy list.  If you wanted to add a buddy you would have to physically add your buddy to the toy and vice-versa. It also allowed for an interesting business model, add all the costly circuitry in the head (the brain) and allow for less expensive body modules to take advantage of the brains powersupply, and various other components like speakers, memory, etc. This along with some inner circuit  communication was all i needed to create the beginnings of what turned out to be myChatterPillar.  Bellow is a video showing my initial alpha prototype of myChatterPillar in action.

Main Features

My ChatterPillar has several features that have been incorporated into the design.

1. There is a photo sleeve on each of the detachable modules which serve as an avatar.
2. There are 3 audio switches. The one beneath the photo is to identify the family member, and the two on the legs is for adding any other audio, like messages, song, etc. These audio buckets are created online by the adult via a accompanying web site, and the files are later synced to the toy via a tethered USB connection.
3. Adults could remotely communicate with the toy and send messages to it via familiar technology such as email, twitter and SMS
4. Embeded assessments to test the child’s familiarity with their family and colors.

Where to go from here

My next steps are to take this toy out of it’s bread board stage, and into a more complete embodiment. I initially looked at this project as a method of communicating with my daughter, but would be great to get it out there some day so other families could also enjoy interacting with their young children. To be continued….

Obviously, calling <mx:Application /> to fake the old _root method of communicating with nested SWFs is not exactly the best way to go about this. Instead I favor using and Event driven approach.

This the code to create a simple external SWF with 5 textfields. Each textfield is clickable and will dispatch a custom event which broadcast the value of the textfield.

SWF Code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

package {
	import com.events.ExternalSwfEvents;
 
	import flash.display.Sprite;
	import flash.events.MouseEvent;
	import flash.text.TextField;
 
	public class SampleSWF extends Sprite
	{
		public function SampleSWF()
		{
			for(var i:int=0; i<5; i++){
				var tf:TextField = new TextField();
				tf.autoSize = "left";
				tf.text = "Click me from External SWF " + i;
				tf.y = tf.height * i;
				tf.selectable = false;
				tf.addEventListener(MouseEvent.CLICK, handleClick);
				this.addChild(tf)
			}
		}
 
		private function handleClick(event:MouseEvent):void
		{
			var tf:TextField = event.target as TextField;
//Make sure you set bubbles & cancelable to true		
this.dispatchEvent(new ExternalSwfEvents(ExternalSwfEvents.TEXT_CLICKED, tf.text, true, true));
		}
	}
}

Take notice of the comment that states “Make sure you set bubbles & cancelable to true”. It is necessary to bubble this event because it may be nested several layers deep inside of the SWF.

Custom Event named ExternalSwfEvents.as:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

package com.events
{
	import flash.events.Event;
 
	public class ExternalSwfEvents extends Event
	{
		public static const TEXT_CLICKED:String = "textClicked";
 
		private var value:String;
 
		public function ExternalSwfEvents(type:String, value:String, bubbles:Boolean=false, cancelable:Boolean=false)
		{
			super(type, bubbles, cancelable);
			this.value = value;
		}
 
	}
}

So at this moment, the external SWF has no idea that it is an external app, nor does it know who or where the Flex application is. All it knows is that it has some data stored in “value” that it would like to share with the world. If someone decided to listen for it, then they will be able to know what the contents of “value” are. If not then no worries, it’s there if I ever decide I want to know what “value” is.

In my example I am going to load this file in Flex using SWFLoader.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

<?xml version="1.0" encoding="utf-8"?>
<mx:Application backgroundColor="#FF0000" xmlns:mx="http://www.adobe.com/2006/mxml" layout="absolute">
	<mx:Script>
		<![CDATA[
			import com.events.ExternalSwfEvents;
			import mx.controls.Alert;
 
			private function swfReady(event:Event):void
			{
				trace("COMPLETE");
				mySWF.content.addEventListener(ExternalSwfEvents.TEXT_CLICKED, handleEvent);
			}
 
 
			private function handleEvent(event:ExternalSwfEvents):void
			{
				Alert.show("You Clicked: " + event.value);
			}
		]]>
	</mx:Script>
	<mx:SWFLoader id="mySWF" complete="swfReady(event)" source="assets/SampleSWF.swf"  />
</mx:Application>

Using this approach I know exactly what handleEvent is doing. I also know exactly what it will be receiving and when it will be receiving it. A much nicer and cleaner approach to the

From Arduino Site:

Wire.begin()
Wire.begin(address)
====
Description
Initiate the Wire library and join the I2C bus as a master or slave.
====
Parameters
address: the 7-bit slave address (optional); if not specified, join the bus as a master.
====
Returns
none

I interpreted this explanation as Wire.begin(SomeAddress) would default as a slave, and not be allowed to be a Master. Being as curious, and stubborn as I typically am, i decided to forget what I thought I was being told, and instead try to break the library, so I could then see where it broke, and attempt to adjust it in a way that better suited my need. Surprise, surprise, it worked, and not need to change anything at all! The address parameter is optional and defaults as a master role if no address is set. However if you do plan on sending messages to the master, you could switch speaker and listener roles via a slaves Wire.onReceive(handler) rather then polling using onRequest(handler).

I then decided to do a search on google for just “i2c”. When I clicked on the Wikipedia entry it all made sense in the first sentence of the entry summary:

I²C (Inter-Integrated Circuit) (pronounced /ˈaɪ skwɛərd ˈsiː/ or /ˈaɪ tuː ˈsiː/) is a multi-master serial single-ended computer bus…

This basically states that no one microcontroller (unless you do not specify an address) could claim being a master at all time. They could be bumped off their soupbox by another microcontrol and assume the role of listener/slave at anytime.

In the accompanying video, I give a quick run through of how the circuit works. Essentially, the main goal that I was able to achieve was that I would be able to clone one the inner circuits and add it right in the middle. All I would need to do is connect them to the 2 digital pins, 2 analog pins, one ground, and one 5V series, and it should work without any additional rewiring (although the idea is to make the sub circuits slightly different in their interaction, yet the same in their communication), asides from programing the EEPROM (I used the 24LC256 from SparkFun for $1.95) to contain a unique identifier. The secret to success…diodes..lots of them.

I based my code on a great snippet of code to help me get the I2C communication working on my EEPROMs. I also checked out a helpful tutorial which also helped me out substantially.

One quick tip: Keep in mind that Arduino has an EEPROM mounted on the chip. I intially made the silly mistake of using the EEPROM code that is found on the Arduino tutorial page. This code was reading and writing data on my Arduino’s board mounted EEPROM, which i quickly realized once I realized that the unique data I was writing on each external EEPROM chip did not seem to be working properly.

So why go through all this extra effort? Basically there are two reasons.

1) allowing a person to customize and interchange their toy gives them an added sense of ownership, and taps into an emotional type of attachment.
2) it is pretty easy to come up with a ways of taking the ideas behind this circuit, and give very young children the ability to construct abstract concepts such as flow. This in turn makes this simple interaction material a digital manipulative with extraordinary educational benefit.

One of my points of inspiration was MIT’s Mitchel Resnic’s Programmable Beads , and other work with digital manipulative that I’ve spoken about on other posts.

Onto phase 2…

Here is a video of Mitch Resnick speaking about his Lifelong Kindergarten group at the MIT Media Lab

Bellow is an updated version of my previous Arduino coding. I plan on switching the status updating to the Processing side, instead of the Arduino side. If this where to be a real product, it would be easier to download a software update, then to have to reprogram the toy itself. I will add that to my todo list, once i get all the major functionality working.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

// BUTTONS
const int buttonGreen = 8;
const int buttonRed = 9;
const int buttonYellow = 10;
 
//LEDS
const int ledGreen =  2;
const int ledRed =  3;
const int ledYellow =  4;
 
//STORE BUTTON STATES
int greenState = 0;
int redState = 0;
int yellowState = 0;
 
int lastActiveLED = 0; // Keep track of the activeLED
 
void setup() {
  Serial.begin(9600);
 
  pinMode(ledGreen, OUTPUT);
  pinMode(ledRed, OUTPUT);
  pinMode(ledYellow, OUTPUT);
 
  pinMode(buttonGreen, INPUT); 
  pinMode(buttonRed, INPUT); 
  pinMode(buttonYellow, INPUT); 
 
}
 
void loop(){
  // CHECK BTN STATES
  greenState = digitalRead(buttonGreen);
  redState = digitalRead(buttonRed);
  yellowState = digitalRead(buttonYellow);
 
  /**********
   *  Each of the following conditionals only sends one Serial message
   *  per button press
   **********/
 
  //GREEN
  if (greenState == HIGH) {
   //check if last active LED was not Green 
    if(lastActiveLED != ledGreen){
      //print the respective message for each button only once per mouse press. End message transmission with '10' which is linefeed.
      Serial.print("green");
      Serial.print(10, BYTE);
    }   
    //store green as last active press
    lastActiveLED = ledGreen;
    digitalWrite(ledGreen, HIGH);
  } 
  else {
    //clear out last active so you could reclick it
    if(lastActiveLED == ledGreen){
      lastActiveLED = 0;
    }
    digitalWrite(ledGreen, LOW);
    delay(100);
  }
 
  //RED
  if (redState == HIGH) {    
    if(lastActiveLED != ledRed){
      Serial.print("red");
      Serial.print(10, BYTE);
    }   
    lastActiveLED = ledRed;
    digitalWrite(ledRed, HIGH);
    delay(100);
  } 
  else {
    if(lastActiveLED == ledRed){
      lastActiveLED = 0;
    }
    digitalWrite(ledRed, LOW); 
  }
 
  //YELLOW
  if (yellowState == HIGH) {    
    if(lastActiveLED != ledYellow){
      Serial.print("yellow");
      Serial.print(10, BYTE);
    }   
    lastActiveLED = ledYellow;
    digitalWrite(ledYellow, HIGH);
    delay(100);
  } 
  else {
    if(lastActiveLED == ledYellow){
      lastActiveLED = 0;
    }
    digitalWrite(ledYellow, LOW);
  }
}

Now that we are sending message, we need to listen. I decided to go with Processing since I’ve always been curious about it, and it is about as seamless of a coding experience as you could possibly get with Arduino.

In order to get the Twitter4J Java Library working you first needed to drag the .jar file directly onto your Processing sketch, and that is pretty much it. Bellow is the Processing code that simply listens for a Serial Event (Arduino button press), and then sends the status message over to Twitter.

Being a total N00bie to Processing, one additional tip that confused me was Fonts. Processing doesn’t allow True Type Fonts, so if you want to add text to your project you need to go to:

Tools > Create Fonts…

and then select the font you would like to use. The Processing IDE then converts the font to a .vlw file. You could find the file in a folder named ‘data’ that gets created within your projected folder.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

/*************
*    based on:  http://processing.org/reference/libraries/serial/serialEvent_.html
*************/
 
import processing.serial.*; 
 
Serial myPort;    // The serial port 
PFont myFont;     // The display font 
String inString;  // Input string from serial port 
int lf = 10;      // ASCII linefeed 
 
Twitter twitter;  // Twitter
 
//Going to get oAuth working instead of this, but this will do for now
String username = "YOUR-TWITTER-USERNAME"; // you Twitter Username Here
String password = "YOUR-TWITTER-PASSWORD"; // your Twitter Password Here
 
void setup() { 
  size(400,200);
  twitter = new Twitter(username,password);
  myFont = loadFont("AppleGothic-48.vlw"); 
  textFont(myFont, 18); 
  println(Serial.list()); 
  myPort = new Serial(this, Serial.list()[0], 9600); 
  myPort.bufferUntil(lf); //wiat for line feed to specify end of serial buffer
} 
 
void draw() { 
  background(100); 
  text("color selected: " + inString, 10,50); 
} 
 
void serialEvent(Serial p) {
  inString = p.readString();//read serial string
  //For some reason this only wanted to work in a try catch
  try
  {
    Status status1 = twitter.updateStatus("Arduino's favorite color is "+inString);//update twitter status
  }
  catch( TwitterException e)  {
    println(e.getStatusCode());
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

// BUTTONS
const int buttonGreen = 8;
 
//LEDS
const int ledGreen =  2;
 
//STORE BUTTON STATES
int greenState = 0;
 
 
void setup() {
  Serial.begin(9600);
 
  pinMode(ledGreen, OUTPUT);
  pinMode(buttonGreen, INPUT); 
}
 
void loop(){
  // CHECK BTN STATES
  greenState = digitalRead(buttonGreen);
 
  //GREEN
  if (greenState == HIGH) {
  Serial.print(ledGreen, DEC);
    digitalWrite(ledGreen, HIGH);
  } 
  else {
    digitalWrite(ledGreen, LOW); 
  }

When i check my serial monitor I receive something like:
22222222222222222222222222…..

That won’t work, since I plan for each of the Serial events to make an API call to Twitter. This activity would wipe out my allotted request in a matter of a couple of clicks, and probably would result in getting my account suspended due to unusual activity. So bellow is a quick fix which store individual button clicks, and prints out the Serial output once. I also decided against using any delays, since that may have potentially ended up in ignoring a button press.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

// BUTTONS
const int buttonGreen = 8;
const int buttonRed = 9;
const int buttonYellow = 10;
 
//LEDS
const int ledGreen =  2;
const int ledRed =  3;
const int ledYellow =  4;
 
//STORE BUTTON STATES
int greenState = 0;
int redState = 0;
int yellowState = 0;
 
 
int lastActiveLED = 0; // Keep track of the activeLED
 
void setup() {
  Serial.begin(9600);
 
  pinMode(ledGreen, OUTPUT);
  pinMode(ledRed, OUTPUT);
  pinMode(ledYellow, OUTPUT);
 
  pinMode(buttonGreen, INPUT); 
  pinMode(buttonRed, INPUT); 
  pinMode(buttonYellow, INPUT); 
 
}
 
void loop(){
  // CHECK BTN STATES
  greenState = digitalRead(buttonGreen);
  redState = digitalRead(buttonRed);
  yellowState = digitalRead(buttonYellow);
 
  /**********
   *  Each of the following conditionals only sends one Serial message
   *  per button press
   **********/
 
  //GREEN
  if (greenState == HIGH) {
   //check if last active LED was not Green 
    if(lastActiveLED != ledGreen){
      //print Green since it is a new press
      Serial.print(ledGreen, DEC);
    }   
    //store green as last active press
    lastActiveLED = ledGreen;
    digitalWrite(ledGreen, HIGH);
  } 
  else {
    //clear out last active so you could reclick it
    if(lastActiveLED == ledGreen){
      lastActiveLED = 0;
    }
    digitalWrite(ledGreen, LOW); 
  }
 
  //RED
  if (redState == HIGH) {    
    if(lastActiveLED != ledRed){
      Serial.print(ledRed, DEC);
    }   
    lastActiveLED = ledRed;
    digitalWrite(ledRed, HIGH);
    delay(100);
  } 
  else {
    if(lastActiveLED == ledRed){
      lastActiveLED = 0;
    }
    digitalWrite(ledRed, LOW); 
  }
 
  //YELLOW
  if (yellowState == HIGH) {    
    if(lastActiveLED != ledYellow){
      Serial.print(ledYellow, DEC);
    }   
    lastActiveLED = ledYellow;
    digitalWrite(ledYellow, HIGH);
    delay(100);
  } 
  else {
    if(lastActiveLED == ledYellow){
      lastActiveLED = 0;
    }
    digitalWrite(ledYellow, LOW);
  }
}

If anyone knows of any other methods of doing this, let me know!

I tried to keep both programming and circuitry as slim as I could, and I think that worked out pretty well. Not sure if i will add anything else to this, but if anyone has any ideas, asides from my coworker’s recent tweet, then Iet me know.

This source code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220

 /*
   Simon Sez
 
 
  created Feb 10 2010
  by Alex Britez
 
  http://blog.unthinkmedia.com/?p=475
 
  */
 
#include <Tone.h>
 
Tone audioFeedback;
 
//DEFINE MOTOR
int transistorPin = 12; 
 
int speakerPin = 6; 
 
//DEFINE LEDS
int ledWhite = 11;
int ledGreen = 10;
int ledRed = 9;
int ledYellow = 8;
 
char leds[] = {
  ledWhite,ledGreen,ledRed,ledYellow};
 
//DEFINE SWITCHES 
int switchWhite = 5;
int switchGreen = 4;
int switchRed = 3;
int switchYellow = 2;
 
//AUDIO
int notes[] = {
  NOTE_D4,NOTE_E4,NOTE_F4,NOTE_G4};
//this plays if you win
int winNotes[] = {
  NOTE_D4, NOTE_E4,NOTE_C4,NOTE_C3,NOTE_G3 };
int durations[] = {
  500, 500, 500, 500, 1000};
 
 
 
//
int playbackCount = 0;//autoplay selection count
int selectionCount= 0;//player selection count
 
int currentLevel = 0;//current game level
 
boolean watchMode = true; //Simon's turn, false means it is the players turn 
 
//store which switch is currently active?
int pressAry[] = {
  0,0,0,0};
 
//Storing the squence that gets randomly generated, Num in brackets states how long sequence is [#]
int sequenceAry[7];
int sequenceAryLegnth = sizeof(sequenceAry) / sizeof(int);
 
void setup()
{
  pinMode(ledWhite, OUTPUT);
  pinMode(ledGreen, OUTPUT);
  pinMode(ledRed, OUTPUT);     
  pinMode(ledYellow, OUTPUT);
  pinMode(switchWhite, INPUT);
  pinMode(switchGreen, INPUT);
  pinMode(switchRed, INPUT);     
  pinMode(switchYellow, INPUT);
  pinMode(transistorPin, OUTPUT);
 
  randomSeed(analogRead(0));//Add this so sequence is truely random
  audioFeedback.begin(speakerPin);
  createRandomSequence();
}
 
void loop()
{
  /************
   *  Check to see if simon/player mode
   *************/
  if(watchMode == true){
   /************
   *  SIMON SEZ: leds automatically blink in random sequence
   *************/
    //have you won?
    if(playbackCount <= sequenceAryLegnth){
      //has simon finshed showing current sequence?
      if(playbackCount < currentLevel){
        //Blink proper LED from leds array
        int activeLED_index = sequenceAry[playbackCount];
        digitalWrite(leds[activeLED_index], HIGH);
        //Play corrisponding note
        audioFeedback.play(notes[activeLED_index]);
        delay(200);
        digitalWrite(leds[activeLED_index], LOW);
        audioFeedback.stop();
        delay(200);
        playbackCount++;
      }
      else{
        //simon is done, now it is players turn
        watchMode = false;
      }
    }
    else{
       /************
       *  PLAYER WINS!
       *************/
      playerWins();
    }
  }
  else{
 
    //Read States of all Switches
    int whiteState = digitalRead(switchWhite);
    int greenState = digitalRead(switchGreen);
    int redState = digitalRead(switchRed);
    int yellowState = digitalRead(switchYellow);
 
    int statesAry[] = {
      whiteState,greenState,redState,yellowState};
 
    //loop across all 4 switch states
    for(int x=0; x<4; x++){
      int switchState = statesAry[x];
      if(switchState == 1){
        audioFeedback.play(notes[x]);
        digitalWrite(leds[x], HIGH);
        delay(200);
        audioFeedback.stop();
        digitalWrite(leds[x], LOW);
 
        if(pressAry[x]==0){
          if(sequenceAry[selectionCount]==x){
            selectionCount++;
            pressAry[x] = 1;
          }
          else{
            resetGame();
          }
 
        }
 
      }
      else{
        pressAry[x] = 0;
        // turn LED off:
        digitalWrite(leds[x], LOW); 
      }
 
      //Check to see if we could incrament level
      if(selectionCount == currentLevel){
        advanceLevel();
      }
    }
 
  }
 
}
 
 
void createRandomSequence(){
   for(int x=0; x<sequenceAryLegnth; x++){
      sequenceAry[x] = random(0, 4);
   } 
 
}
 
/************
 *  Play winning melody
 *************/
void playerWins(){
  for (int thisNote = 0; thisNote < 5; thisNote ++) {
    // play the next note:
    audioFeedback.play(winNotes[thisNote]);
    // hold the note:
    delay(durations[thisNote]);
    // stop for the next note:
    audioFeedback.stop();
  }
  // hold before repeating:
  delay(3000);
}
 
/************
 *  Incrament player one level
 *************/
void advanceLevel(){
  resetValues();
  currentLevel++;
  delay(200);
} 
 
/************
 *  Player pressed wrong button
 *************/
void resetGame(){
  //DISPATCH HAPTIC FEEDBACK 
  digitalWrite(transistorPin, HIGH);
  delay(1000);
  digitalWrite(transistorPin, LOW);
  delay(1000);
 
  resetValues();
  currentLevel = 0;
  delay(1000);
}
 
/************
 *  Reset all values so simon knows to start from the first LED in the sequenceAry
 *************/
void resetValues(){
  selectionCount = 0;
  playbackCount = 0;
  watchMode = true;
}

Anyhow, armed with some basic knowledge of electronics, and some programming knowledge, why not! Bellow is my stab at Simon, I even added some haptic feedback just because. The audio is a bit low because it was 1am and I didn’t want to wake up my wife and daughter, but you get the idea.

Before I post up the code, I need to clean it up a little bit and get a bit more acquainted with C. The programing language that Ardiuno uses is pretty bare bones, so a lot of common functions that i have taken for granted don’t exist, go figure. Not a big deal, it will just take some research and tinkering to figure it out.

Another issue i had was regarding resistor setup, an 8 ohm speaker, and it’s affect to what i believe is the audio pitch. The sound that plays during Simon’s turn and the sound of the same note that play during the button press is slightly different. May need to bring out the multi-meter and see how many ohms are being passed through, in both scenarios. I am using the Arduino Tone Library. I’ll add my findings in my next post once i find some free time to get my debugging hat on. Other then that, my first real project went pretty smoothly.

As I mentioned, once I iron out these small bugs, I will post all the source and wiring, then take it apart and move onto my next project. Homework has never been so much fun…ha!

The game is pretty much a maze that gets created “on the fly” (I really hate that phrase) by intersections that close off on each turn. The goal of the game is to beat the computer to the your homebase which is the space that the computer starts on (sort of like Chinese Checkers, but with one marble and maze) The first person to get to their homebase wins.  Use your arrow keys to move around.

Source View is here, so go bananas (I like that phrase).