CubeCrasher

I haven’t posted anything in a couple weeks so I thought I’d throw something up. What have I been up to? Midterms, work, and a side programming project which is an automation program for a little Facebook puzzle came called Cube Crash. I call it the CubeCrasher.

The game Cube Crash itself is fairly simple. You’re given a set of colored blocks on a nice grid. Blocks in a group of 3 or more with the same color can be clicked on and eliminated. The goal is to eliminate enough blocks to move onto the next level, and also get a high score, which is done by eliminating large groups of blocks rather than small.

Scoring is based on the formula: n^2 + (n+1)^2 + (n+2)^2 + (n+3)^2 + (n+4)^2 with n-2 being the number of blocks you eliminate with a click. Not sure why they chose this sequence, but it basically to get a high score you need to create large groups of blocks to click.

CubeCrasher Algorithm

The first thing CubeCrasher does is take an input for the number of “blocks left”, which it can then compute total blocks – blocks left to figure out the max number of blocks that can remain and still level up. It then takes a screenshot of the game and checks the pixel color in the center of each block, storing the results into a character array which gives me an internal logical representation of the game to manipulate. This is done using the Java.Robot library (quite handy for automation).

The state of the game is then put into a GameStateNode object, which consists of the game state (the character array), a LinkedList of groups of blocks that can be clicked on, a scoreSoFar variable, and a LinkedList of children. This becomes the root of a tree of all the possible solutions of the game. Each child represents clicking a different set of blocks.

My original idea was to brute force an optimal solution to each of these little levels of blocks. I quickly found that it seems fairly impossible given the size of the solution space though. In some cases you can do as many as 20-30 clicks to eliminate all the blocks. A very rough estimate is to say that everytime you click a group of blocks, there is one less group you can click, which would give between 20! and 30! game states. 30! has far more 0’s in it than I know how to pronounce, and would take around 1.3*10^18 years to compute using a single processor and my current program. This is of course a very rough estimate, but long story short, a pure brute force solution to a full grid of blocks is fairly impossible. Once you eliminate maybe 1/3 or 1/2 of the blocks, then you can actually find an optimal solution to your current state within a reasonable amount of time.

My original program was a nice recursive tree algorithm that, if left long enough, would go off and compute every single possible state and return the game with the highest score. Unfortunately due to the size of the solution space, what would end up happening is that it would go 20-25 moves deep and then sit there spending all of it’s computation time figuring out an optimal solution to the last 10 or so moves. I also wasted a lot of time computing all the possible children of every state even though I didn’t use any of them, and I simply checked for groups of blocks starting at the top left corner and moving down. This meant that it never actually got to game states where the bottom blocks were clicked first.

Version 2 of the algorithm consisted of adding a lot of randomness. The algorithm itself was a lot simpler to code though. First it creates a root GameStateNode by taking a screenshot as before, but instead of finding all the groups from the top down to the bottom, I make a list of 0 to 13 for the x values and 0 to 12 for the y values and shuffle them before iterating through and finding groups. This makes it so when finding groups, it goes in a random order. I set a counter variable so after checking some number of states it would stop the current path through the tree. I then repeatedly called this function in order to traverse random paths down the tree, but actually compute all possible states of the last couple moves (just because I set the counter value to 100 or 1000). This algorithm is a bit slower than before, but the results score wise are much better. This was also trivial to make multithreaded and get a good 40-50% speed boost by using both cores of my Intel Core 2 Duo, since I’m not actually checking if I’ve traversed a certain path down the tree before. It’s assumed that the solution space is so large, the tiny fraction of it I’m randomly exploring won’t contain too many repeats, and that recomputing those repeated paths down the tree would actually be faster than checking every single path if I’ve done it before.

What’s the result? A score of 144,835 after a couple games. This was high enough to put me on 2nd place for the week, but not on the all time score list which is my goal. It seems around level 13-15 the game gets to the point that there’s simply no way to continue. I let the algorithm run overnight once, computing over 8 billion possible game states, and didn’t find a single one that would eliminate all of the blocks and let me move on. This leads me to believe that I either have to focus on getting higher scores on the beginning levels, or fully automate the program so it will just play many games in a row and hopefully get lucky on one and get a high enough score to make it into the 200k+ all time high score list. There are also some optimizations I can do on the algorithm to speed it up a little, and perhaps when I have some time I’ll work on a version 3 of it that actually takes into account some sort of strategy for the first moves (like favoring deleting one color at a time, or the color with the most/least blocks).

Source code to be posted later.

