Jul 05

Sketch 4

Copy and paste everything below the /****/ into a blank sketch.

/*****************************/
//Sketch_4
/* This program goes with Lab 4 of the OpenTag laser tag tutorial.
It plays a basic game of free for all laser tag. A player is out
if they get tagged 5 times.
*/

#include
//TimerOne will make it easy to pule an infrared LED 38,000 times
//a second

// Variables (nicknames for pins)
int button_pin = 12;
int led_pin = 11;
int ir_led_pin = 10;
int ir_receiver_pin = 9;

//you start with 5 health. This is the first time that we will use
//a variable to keep track of and change a number.
int health = 5;

void setup() {
//first, start up the TimerOne library. We want it to pulse
//38,000 times a second, which is about once every 26 milliseconds
Timer1.initialize(26);

//tell the arduino if a pin is input/output
pinMode( button_pin, INPUT);
pinMode(led_pin, OUTPUT);
pinMode(ir_led_pin, OUTPUT);
pinMode(ir_receiver_pin, INPUT);
}

void loop() {
int button_state = digitalRead( button_pin ); //read button
if (button_state == HIGH) { //if the button is pushed
/* If we are pushing the button, then we are trying to send
a tag. However, we can only tag if we have more than 0 health.
We can use the if statement and a comparative function called
greather than, which uses the > symbol. Greather than will
be true (the code in the if statement will be run) if the
number on the left is greather than the number on the right.
We want to send a tag if health is greater than 0. In code,
that is written as:
*/
if (health > 0){ //if we have health
//so, we know that we are pushing the button and have health
//now we can send a tag.
//first, pulse the infrared LED with the TimerOne code
Timer1.pwm(ir_led_pin, 512); //send pulse
delay(10); //delay for 10 milliseconds
Timer1.disablePwm(ir_led_pin); //turn off Timer One
}
}

//now, we want to see if we are getting tagged
int ir_receiver_state = digitalRead(ir_receiver_pin);
//if the receiver sees something, it will send a LOW or 0 signal
if (ir_receiver_state == 0){
//when we are tagged, we lose 1 health.
/* In order to tell the arduino to subtract 1 health, we
need to tell it what health should now be. To do this, we
will say that the health I should have is equal to the health
that I had minus 1. That line of code is written below.
*/
health = health - 1;
//now that we see something, indicate it by turning the LED
//on for 1 second
digitalWrite(led_pin, HIGH);
delay(1000); //a delay of 1000 is 1 second
digitalWrite(led_pin, LOW); //then turn LED off
}
}

//Tia tia tia!

Jul 05

Lesson 4

Now that we have an arduino that can both send and receive signals using infrared light, we can program it to play a basic game of laser tag.

Basic Laser Tag

We will start with a simple game of elimination. Each player has a tag unit, and the objective is to tag the other players 5 times. If you get tagged 5 times, you are out. The person who is left when everyone else is out is the winner.

So, how do we program the arduino to do this? We are nearly there. We already have code that sends in infrared signal (light pulsed 38,000 times a second) that our infrared receiver can receive. We also have code that checks to see if our receiver is receiving anything. What we need to do is add health. If you are out of health, then you can not send tags. Every time you receive a tag, your health goes down by one. You start with 5 health.

That's all there is to building a simple game of laser tag. From here, we are going to start adding bells and whistles to make the game more fun to play. But after you have completed this lesson and lab, you can play laser tag. Go for it. Write down what you liked and didn't like. If you want to change something, you can do it. This is your game of laser tag, and you can build it to do whatever you want. But first, let's make the code. To the code!

Jul 04

Sketch 3

This is the code for Sketch 3. Copy and paste everything below the /*************/ into a new arduino sketch.

/************************************************/
//Sketch_3
/* This program goes with Lab 3 of the OpenTag laser tag tutorial.
It sends a pulsed IR signal (38,000 times a second) when a button
is pressed and turns on an LED if a signal is seen
*/

/*
first, let's add the TimerOne library. To add a library, you
type #include and then the library name inside <>
*/

