I did that until I thought I had  basic understanding of Arduino. So I moved on to a slightly bigger project. I was going to build a simple robot using the Arduino.

To start I took the main part of my Parallax Boe 2 off of the body part, so I had something to build with. And, as most robots need SOMETHING to do I hooked up the servos used for the wheels to my Arduino/solderless breadboard using the following schematic:

For those who don’t know: Vdd is power, Vss is the ground, and obviously the I/O pin is what gets conneted to the Arduino boards so that the servo actually knows what to do.

After a long afternoon of exploring PWM (Pulse Width Modulation) and how to use it, we tried to actually get the sevos moving. As with most projects I do, it didn’t work at first. So after extensive research online I found this code:

int servoPin = 7;
void setup()
{
pinMode(servoPin,OUTPUT);
}
void loop()
{
int temp;
for (temp = 0; temp <= 200; temp++)
{
digitalWrite(servoPin,HIGH);
delayMicroseconds(1500); // 1.5ms
digitalWrite(servoPin,LOW);
delay(20); // 20ms
}
for (temp = 0; temp <= 200; temp++)
{
digitalWrite(servoPin,HIGH);
delayMicroseconds(1800); // 1.8ms
digitalWrite(servoPin,LOW);
delay(20); // 20ms
}
for (temp = 0; temp <= 200; temp++)
{
digitalWrite(servoPin,HIGH);
delayMicroseconds(1200); // 1.2ms
digitalWrite(servoPin,LOW);
delay(20); // 20ms
}
}

Basically, what this code was doing was using PWM in a “braindead way”. It made The servos soin in one direction until the time got slow enough that it stopped and started spinning in the opposite direction. “Wow. That seems a bit too tedious to be the real way to control the servos,” I thought. Research. Research. Research.

After all of that research and stuff, I found one of the weird things the guy who wrote the previous code did. He was using digitalWrite. It is much easier to us analogWrite, so that you can use a number value instead of just LOW/HIGH. That’s important because the way that the servos work is based on the PWM coming from the Arduino board. So if It’s at either extremes, the servos won’t move very fast, if at all. That’s why, in the following code, the analogWrite sets the wheels to a space in between HIGH and LOW.

#define CLOCK 52
#define COUNTER 200
#define NOTMOVING 128
#define RIGHT 6  //sets pin 6 to the right wheel
#define LEFT 5  //sets pin 5 to the left wheel

void forward() {  //the “function” used to refer to moving the servos forward
  analogWrite(RIGHT, CLOCK);
  analogWrite(LEFT, COUNTER); 
}
void stopped() {  //the “function” used to refer to the servos being stopped
  analogWrite(RIGHT, NOTMOVING);
  analogWrite(LEFT, NOTMOVING);
}
void backwards() { //the “function” used to refer to the servos
  analogWrite(RIGHT, COUNTER);
  analogWrite(LEFT, CLOCK);
}
void setup() {
  pinMode(RIGHT, OUTPUT);  //sets pin 7 as an output
  pinMode(LEFT, OUTPUT);  //sets pin 6 as an output
}
void loop() {
  forward();
}

This code, as it is, will just make the little BOE move forward. However, I added the function of moving backward, and staying still. So all you would have to do to make it move backward or stay still is add it it to the loop. So as soon as I get around to doing other stuff to the robot, like adding sensore, I can still tell it which ways it should move easily.

import random
randomfact =  random.randint(1,  3)
if randomfact == 1:
    print ‘There are square watermelons in Japan!’
if randomfact == 2:
    print ‘Philo Farnsworth (the man tht invented the television) had a complete undderstanding of the the theory of relativity when he was 15!’
if randomfact == 3:
    print ‘crwth is an english word with no vowel!’
if randomfact == 4:
    print ‘Horses do not yawn!’

he suggested we do it with a list. So we talked for a while about lists. Then we talked about indexs. After a lot of stupid questions from me I finally under stood why we did things like ‘random.randint (0, len(facts)-1)’. And it’s because the highest index in the list is always gonna be one less than the number of items on the list because it uses zero as a number, rather than starting t one. In the end we ended up with the finished random fact generator like the on below.