n^2 + (n+1)^2 + (n+2)^2 + (n+3)^2 + (n+4)^2.

Social Networking: Overrated?

Well, it was bound to happen eventually. Google Wave was advertised as a collaboration tool and email replacement, but not as a social media device. That’s where the newly released Google Buzz comes in. What is it? It’s twitter without the annoying character limit, and it’s Facebook without all the nonsense of applications. An improvement to both? Maybe, maybe not. I’m not sold on social networking in general, despite having a Facebook and forwarding my blog posts to a twitter  which sets my Facebook status. Maybe it’s the other way around, I can’t remember.. nor can I get it to stop forwarding anymore..

First off, what is the point of all these social networking applications?

• Internet “small talk”. You don’t want to send an email or make a forum post, you just want to say hey and see what someone’s up to.
• Group communication
• Sharing of information and news

So why has social networking never grown on me much? Well the reason is I just find it a hacked together combination of IM, forums, and blogs.

For Internet small talk I prefer IRC, a room based IM protocol that still flourishes for the geekier types that like chat rooms. The conversations are mostly instant, but messages can also be left and looked at later for those who stay logged in and logging all the time.

I used to be a member on several forums, even a moderator and nearly an administrator on one. If you want to have a conversation about a certain topic or ask general questions to the community, a good forum will win over a Facebook Group any day of the week.

Finally for sharing information or reading about interesting news, an RSS reader with a few blogs and news pages will suffice nicely.

With far more powerful ways to share and communicate available, why would anyone want Twitter, Facebook, or Myspace? I think the answer to that is simply that social networking pages are targeted to general people and designed to be extremely simple to use. For a power use type of person like me, logging on IRC, posting on blogs/forums, and creating my own webpages to post content is no big deal. Social networking pages mash together a bunch of ways to communicate and interact. Almost all of these exist in a superior stand alone application or protocol, but perhaps not with the ease of usability.

Another reason it’s become so popular is because it’s become so popular. Yes, that may sound like a contradiction, but it’s really not. As the user base grew, pages like Twitter took off at exponential rates until almost everyone had heard of it and probably had an account. The reason everyone uses Facebook is because all their friends are on it. Some of their friends might sit around and IM, some might hang out on forums, but Facebook is a centralized place with a huge user base.

So on one hand these social networking pages certainly don’t contain many interesting or innovative ideas or technology and really are just a mash up of photo sharing pages, IMs, forums, and blogs. On the other hand they offer a simple interface to do a lot of things and have a huge user base, which propels them forward in popularity.

Obscure Error of the Day

Got this today when installing Xmetal (images needed to view this post).

Apparently there was a meeting, and my driver failed to attend. No wait, my driver’s ConfigDNS failed to attend? Or did they just fail at the meeting? Did it fall asleep during the meeting? Make too much noise?

Online Whiteboards

Sometimes, the best way to explain something is with pictures. Other times, you’re trying to show someone math over something like IM, and failing miserably. In both cases an online whiteboard application comes in handy.

The most recent one I’ve found is Dabbleboard. Not only can you draw, but you can insert text just be clicking and typing, insert math symbols, maintain a library of symbols you use often (quick and dirty schematics anyone?), insert PDF and other types of documents, and images from either your hard drive or a URL. Downsides: no flood fills, limited colors, no spray paint, and the automatic shape detection can be buggy (but you can always go freehand).

Another one I’ve used is the GE Imagination Cubed, which has the advantage of being able to use the pens as pointers, but generally  lacks a lot of the cool features Dabbleboard has, and is more difficult for inserting text.

I wonder if Google Wave has any good whiteboard applications yet… Even if it does, Dabbleboard and GE Imagination Cubed offer the advantage of just having to share a link, without the hassle of login names and registrations before your group can get started scribbling.

Dabbleboard

What did you say the units were?

Another day at work fighting with CAD tools…
Me: How high should the motherboard mounting hardware be?
Coworker: About 3 cm?
Me: I think someone set them to 3 feet…

The sad part is, this error was the highlight of my day.

Bootable VM Images?

Virtual Machines are great for testing things on and running software your native operating system won’t support. Sometimes, though, you actually want to be able to boot into them rather than run them on top of another operating system. If you run Linux for a main OS and Windows for gaming, a VM isn’t going to work that well for you due to all the extra overhead of running two operating systems at once, not to mention poor graphics frame rates on many VMs. Shouldn’t it be possible to create an image that you could both boot into like a regular partition, but also run inside a virtual machine? So far I’ve found nothing that can do this…