#include
//TimerOne will make it easy to pule an infrared LED 38,000 times
//a second

// Variables (nicknames for pins)
int button_pin = 12;
int led_pin = 11;
int ir_led_pin = 10;
int ir_receiver_pin = 9;

void setup() {
//first, start up the TimerOne library. We want it to pulse
//38,000 times a second, which is about once every 26 milliseconds
Timer1.initialize(26);

//tell the arduino if a pin is input/output
pinMode( button_pin, INPUT);
pinMode(led_pin, OUTPUT);
pinMode(ir_led_pin, OUTPUT);
pinMode(ir_receiver_pin, INPUT);
}

void loop() {
int button_state = digitalRead( button_pin ); //read button
if (button_state == HIGH) {
/*so, this is the first change. What we want to do is have
the arduino turn on the infrared LED on and off at 38,000
times a second.
we already know that digitalWrite is the command to tell the
arduino to set a pin to HIGH or LOW voltage. We want to
do that 38,000 times a second. That means we need to
turn the LED off then on about every 0.026 seconds.
(1/38,000 = 0.02632)
We could use digitialWrite to turn the infrared LED on and off,
or, we could use the TimerOne code to turn the infrared LED
on and off at precisely the time we want. We just need to tell
the arduino how long to pulse the LED. For that, we use the
delay function. The delay function tells the arduino to pause
for a set number of microseconds, or 1/1000th's of a second.
For our code, we will have the infrared LED pulse for 10
milliseconds every time we push the button
*/
//first, pulse the infrared LED with the TimerOne code
Timer1.pwm(ir_led_pin, 512); //send pulse
delay(10); //delay for 10 milliseconds
Timer1.disablePwm(ir_led_pin); //turn off Timer One
}
/*we don't need to do anything if the button is low
else {
digitalWrite(led_pin, LOW);
}
*/
//now, we want to see if we are getting tagged
int ir_receiver_state = digitalRead(ir_receiver_pin);
//if the receiver sees something, it will send a LOW or 0 signal
if (ir_receiver_state == 0){
//now that we see something, indicate it by turning the LED
//on for 1 second
digitalWrite(led_pin, HIGH);
delay(1000); //a delay of 1000 is 1 second
digitalWrite(led_pin, LOW); //then turn LED off
}
}
//Mj csy ger xyvr sr er PIH, csy ger hs ercxlmrk!

May 04

Laser Tag Update 5/3/15

My deliverables from last month were to:
1. Build a receiver unit. (IR receivers with indicator LED)
2. Adjust code for first game played

1. I arranged IR receivers in a circle,and they all read. I soldered them onto a spare piece of board and built two. After the fact, I decided to add an additional LED onto the receivers so that you would have LED indication on the lens tube when you are tagged or when you send a tag.
2. I changed how my LED's (for indication, not for tagging) turn on and off. I wrote a function that handles all of the indication LED's. With some modification, I could have it run RGB LED's and change their colors without using the built in PWM. The color may change a little bit when you send or receive a tag, but other than that, it should be able to control them pretty easily (during the time that you send or receive a tag, you would not be turning the LED on or off, so the color may be a little different.)

Note: I could change my code that sends and receives tags to send/receive a pulse and then go back into the main loop until I need to send/receive a pulse again. I'm not sure that I'll need to do this, but it is a possibility if I want to run through my main loop faster (and not have to wait for a tag send/receive to complete before going through the main loop).

At this point, I have two tag units, they both are running the current code, and I am ready to actually test playing laser tag. During that test, I should figure out what I should add to make the game play better. I have some other items that I would like to add, and in no particular order, here are some of them:

To add Later:
1. Telegraphing
2. Health bars
3. Shields
4. Bases

Based on trying to make a game type similar to Star Wars Battlefront, I should make spawn bases next. I can work on telegraphing and shields after I have places to respawn from. I can add allowing players to capture spawn points later. (I could add a certain number of respawns for a game type). So, here are my next steps:

Do Next:
1. Test the game with the current tag units: get feedback on what I should add to the devices
2. Begin work on spawn bases (unless telegraphing, health, shields, etc. comes back as something people want more)

Apr 05

Laser Tag Update 4/5/15

My deliverables from two weeks ago were:
1. Rewrite the bill of materials for the tag unit
2. Purchase three additional units
3. (Optional): test tag distances with different protocol timing.

I sorta updated my bill of materials. I have purchased most things from mouser.com, so I have a record of everything that I've purchased and will be able to purchase more if I need to.
I have now purchased materials to build four additional units. Why four? That will give me enough materials to have 5 units. So I could have some asymmetric game play (4v1, 3v2, etc.) or just have up to five people test the things. Or one will break. Who knows.

Do Next:
It will take a week or so for the parts to ship to me, and in the meantime I should prepare for the first game. The only next step I can think of is:
1. Build a receiver unit. It should be able to receive tags from a wide angle (360 degrees is nice, but not necessary). It should have an indicator LED on it.
2. Adjust the code for the first game played.
I am trying to build the minimum viable product. That means the minimum that I can do to make this work is what I should do.

For the first part, I basically need an array of IR receivers that are looking in different directions for a tag. I'm planning on using around 8 right now, because each of the ones that I'm using has a 45 degree field of vision. With 8, I get 360 degrees. I will have to mount that on the tag unit so that you can be tagged from any direction.
I should put an indicator LED on this part. This should go on top of the lens tube. In fact, I could build this in two parts so that you could still see down the center of the tube in order to aim.