import random
facts = [
'there are square watermelons in Japan!',
'Philo Farnsworth (the man tht invented the television) had a complete undderstanding of the the theory of relativity when he was 15!',
'crwth is an english word with no vowel!',
'Horses do not yawn!',
'Elephants are the only mammal that can not jump',
'The English alphabet used to have 24 letters.',
'Matt Hummer was unanimously voted to be the coolest person ever!',
'It is more likely tht you are raped in Canada than it is for you to win the lottery',
'California has a bigger population than Canada (2009)',
'You can not hum with your nose pinched shut.'
]
indexnumber = random.randint (0, len(facts)-1)
print facts[indexnumber]

    Most of the python that I actually wrote today came almost straight from the tutorial, but i still think i accomplished a lot.

    First i downloaded Xchat so my brother and I could communicate as we wrote our games. Then we downloaded Wing IDE pro.

    Now this is where it gets complicated(we all knew it was coming). We couldn’t use our verification code because it as for Wing IDE personal. So we switched it easy enough. However, now Wing couldn’t find python. So we downloaded that as well as pygame.

    For some odd reason Wing could still not find python so we had to save it to a weird file. Then it found it. Now it couldn’t find Pygame though. So we had to move that around a bit. And this whole process involved a bit of installing, uninstalling, and reinstalling. It made me wish I could just use Synaptic again. 

    Then we finally figured out where to put everything, Wing could find it and we would finally work on our games again.

We broke animals into two basic groups-vertebrate and invertebrate. Then we broke that into Mammels, fish, etc.

 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

'''Animal types.'''

class Animal:
    '''A Base Animal type.'''

class Vertebrate(Animal):
    '''An Animal with a backbone.'''

    def has_backbone(self):
    	return True

class Invertebrate(Animal):
    '''An Animal without a backbone.'''

    def has_backbone(self):
    	return False

class Fish(Vertebrate):
    '''A Vertebrate with no fur.'''

    def has_fur(self):
    	return False

class Mammal(Vertebrate):
    '''A Vertebrate with fur.'''

    def has_fur(self):
    	return True

class Human(Mammal):
    '''vertebrate with fur.'''

class Lion(Mammal):
    '''vertebrate with fur'''

class monkey(Mammal):
    '''vertebrate with fur'''

class jellyfish(invertebrate):
    '''not sure, but cool'''

class bear(Mammal):
    '''hairy monster!!!'''

class Matt(vertebrate):
    '''We're not sure exactly...'''

import random
compnumber =  random.randint(1,  100)
usrnumber = 0
while usrnumber != compnumber:
usrnumber = raw_input(‘Your number please:’)
usrnumber = int(usrnumber)

if usrnumber > compnumber:
print “Too high!”
if usrnumber < compnumber:
print “Not quite high enough…”

if usrnumber == compnumber – 1:
print “So close…”
if usrnumber == compnumber + 1:
print “So close…”
print “Yay! You did it!”

I have been learning about boolean logic, statements, and operators. It’s pretty much a lot tougher now. But the cool thing is I’m actually writing stuff that looks like python now. It’s a lot more lengthy. It’s not just the simple stuff I used to do, like making strings and adding them together.

It’s especially cool cause In the Python in Practice section of the book we actually wrote a program that makes a bunch of tanks fight each other. I changed the numbers around a little so that the tank Bob would win.

I also wrote a little program that would pretty much do the same thing as rolling a die. It would randomly pick a number from one through 6. Yet again I played with the numbers a little so that it would randomly pick a number one through 100.

That’s pretty much everything I’ve been doing. I change a lot of the code around so I can learn it better. If I didn’t I would probably drive my self crazy with the word FUGU!

Okay so today I started working on making a game with my brother. It’s fairly easy, except for some of the little details. It is going to be a game we make using python. We’re using a book to help me start learning python. It’s called Beginning Game Development with Python and Pygame.

So today by brother quizzed me on chapter one. It was pretty easy. Then we started chapter two. That’s when all the problems started. I was having problems with extra spaces at the end of the things that you can’t even see when the books give you examples of what it looks like. But it’s okay.

I learned about loops. We also talked about the differences between lists and tuples. Tuples load faster, but are immutable. It is pretty much cool!