Cool Windows Command Line Tool

WMIC (Windows Management Instrument Command) is a nifty little Windows command that’s apparently been around since Windows XP pro. I found it when I was trying to get the command line arguments that were being passed to some process by some other process.

Some uses,

1.  To get the process list – wmic process list
2.  To get the group list – wmic group list
3.  To get the NIC Card Configuration – wmic nicconfig list
4.  To get user account list – wmic useraccount list
5.  To get the built in System account list – wmic sysaccount list
6.  To get the Environment list – wmic environment list
7.  To get the information of all shares (including hidden) – wmic share list
8.  To get the list of services – wmic services list
9.  To get the computer system details – wmic computersystem list
10. To get the volume information – wmic volume list
11. To get full startup list – wmic startup list full
12. To get Information of logical disks – wmic logicaldisk get description, filesystem, name, size
13. To get screensaver information – wmic desktop get screensaversecure, screensavertimeout
14. To get logon information – wmic logon get authenticationpackage
15. To get information about the OS – wmic os get name, servicepackmajorversion
16. To get information about QFE (Quick Fix Engineering) – wmic qfe get description,installedOn
17. To get information about the computer – wmic csproduct get name,vendor,identifyingNumber
18. To get the toal ram – wmic computersystem get TOTALPhysicalMemory,caption
19. To get the macaddress of nic card – wmic nic get macaddress,description

– source

You can format the output into html, xml, csv, and more. Just using it to pull info about your system is handy, but it can also modify network settings, start and kill processes, set the process priority,  and way more. I hate to sound like a late night Microsoft commercial, but this is the coolest command line utilities Ive found for quite some time in Windows. Go ahead and stick “wmic /?” in the command line and have fun.

On the n’th day of Christmas, my (assert love=true) love sent to me…

As an excuse to get all the IDEs and compilers I might possibly need running on my Vostro, plus to get in the Christmas spirit and code something in languages I haven’t used in a while, enjoy the Twelve Days of Christmas. I got bored after MIPs, maybe I’ll get around to adding on a SKILL/LISP implementation and VHDL later.

In TCL,

set days [list\
	"first" "second" "third"\
	"fourth" "fifth" "sixth"\
	"seventh" "eighth" "ninth"\
	"tenth" "eleventh" "twelfth"]

set gifts [list\
	"partridge in a pear tree"\
	"Two turtle doves"\
	"Three French hens"\
	"Four calling birds"\
	"Five golden rings"\
	"Six geese a-laying"\
	"Seven swans a-swimming"\
	"Eight maids a-milking"\
	"Nine ladies dancing"\
	"Ten lords a-leaping"\
	"Eleven pipers piping"\
	"Twelve drummers drumming"]

for {set i 0} {$i < 12} {incr i} {
           puts "On the [lindex $days $i] day of Christmas,"
           puts "My true love sent to me,"
for {set j $i} {$j > 0} {incr j -1} {
		puts "[lindex $gifts $j],"
	}

	if {$i == 0} {
		puts "A [lindex $gifts 0].\n"
	} else {
		puts "And a [lindex $gifts 0].\n"
	}
}

In C,

#include 

int main() {
	const char *days[12] = {"first", "second", "third",
		"fourth", "fifth", "sixth",\
		"seventh", "eighth", "ninth",\
		"tenth", "eleventh", "twelfth"};

	const char *gifts[12] = {"partridge in a pear tree",\
	"Two turtle doves",\
	"Three French hens",\
	"Four calling birds",\
	"Five golden rings",\
	"Six geese a-laying",\
	"Seven swans a-swimming",\
	"Eight maids a-milking",\
	"Nine ladies dancing",\
	"Ten lords a-leaping",\
	"Eleven pipers piping",\
	"Twelve drummers drumming"};

	int i, j;
	for (i = 0; i < 12;i++) {
            printf("On the %s day of Christmas,\n", days[i]);
            printf("My true love sent to me,\n");
 		for (j = i; j > 0; j--)
			printf("%s,\n", gifts[j]);

		if (i == 0)
			printf("A %s.\n\n", gifts[0]);
		else
			printf("And a %s.\n\n", gifts[0]);
	}
}

In Java,

public class song {
	private final static String days[] = {
		"first", "second", "third",
		"fourth", "fifth", "sixth",
		"seventh", "eighth", "ninth",
		"tenth", "eleventh", "twelvth"};