For the second part, I need to make the code react to getting tagged in some way so that I can play a game with it. What is the most basic game that I want to play? Standard death match. Each player can get hit a certain number of times. They are out after hit a certain number of times. I need to add some code to keep track of the number of times someone has been hit, and if that counter reaches 0, they are out (I could have the indicator LED stay on or something.
If I want to make the game last for a certain amount of time, I could use a timer on my phone.

For future work, I can get stuff laser cut here:
http://www.cherrylaser.com/
http://www.lasersoverlosangeles.com/

Mar 09

Laser tag update 3/8/15

I missed last week's update, but I still worked on the laser tag project. I just didn't post. Well, here's to make up for lost time:

My deliverables from last week were:

1. Change IR LED current to 1 Ampere. Done.
2. Get distance tests for 1 A with 4.5" lens and a 1" lens. Not done.

So, I did upgrade the board a bit. I was using a solderless breadboard for my prototyping, but it was difficult to hold the darn thing together while aiming at my receiver board. Since I need to make a prototype anyway, I built a version on perfboard that had a breadboard layout on it. That way, my prototype would be sturdy enough that I could walk around with it and test it. I changed the current draw up to about 1 Amp as well. I am not using the 4.5" lens, and instead am using a 3.49" lens that is a standalone lens (the 4.5" lens is encased).

Specifications:

Voltage for LED: 5 V
Resistance for LED: Seven (x7) 33 Ohm resistors in parallel, resulting in 4.7 Ohm total resistance.
Current for LED: 1.06 (max is 1A)
Lens Diameter: 3.49"
Lens Focal Length: 9.5" +/- 0.125"
Max Transmission distance: ?? (not tested)

The purpose of this prototype was to build a unit that could be carried around. I used cardboard as my building material, as it is easy to cut, I have a bunch of it after purchasing stuff, and I can build things with it really quickly. I don't care about making it look pretty at the moment. I just need to see if it will work.

This is the first laser tag prototype

This is the first laser tag prototype

I will do distance tests eventually. However, currently, I have my receiver (which is basically another tag unit) turn on an LED when it is tagged. However, I can't see the little LED very well when I am standing 90 feet away, so I'll need to hook up my laptop and walk away, tag the receiver, then walk back. I'll do it eventually. Not enough time these past two weeks.

Another fun fact about using a larger lens. I empirically found the focal length by focusing the light of the sun (which is as close to a collimated source as I can get. If you have a better solution than focusing your light on something 92 million miles away, please let me know). When I did that, I noticed that the spot is larger than the spot of light I got when using a smaller lens. This is beneficial because the LED is not a point source, but is 5 mm in diameter. Using a larger lens will allow the focal point to have a larger diameter, so I will be able to collimate more light.

I will also mention to check for floating inputs. I didn't solder on the receiver initially, as I was pressed for time. That meant that the input was left floating (I didn't turn on internal pull-up resistors, since originally, there was a receiver there). My tag unit would stop tagging for some reason. I thought it was a power supply issue, code issue, and eventually tracked down that I had a floating input. Oops. I soldered the receiver in, and everything worked fine. If I'd taken the time to solder that last bit on, I wouldn't have been frustrated with the unit upon building it. Let that be a lesson.

Eventually, this needs to be turned into a tag unit that I can run around with and send/receive tags. Here's a short list of work that I will need to do eventually:

1. Build an enclosure - should be done after prototype done
2. Look at multiple IR receivers - (simplest way may be to add multiple receivers to the unit. Current ones don't have 360 degree field of view)
3. Test using 1 resistor instead of 7.
4. Determine what connection you want between your LED and tag unit. (maybe for the final unit, you have a red LED next to the IR)
5. Build multiple devices and test them in the field!

Future work (after first game):

1. Add LCD
2. Add RGB LED?
3. Add 58 kHz receiver for other types of tags
4. Make different lens combinations with different resistors on them with different tag rates

So, based on those things, I should probably test adding multiple IR receivers to my project and make it work with multiple receivers as my next step.

Next Steps:

1. Test multiple receivers. I have a few extra, so I shouldn't have to buy any more to do these tests.

Feb 15

Laser Tag Update 2/15/15

So, about two years ago, I wanted to make a course to teach laser tag. I didn't make it a habit, and it didn't get done.

Now, I've made some progress towards that laser tag. However, like the me of the past, this is still a large project, and I haven't gotten very far.

So now, I'm going to (try to) use some of the advice I've got from Extra Credits. They make videos about video games, and their advice can be translated to other projects. I'm specifically talking about their series on making video games, and their rules video. I should refer to this every once in a while when I am unsure of what to do.

Completed Work

1. Create a program to send and receive tags
2. Build a prototype that can send and receive tags
3. Build a lens setup and test adding a lens - adding lens increased tag distance
4. Build LED test setup and increase current - increasing drive current increases tag distance
(Note: requires batteries that can supply the current, and capacitors)

In Progress

1. Increase range of tag unit send/receive

Methods:

In my meanderings across the internet, books and the like, I have come across information on optics. I haven't done very much with optics, so this is a lot of trial and error on my part. However, I do know that I want to collimate light. Basically, I want to take light from an LED (emanating at about 25 degrees) and turn it into a beam that travels straight. Fortunately, if you buy a lens, they tell you the focal length, or distance away that a collimated light source will be focused. Put a light source that far away, and presto, instant collimated light.

However, what assumptions are they making about that light source? In the land of physics, everything is a point source, meaning it doesn't have any height or width. I tried using a 1" diameter lens to collimate a 5mm diameter IR LED. I got it to transmit about 50 feet, but it did not work very well outside. When I checked what the beam looked like with a red LED, the beam was not a column, but focused a few inches from the lens. If I want my lens to work more like the theoretical column, I need to make my LED look more like a point source. That means a larger lens or a smaller LED. Why not try both?

Deliverable:

1. Get a larger lens/lenses 2"+ in diameter.
2. Build test set up and test 2" diameter lens (inside and outside) and record transmission distances at standard currents

Future work

1. Add more light indication.
2. Make tag unit more sturdy.

Oct 19

Updates in the world of Open Source Laser Tag

To quote GLaDOS, "It's been a long time."

While I've been away, there have been plenty of things going on in the world of open source, laser tag, etc. A quick google search showed me some recent developments that look exciting.

Skirmos is an open source laser tag game made by college students. It is based on the arduino, uses IR LED's to send tags (with a range of 500 feet according to their kickstarter page), X-bee radios to sync data, tricolor LED's for coloring the tag unit, has a screen (which seems to be their differentiator), and has a cool shell. Since it uses an arduino, it is hack-tastic for other arduino enthusiasts. I missed the initial kickstater, and will have to follow up with this in the future. Based on their website and kickstarter goals, the final product may not have all of the functionality that they state in their kickstarter video. But hey, they are building something cool, and I am supportive of building cool things.

The guys at Skirmos mention that they are working with Kevin Darrah. He's another person who has a tutorial for using those silly NRF24L01+ radios (and I say that they are silly because, while I have read their data sheet and understand how one could control them, I haven't spent the time to write a library for controlling them and don't want to. I want a free one that I can use for whatever I want. Including teaching children how to build laser tag). Kevin has a website here with some cool projects relating to LED cubes (shift registers, multiplexing, etc.) and some home automation stuff with the aforementioned radios (which turns out are really cheap on ebay). He also made a breakout board for those things. Because who wants to solder 8 pins every time they use one?

IBM developerWorks has a three part tutorial on building laser tag. Who knew? I had some trouble navigating from part 1 to part 2 (there wasn't a link from part 1 to part 2 that I found faster than googling for part 2, so I'm posting the links to all 3 parts). I may have to look at developerWorks from IBM for more cool projects.
Part 1
Part 2
Part 3

Aug 13

Key Qualities for a school Makerspace and Bareduino

I came across and article on Make about the key qualities that are needed in a makerspace for kids in school. The main point of the article was that people need a few things to make. First, they need the basic skills of what tool to use and how to use it. Then they need to problem solve, to determine the reason that the thing they are making isn't working. Finally, they need the confidence to try something new. To learn something as they go. That confidence is what I want to impart on people. I want to empower them, to make them realize that they can build something complex, like laser tag. To be able to feel like they can do it and that it is within their reach to understand, to build, to create. The original article is here.

In other news, Niek Blankers at NiekProductions posted schematics for a bareduino, an arduino compatible based off of the ATiny45/85 that uses a small circuit board and minimal support components. It may be something that i could use if I wanted to have a separate controller that looked for tags, say on someone's head. His post is here.

Apr 19

Lab 2

In order to send a light signal (which is how the arduino will communicate when playing laser tag), we need to program the arduino to turn on a light when you push a button. In order to do this, you need to learn how to control the arduino's inputs, outputs and the basics of programming in the arduino IDE.

After reading through the example sketch (Sketch 2), you should have an idea of how to write a program to turn on an LED when a button is pressed. The circuit that you need to build to light up an LED when a button is pressed is shown below.

Figure 1: Breadboard of Lab 2 circuit (click on picture to make it bigger)

Lab2_bb
Xohd voccyx, dro grsvo vyyz!

The arduino runs off of five volts, and the LED needs 0.01 amperes (10 mA) of current. The circuit above makes pin 12 high (5V) when the button is pressed, and when the button is not pressed, the resistor pulls the pin to ground. This is called a pull-down resistor, as it makes the pin grounded (it is 0 volts) when the button is not pressed. This keeps static electricity from building up on the pin and causing the arduino to think that the pin is high when it shouldn't be. (in general, any pin that you are using should always be connected to either 5V or 0V [ground], so that static or charge from another source dos not build up on the pin).

The button does not need to have much current running through it, and to save power and use standard components, we choose a current value of 0.0005 Amperes (0.5 mA) through the pull-down resistor. Without the resistor, you will be connecting power (5V) to ground (0V), and create a short. A short will try to pull as much current as it can (it has roughly zero resistance, so the current will be very high), which will cause the batteries to quickly die and the components to heat up (and potentially fry). Remember the pull down resistor.

You now have enough information to calculate the resistance values for the two resistors in the circuit. After building the circuit and testing it with the arduino code that was provided, try adding another LED onto pin 10 and having it turn on when the button is not pressed, and turn off when the button is pressed.

Bonus Knowledge
The pin numbers that we are using were chosen to make the schematic look nice. Any of the digital pins can be used for this sketch.