	private final static String gifts[] = {
		"partridge in a pear tree",
		"Two turtle doves",
		"Three French hens",
		"Four calling birds",
		"Five golden rings",
		"Six geese a-laying",
		"Seven swans a-swimming",
		"Eight maids a-milking",
		"Nine ladies dancing",
		"Ten lords a-leaping",
		"Eleven pipers piping",
		"Twelve drummers drumming"};

	public static void main(String args[]) {
		for (int i = 0; i < 12;i++) {
                      System.out.println("On the " + days[i] + " day of Christmas,");
                      System.out.println("My true love sent to me,");
		      for (int j = i; j > 0; j--)
			  System.out.println(gifts[j]);

			if (i == 0)
				System.out.println("A " + gifts[0] + ".");
			else
				System.out.println("And a " + gifts[0]);
			System.out.println();
		}

	}
}

In MIPS,

.data
	day1:	.asciiz	"first"
	day2:	.asciiz	"second"
	day3:	.asciiz	"third"
	day4:	.asciiz	"fourth"
	day5:	.asciiz	"fifth"
	day6:	.asciiz	"sixth"
	day7:	.asciiz	"seventh"
	day8:	.asciiz	"eighth"
	day9:	.asciiz	"ninth"
	day10:	.asciiz	"tenth"
	day11:	.asciiz	"eleventh"
	day12:	.asciiz	"twelvth"

	gift1:	.asciiz	"partridge in a pear tree"
	gift2:	.asciiz	"Two turtle doves"
	gift3:	.asciiz	"Three French hens"
	gift4:	.asciiz	"Four calling birds"
	gift5:	.asciiz	"Five golden rings"
	gift6:	.asciiz	"Six geese a-laying"
	gift7:	.asciiz	"Seven swans a-swimming"
	gift8:	.asciiz	"Eight maids a-milking"
	gift9:	.asciiz	"Nine ladies dancing"
	gift10:	.asciiz "Ten lords a-leaping"
	gift11:	.asciiz	"Eleven pipers piping"
	gift12:	.asciiz	"Twelve drummers drumming"

	onThe: .asciiz "On the "
	dayOf: .asciiz " day of Christmas,\nMy True love sent to me,\n"
	trueLove: .asciiz "My true love sent to me,\n"
	period: .asciiz ".\n\n"
	comma: .asciiz ",\n"
	newline: .asciiz "\n"
	andA: .asciiz "And a "
	justA: .asciiz "A "

	dayAddressesArray: .word 0,0,0,0,0,0,0,0,0,0,0,0
	giftAddressesArray: .word 0,0,0,0,0,0,0,0,0,0,0,0

.text

main:

	# Put all the addresses of the day strings in an array
	la $s0, dayAddressesArray
	la $t1, day1
	sw $t1, 0($s0)
	la $t1, day2
	sw $t1, 4($s0)
	la $t1, day3
	sw $t1, 8($s0)
	la $t1, day4
	sw $t1, 12($s0)
	la $t1, day5
	sw $t1, 16($s0)
	la $t1, day6
	sw $t1, 20($s0)
	la $t1, day7
	sw $t1, 24($s0)
	la $t1, day8
	sw $t1, 28($s0)
	la $t1, day9
	sw $t1, 32($s0)
	la $t1, day10
	sw $t1, 36($s0)
	la $t1, day11
	sw $t1, 40($s0)
	la $t1, day12
	sw $t1, 44($s0)

	# Put all the addresses of the gift strings in an array
	la $s1, giftAddressesArray
	la $t1, gift1
	sw $t1, 0($s1)
	la $t1, gift2
	sw $t1, 4($s1)
	la $t1, gift3
	sw $t1, 8($s1)
	la $t1, gift4
	sw $t1, 12($s1)
	la $t1, gift5
	sw $t1, 16($s1)
	la $t1, gift6
	sw $t1, 20($s1)
	la $t1, gift7
	sw $t1, 24($s1)
	la $t1, gift8
	sw $t1, 28($s1)
	la $t1, gift9
	sw $t1, 32($s1)
	la $t1, gift10
	sw $t1, 36($s1)
	la $t1, gift11
	sw $t1, 40($s1)
	la $t1, gift12
	sw $t1, 44($s1)

	li $t0, 0 # $t0 <- outer loop index
	outerLoopStart:
		la $a0,onThe
		li $v0,4
		syscall

		move $t1, $t0
		sll $t1, $t1, 2
		add $t2, $s0, $t1 	# t2 <- address of array element with address of string
		lw $a0, 0($t2) 		# t2 <- address of string
		li $v0,4
		syscall
		la $a0, dayOf
		li $v0, 4
		syscall

		move $t1, $t0
		innerLoopStart:
			beq $t1, $zero, innerLoopEnd
			move $t3, $t1
			sll $t3, $t3, 2
			add $t3, $t3, $s1
			lw $a0, 0($t3)
			li $v0, 4
			syscall

			la $a0, comma
			li $v0, 4
			syscall

			addi $t1, -1
			beq $t1, $zero, innerLoopEnd
			j innerLoopStart
		innerLoopEnd:

		beq $t0, $zero, printA

		printAnd:
			la $a0, andA
			li $v0, 4
			syscall
			j donePrinting

		printA:
			la $a0, justA
			li $v0, 4
			syscall
		donePrinting:

		lw $a0, 0($s1)
		li $v0, 4
		syscall
		la $a0, period
		li $v0, 4
		syscall

		addi $t0, 1
		beq $t0, 12, outerLoopEnd
		j outerLoopStart

	outerLoopEnd:
		jr $ra

In SKILL,

days = ‘(“first” “second” “third” “fourth” “fifth” “sixth”\

		” seventh” “eighth” “ninth” “tenth” “eleventh” “twelvth”)

gifts = ‘(“partridge in a pear tree”\

	“Two turtle doves”\

	“Three French hens”\

	“Four calling birds”\

	“Five golden rings”\

	“Six geese a-laying”\

	“Seven swans a-swimming”\

	“Eight maids a-milking”\

	“Nine ladies dancing”\

	“Ten lords a-leaping”\

	“Eleven pipers piping”\

	“Twelve drummers drumming”)
(defun sing ()

	(for i 0 11

		(printf “On the %s day of Christmas,\n” nth(i days))

		(printf “My true love sent to me,\n”)
		j = i

		(while j > 0

			(printf “%s,\n” nth(j gifts))

			j = j – 1

		)
		(if i == 0 then

			(printf “A %s.\n\n” (car gifts))

		else

			(printf “And a %s.\n\n” (car gifts))

		)

	)

)

Event/Emergency APRS Network Brainstorming

APRS is a wireless packet network system used by ham radio operators to transmit position information. Packets are encoded using the AX.25 data link protocol, which occupies the first, second, and third layers of the OSI networking model, and transmitted using half duplex radios usually on VHF or UHF frequencies. The default transfer rate is 1200 or 9600 baud. Packets are transmitted by a station and in general consist of a callsign to identify the sender, an icon/symbol code, a GPS string to show the sender’s exact position, and a short text status. It is also possible to send text messages or other small amounts of data.

Digipeaters are the basic nodes of the network, repeating signals from the stations to propagate them. The exact structure of the network is limited to the geography of the area and hardware available.

A basic representation of an APRS network can be achieved using a graph with the nodes representing the digipeaters and the edges representing which digipeaters can hear each other. In theory this would be an undirected graph, but on occasion phenomena arise which cause one digipeater to hear another, but not vice versa. This is a rare occurrence and will not be considered in most cases. The goal of a general purpose APRS network is to propagate the signal packet through the nodes to a certain depth from it’s original location.

In a general purpose APRS network, collisions between stations can and will occur as congestion increases, due to the almost random nature of transmission times. Collisions between the digipeaters should, however, be minimized.

In Event/Emergency Specific APRS, APRS is often used to track mobile emergency vehicles or event vehicles. The main difference of event specific APRS is that the stations have the ability to use controlled methods such as preasigned time slotting, so that no collisions will occur between stations.

For example, 10 stations transmitting position packets every 60 seconds can be programmed before the event to transmit one after the other every at 6 second intervals, allowing the most time possible for the signal to propagate through the network. Using the station’s GPS receivers to continually synchronize their internal clocks, they can achieve very accurate transmission times.

Beyond this, during an event the coordinators have more control over the content on the network, and can limit it to decrease network congestion. Messages or excess data for example, can be banned from the network, making relatively small standard packet length for all the stations in order to increase the number of time slots that can be assigned.

In a general purpose APRS network collisions and lost packets are considered acceptable. In an event/emergency specific APRS network, it should be engineered to have no collisions or lost packets as long as the station is able to be heard by at least one digipeater.

Generally, event specific networks cover a much smaller area. A general purpose APRS network might cover the entire country, but an event specific network will likely only cover some portion of a state and be perhaps less than 10 nodes.

A somewhat simplified version of the problem can be described as follows for a small event network,

• A station may be heard by any subset of the total digipeaters when it sends a packet
• Only one node or station should be transmitting on the network at a time to avoid any chance of collisions
• Time may be discretized into slots the length of the longest transmission time to send a packet
• It can be assumed that only one mobile station will send a packet at a time, and all other mobile stations will hold off a set amount of time in order to allow for that packet to propagate through the network (in other words, all stations will be time slotted)
• Packets should be retransmitted by all nodes exactly once
• A digipeater can tell if a packet was heard directly or by an adjacent digipeater
• A digipeater can tell if it has digipeated a packet before, either by each station including a timestamp inside the packet, or by the digipeaters just keeping track of anything they transmitted and received during a station’s time slot.

Therefore, the problem is how to propagate the packet through the entire network in the least amount of time slots, and taking into an account a digipeater’s only information is what it’s heard.

Method 1: Simple Algorithm to avoid collisions by use of delays

Even this very simplified and ideal problem, where stations will always transmit inside their time slots, proves to be a challenge to keep the digipeaters from colliding. Suppose you have a chain of digipeaters as shown below,

Even in this almost simplest layout, it’s impossible to get an efficient use of time slots when the number of digipeaters increases. Suppose we have a chain of 4 digipeaters such that, digipeater 1 can hear 2, 2 can hear 1 and 3, 3 can hear 2 and 4, etc.

Here is a simple way to ensure no two transmit at the same time.

If a direct packet hits digipeater 1, it can transmit immediately. However, if 1 hears a packet from 2, it must wait two timeslots to ensure that 3 and 4 are not transmitting (the case 2 hears the packet, but 1 does not).

If a packet is heard direct by 2, it can transmit only after a delay of 1 time slot to ensure 1 did not also hear the packet and repeat. If a packet is heard by 2 from 3, it must wait one timeslot to ensure that 4 does not transmit next (the case when 3 is the only one to hear the packet).

If digipeater 3 hears a packet direct, it must wait two timeslots to ensure that neither digipeater 1 or 2 are going to fill the time slot transmitting the packet. If 3 hears a packet from 4, it can transmit immediately.

If digipeater 4 hears a packet, it must wait three timeslots to transmit.

Now, suppose a packet is heard by digipeater 1. In this case, the path is 1->2->3->4 with no pauses. However, if 4 hears the packet, it must wait 3 timeslots to ensure neither 1, 2, or 3 are transmitting. It can then transmit the packet. After that, 3 can transmit the packet. Now when 2 hears a packet from 3, it’s possible that 3 was the first and only station to hear the packet, so 2 must wait a timeslot in case 4 has to go. The path then looks like,

P->P->P->4->3->P->2->P->P->1

For a line of digipeaters of length 6 the longest path is,

P->P->P->P->P->P->6->5->P->4->P->P->3->P->P->P->2->P->P->P->P->1

For a line of N digipeaters using this method, it takes 2N+[(N-2)+(N-3)+(N-4)+…+2+1]-1 = O(N^2) for the longest possible path. This is due to the fact digipeaters have no idea what’s going on further down the chain.

For a group of digipeaters where they can all hear eachother, a routing algorithm like this can be improved slightly, down to 2N hops worse case, but this is still too many to be useful for any sort of large network. Also, in most cases there will be some mix of digipeaters being able to hear eachother and being chained.

Because time slotting must be assigned to take into account the worse case propagation through the network, a better method is needed than simple logic on the digipeaters to ensure no collisions and higher throughput (such as a high speed back bone between digipeaters, multiple channels, request to send protocols, etc).

EE101 Hummerbot Videos

Finally got around to posting some old videos of the robot I made back in EE101 a year ago.

The hummerbot (my team’s robot) on the ramp,

http://www.youtube.com/watch?v=IVMj-MIEGfM

http://www.youtube.com/watch?v=fBgCe5NAAxU

The hummerbot on the can course,

http://www.youtube.com/watch?v=UeFmm4FkRnU

http://www.youtube.com/watch?v=MrN54sZcY6A

One of our competitor robots (slow and steady wins the race?),

http://www.youtube.com/watch?v=VdETMfP_kmc

http://www.youtube.com/watch?v=_9wO-Xzdf_c

A blooper of a not so competitve robot,

http://www.youtube.com/watch?v=5NlHOx8KUh0

Aah good times. When we walked into the lab and saw the other robots, we said, “Well… we’re either going to get an A because our robot is the most awesome thing here, or we’re going to fail since we hacked a microcontroller on an RC hummer instead of building ours from scratch and duct tape.” We ended up getting an A.