SummerSchedule2008

From IPRE Wiki
Jump to: navigation, search

Vacation Schedule

  1. Doug

Work Schedule

Meena : 27 May - 1 August, 2008 (10:00 am - 5:00 pm, with hour lunch break)

Project Webpages

Becca: Dinah

Kerstin and Priscy: Neural Networks and Robot Attention

Meena : Humanoid Robotics

Teyvonia: Designing, Building and Programming a Hexapod: From King Spider to TevBot

To-do List

  • Doug: fix startpython.pyw for Mac.
  • Becca: work on Ruby, Scheme, Dinah interface's code blocks

Week 1, May 27 - May 30, 2008

I did this...

  • Becca (27 May 2008): I have Myro loaded, though not TK Snack (stuck) or XMPPPY (no directions anywhere). Here are some links to websites with instructions for creating installer packages:
  • Meena (27 May 2008): Started reading about differences between C# and Java (to prep for translation of pyro code); read through the Pyro tutorials; ended on the "PyroModuleDirectControl" module; edited the code at the end like so:
from pyrobot.brain import Brain

class WallFollow(Brain):
    # follows walls on its left, ignores sonar sensors on its right
    def wallFollow(self, dist):
        sideLeftA = self.robot.sonar[0][0].distance()
        sideLeftB = self.robot.sonar[0][15].distance()
        sideRightA = self.robot.sonar[0][7].distance()
        sideRightB = self.robot.sonar[0][8].distance()
        diagBackLeft = self.robot.sonar[0][14].distance()
        diagBackRight = self.robot.sonar[0][9].distance()
      
        frontLeft = min([s.distance() for s in self.robot.sonar[0][2:4]])
        frontRight = min([s.distance() for s in self.robot.sonar[0][4:6]])
        if frontLeft < dist:
            print "wall in front"
            self.move(0,-0.5)
        elif (sideLeftA < dist or sideLeftB < dist or diagBackLeft < dist):
            print "following left:",
            if frontLeft < sideLeftA:
                print "turn slight away"
                self.move(0.4,-0.1)
            elif frontLeft < diagBackLeft:
            	print "turn a lot toward"
            	self.move(0.3, 0.5)
            elif frontLeft > diagBackLeft:
            	print "turn a bit toward"
            	self.move(0.3, 0.4)
            else:
                print "turn slight toward"
                self.move(0.3,0.1)        
        elif (sideRightA < dist or sideRightB < dist or diagBackRight < dist):
            print "following right:",
            if frontRight < sideRightA:
                print "turn slight away"
                self.move(0.4,-0.1)
            elif frontRight < diagBackRight:
            	print "turn a lot toward"
            	self.move(0.3, 0.5)
            elif frontRight > diagBackRight:
            	print "turn a bit toward"
            	self.move(0.3, 0.4)
            else:
                print "turn slight toward"
                self.move(0.3,0.1)       
        else:
            print "find wall"
            self.move(0.3,0)
    def step(self):
        self.wallFollow(1)

def INIT(engine):
   return WallFollow('WallFollow', engine)
  • Becca (28 May 2008): Directions to load xmpppy on an Intel-based Mac: Download xmpppy from link and unzip. cd to correct directory, then same install line as for other packages.
    • It turns out that TK Snack doesn't work on Intel-based Macs yet.
    • I made installers for Myro, but need a Mac to test them on.
    • I read the Pyro article, and am partway through the IronPython book. See the Mac OS X installation page for everything else I've done all day.
  • Kerstin: I read the first 8 Pyro tutorials (up through Neural Networks) and I am wondering about the advantages of having several references to the same robot: robot, engine.robot, engine.brain.robot. I also read the article Bringing up robot: Fundamental mechanisms for creating a self-mativated, self-organizing architecture by D. Blank, D. Kumar, L. Meeden and J. Marshall, and I started reading up on C#. There does not seem to be a C# compiler installed on Windows so I cannot experiment with actual code right now. I will try to find Mr. Rice to get my Fedora password so that I can work with Linux. Update: It turned out that the robot references make a lot of sense when the program controls several robots with different brains.
  • Meena (28 May 2008): Read "Bringing up robot: Fundamental mechanisms for creating a self-mativated, self-organizing architecture" article (Blank, D., Kumar, D., Meeden, M., and James Marshall) to get an idea of research already done; read most of "Pyro: A Python-based Versatile Programming Environment for Teaching Robotics" article (Blank, D., Kumar, D., Meeden, M., and Holly Yanco) to learn about background of Pyro project; finished reading up on C# vs Java comparison (will probably try writing test programs tomorrow); read some more of the Pyro tutorial; made the following behaviors after the Vertical Behaviors section:
#class Wander(SubsumptionBehavior):
#    def update(self):
#        self.move( .2, random.random() * 2 - 1)

#class Avoid(SubsumptionBehavior):
#    def update(self):
#        if min([s.value for s in self.robot.range["front-all"]]) < 1:
#            self.move(-.2, 0)
            
##New Behaviors  
class Spin(SubsumptionBehavior):
	def update(self):
			self.move(0,1)

class ForwardFromWall(SubsumptionBehavior):
	def update(self):
		if min([s.value for s in self.robot.range["back-all"]]) < 1:
			self.move(0.3,0)

class ForwardToWall(SubsumptionBehavior):
	def update(self):
		if min([s.value for s in self.robot.range["front-all"]]) > 3:
			self.move(0.3,0)
        
class WanderAvoidFollowWall(SubsumptionBehavior):
	def update(self):
		sideLeftA = self.robot.sonar[0][0].distance()
		sideLeftB = self.robot.sonar[0][15].distance()
		sideRightA = self.robot.sonar[0][7].distance()
		sideRightB = self.robot.sonar[0][8].distance()
		diagBackLeft = self.robot.sonar[0][14].distance()
		diagBackRight = self.robot.sonar[0][9].distance()
		frontLeft = min([s.distance() for s in self.robot.sonar[0][2:4]])
		frontRight = min([s.distance() for s in self.robot.sonar[0][4:6]])
		
		if min([s.value for s in self.robot.range["front-all"]]) > 3:
			self.move( .2, random.random() * 2 - 1)
		elif min([s.value for s in self.robot.range["front-all"]]) < 0.5:
			self.move( -.2, 0)
		elif min([s.value for s in self.robot.range["front-all"]]) < 1:
			if frontLeft < 1:
				print "wall in front (left)"
				self.move(0,-0.5)
			elif (sideLeftA < 1 or sideLeftB < 1 or diagBackLeft < 1):
				print "following left:",
				
				if frontLeft < sideLeftA:
					print "turn slight away"
					self.move(0.4,-0.1)
				elif frontLeft < diagBackLeft:
					print "turn a lot toward"
					self.move(0.3, 0.5)
				elif frontLeft > diagBackLeft:
					print "turn a bit toward"
					self.move(0.3, 0.4)
				else:
					print "turn slight toward"
					self.move(0.3,0.1)
			elif frontRight < 1:
				print "wall in front (right)"
				self.move(0, 0.5)		        
			elif (sideRightA < 1 or sideRightB < 1 or diagBackRight < 1):
				print "following right:",
				
				if frontRight < sideRightA:
					print "turn slight away"
					self.move(0.4,-0.1)
				elif frontRight < diagBackRight:
					print "turn a lot toward"
					self.move(0.3, 0.5)
				elif frontRight > diagBackRight:
					print "turn a bit toward"
					self.move(0.3, 0.4)
				else:
					print "turn slight toward"
					self.move(0.3,0.1)       
			else:
				print "find wall"
				self.move(0.3,0)
  
def INIT(engine):
    subsumption = SubsumptionBrain( engine )
    # add behaviors, lowest priorities first:
#    subsumption.add( Wander() ) 	   
    subsumption.add( Spin() )  
    subsumption.add( ForwardToWall() )  
    subsumption.add( ForwardFromWall() )
#    subsumption.add( Avoid() )
    subsumption.add( WanderAvoidFollowWall() )
    return subsumption

Tried to make the sim robot dance, but couldn't figure out how to create three separate movements for it (might look at code again tomorrow to modify for multiple movements during updates, if that is the problem); read partway through Horizontal Behavior section

  • Becca (29 May 2008): Finished reading about IronPython. Started reading about C# and discovered a good online tutorial ([1]) which gets straight to the point.
  • Meena (29 May 2008): Finished reading articles; continued reading Pyro tutorials online (reached second part of Neural Networks section); edited multiple bits of code for exercises (won't paste all of them here to conserve page space); planning on downloading a compiler for C# on laptop and trying some programs tomorrow, since compiler on Park computer's apparently out of date
  • Kerstin: I experimented a bit with Conx. I tried to teach a network to recognize a triangle: given the coordinates of a point, decide whether that point lies inside (output=0), outside (1) or on the edge (0.5) of the triangle. I started with 260 training points, 100 inside, 100 outside and 60 on the edge. I was surprised how much trouble a multi-layered network had with this task. For the number of nodes I used (between 4 and 100 in one hidden layer, and two hidden layers with 6 nodes each), the network never managed to recognize more than 70% of the training points (w/ tolerance = 0.2) after several thousand epochs. More interestingly, the performance of the network dropped over time. The peak performance of ~70% correct points was reached after a few hundred epochs and then the performance dropped down to and stayed stable at 40-50% correct points, regardless of the number of nodes used. The main problem seemed to have been the points on the edge of the triangle. After removing those points from the training set, a three layer network with 4 hidden nodes recognized 100% of the 200 training points after about 80 epochs. It was also able to make generalizations: the network correctly identified 98% of a cross-validation set of 500 points.
  • Becca (30 May 2008): Read enough about C# to write a few sample programs. I should be able to just look up anything else I need to know about the language as I need it. I started loading Myro 3, but got stuck at the 'make' command.

Week 2, June 2 - June 6, 2008

  • Kerstin: I have read (or re-read) a few papers today: The Multiple Roles of Anticipation in Developmental Robotics by D.S. Blank, J.M. Lewis and J.B. Marshal , An Emergent Framework for Self-Motivation in Developmental Robotics by D.S. Blank, L. Meeden and J.B. Marshall, and The Governor Architecture: Avoiding Catastrophic Forgetting in Robot Learning by D.S. Blank, J. Stober and L. Meeden. I also read (or skimmed) the Wikipedia articles on Neural Networks, Neural Gas, Machine Learning, Developmental Robotics and Artificial Intelligence.

A section about chat bots in the "Python AI" article reminded me of a Japanese robotics project I read about awhile ago, where researchers were trying to use humanoid robots to interact vocally with people by interpreting what they said and outputting appropriate responses (I think the robot in that article was doing a physics lecture or a scientific Q&A session). Might be worth simplifying into a project for this summer. The article also mentioned a GuessLang program that can analyze a webpage and figure out what language it's in; this could probably be modified to work with an interactive robot that could work in different languages, or could simulate a fluent speaker for language students needing to be immersed in the language. Maybe.

The dissertation ("A Framework for Reactive Intelligence through Agile Component-Based Behaviors") pointed out some interesting things about different languages and efficiency/speed. C++ (and I would guess other "system programming languages") take less time to process information in (on average C++ is 20x faster than Python and can get up to 100x faster in common applications), so it would make sense to try programming in one of these system programming languages. We'll already be using C# to translate Pyro, so we might as well use it for further experimentation as well, or try using Java or C++ for the fun of it.

  • Kerstin: After thinking about the Governor and its ARAVQ implementation, I started wondering if there are different ways of storing learned information (very broadly speaking) in some sort of long-term memory to avoid catastrophic forgetting. The ARAVQ Governor solves this problem by continually rehearsing the old input, but can a network-controlled robot remember the correct behavior in a situation without continually rehearsing it?
  • Becca (2 June 2008): I discovered that I could load Gnome Sharp (which is needed for Myro 3) with MacPorts, but even though I managed to load another MacPorts program (TexMath. It's way too much fun.), Gnome Sharp kept hanging and wouldn't load. Other than that, I connected the Mac to a Scribbler and started thinking of programs and concepts to share at the workshop next week. I have a few sample programs and will work on more, as well as a robot that's been taken apart to show people.
  • Meena (3 June 2008): Read some articles pertaining to android AI, recent research in humanoid robotics, and other related topics. Looked over the code for an ELIZA-based program called Therapist (program that simulates a discussion with a therapist by responding to human input/responses). Could probably make such a program better by transferring it to a neural network-like format, where program/robot could learn how to respond to different questions or statements (or at least tell the user to stop asking/saying whatever's causing the program/robot trouble). Could have certain keywords also act as reinforcement values, maybe. Will mess with some chat bots on my laptop to gauge their limitations, and will see if I can find out how they are implemented and what makes them better than ELIZA (maybe they're already using networks). Also downloaded, installed, and started messing with Microsoft Robotics Developer Studio 2008. Messed with the VPL (visual programming language) approach to programming. Trying to figure out how to use more complicated loops than if statements (for loops and while loops aren't included as draggable programming parts). Looks like lists/2D arrays are also the only data structures readily available for the visual programmer to use; trying to figure out if other structures are useable, and if so how exactly they can be implemented. Coding by dragging icons feels restrictive, annoying; feel like it would take less time just to type out the commands (it would definitely take less time to include things like while loops or dictionaries, if I wanted to include them for some reason). Wondering whether it's possible to textually code somewhere and import the code into the rest of the program; seems MRDS2008 can work with Visual Studio C# for some applications, so I might install that and see if I can use it instead of VPL.
  • Meena (4 June 2008): Went through tutorials on how to use the MRDS simulation program, looked up videos and articles about the Robonova-1 (the robot that's coming in soon). Downloaded a zip file that had files for simulating the Robonova-1, will look at it tomorrow.
  • Becca (5 June 2008): Oops, forgot to update for a few days. I've installed Myro on an XO laptop and set up the bluetooth so the robot could connect to it (OLPC-XO). I'm still working on ways to make it easier and faster to set it up each time the computer is restarted. I've gone through the new textbook for the intro class and have written a few exercises to go along with the new chapters (read the extra credit one. You will laugh. Exercises). I've started looking up Scheme to get a general idea of what it is about.
  • Meena (5-6 June 2008): Tried running zip files; didn't work. Considered making own mesh files and project for creating robot in simulation, realized learning how to use the art program alone (Blender) could take weeks, decided to see what I could so about the zip file. Got the references to work, but for some reason it can't connect to the Microsoft servers. Posted about it on the Development Forums, will check later to see if I got a reply. If necessary will try connecting to different server.

In the meantime, read through shiny new book, Programming Microsoft Robotics Studio (Sara Morgan); learning how to set up a service that will allow for "autonomous roaming" on a LEGO NXT; hoping to get this into a simulator and see if it works, then learn how to get other robots working in the same manner (right now it seems services are meant for REAL robots, not simulated robots, so I'll have to look up info about that; might have to eventually modify sim environment itself). Also looked at old Myro game I made in CS110 to see if it was presentable for the conference; started on modifications to make it playable by up to 4 people (now only supports 2), but dunno if it will matter, since it has to be played with game controllers and they are in limited supply as far as I know.

Week 3, June 9 - June 13, 2008

  • Becca (9-10 June 2008): I made (thankfully with help) 29 robot kits for the conference. We seem to be missing one lunchbox somewhere.
  • Meena (9-10 June 2008): Found out the zip for the robot was just for the model of the robot, not for moving or anything. Couldn't connect to a server because it didn't have any services in its code. Still looking for something to explain how to use behaviors on sim robots instead of real robots. Looking for code online that will help override whatever code Microsoft uses for movement in simulations (since Microsoft doesn't do a good job of explaining the code that isn't directly discussed in the tutorials). Also looked through random classes to try and find out what might need altering. Will have to look at robot to figure out what sensors it has/joint movement/etc so I can make a behavior that is specific to that robot.
  • Becca (11 June 2008): Gnome Sharp is still not loaded. I seem to get a different error message every time I try installing it through MacPorts, after it hangs for a while.

Week 4, June 16 - June 20, 2008

  • Becca (16 June 2008): I'm looking at Alice and Scratch, two graphical programming languages, to see what features we might want to have for our own graphical programming language in Myro. So far, I like Scratch a lot more because it is much more intuitive, supports more than just videos, and corresponds more to the code it represents.
  • Kerstin: I have been trying to reproduce the follow-the-wall neural network experiment and I have run into several problems. The network simulation crashes after a certain time on Linux, which seems to be a memory issue. I tried deleting the network every now and then and then using the 'gc' module for cyclical garbage collection but it didn't help. Now I moved to Windows and it works just fine. My second problem is with the governor network class. Whenever I try using it (on Windows), it seems to be less efficient than a regular network; after several thousand training periods the error is still significantly larger than the error of a normal network with the same topology. I might have not implemented the governor network correctly, the version on Windows might be outdated or I might not be giving it enough time.

I finally managed to train a network with 25 hidden nodes and I was quite surprised when I tested it: the robot went the exact same path that I wanted it to go (until it got stuck), but backwards. I am 99.9% sure that I am not converting the network units back to robot units correctly, but I cannot find the error. Finally, I am not quite sure how many hidden nodes in how many layers I should use. With 25 hidden nodes in one layer I got a cumulative TSS error of about 200 for a data set of 20,000 points. I am currently training a network with 50 nodes in one layer and I am down to a TSS error of about 180 after 4000 epochs. I would like to try to train a network with significantly more nodes but I am afraid that would currently not be feasible computing-power-wise. I tried training a network with 2 hidden layers of 8 nodes each and had it run over the weekend, but after ~2000 epochs it still had a TSS error above 1,000. The error had not decreased over the last 100 epochs so I stopped the training.


  • Meena (16 June 2008): Found out that partial cause of my problems with MRDS. Stuff works fine now. Looking at code from this site to get idea of how to make robots move on their own in the simulator.

Also worked a little with the Robonova-1. Think it has a short battery life; not sure how long it needs to be charged because LED light on the charger always changes to green after maybe twenty minutes, but the robot loses power shortly after (10-20 mins). Will charge for a few hours tomorrow to see if the battery can last for an hour, at least. Can't try fancy robot moves at the moment anyway because of lack of space.

  • Becca (17 June 2008): I started learning Ruby, in addition to Scheme. I created a spreadsheet in Google Docs listing my ideas so far on what features from Alice and from Scratch would make a good graphical programming language for us to use. I looked up some of what had been done with the two languages to see what we might want to make it easy or harder to do. I will be preparing a talk on Turing tests for a workshop on June 30th and will make up 15 robot kits for the workshop as well.
  • Meena (18 June 2008): Back to Pyro (MRDS too complicated for current purposes). Have spent enough time with MRDS to have forgotten parts of Pyro tutorials, so will start with a review.

Robonova-1's battery lasted about an hour when charged for 5 hours and left standing with the power on. Will see how long battery lasts when robot is moving a bit. Realized sensors I thought were already in the robot are optional additions; only sensor robot has now is the IR for the remote control. Wondering whether the sensor might be usable for other things; unfortunately it's broken, so this can't be tested.

  • Kerstin: After two frustrating weeks I have officially given up on the wall-following. Instead I trained a neural network to avoid obstacles, which went surprisingly smoothly. I will shift my focus to 'attention' now, and if I have a creative moment I might start writing my abstract.
  • Meena (19 June 2008): Tried out the "catch-and-play" features of the Robonova (is indeed as easy to do as the package claimed). Tried out walking program; pretty good but sort of wobbly/non-fluid. Will examine it again after battery has charged (lasted about 40 mins after charging for a long long time) and see if better movements can be created (maybe more human-like walking motions). Also tried out the fighting and dancing moves, because I couldn't help myself. Robot is surprisingly stable when the battery's mostly charged.

Also wrote abstract, read a little about available sensors for the Robonova (can purchase sound sensors, touch sensors, light sensors, and IR sensors), Bluetooth compatibility, trying to use other languages other than Robobasic for programming the robot (a bit trickier; will probably require an interpreter to be created to translate Python/whatever code into Robobasic or something). Will read a little more about the latter, then will see about installing Pyro on me laptop cause the liveCD uses a different sort of Linux. May also try seeing just how stable the Robonova can be. Hah hah.

  • Becca (18-19 June 2008): I wrote my abstract. I also read about Turing tests for the presentation I'm giving on June 30th, read through part of The Ruby Programming Language, went through several online tutorials for Ruby, and learned more about Scheme. I've done lists and recursion now. I added more ideas to my spreadsheet about the graphical language, now named Dinah for Alice's cat in Alice in Wonderland (it pays tribute both to Alice and to Scratch, which has a cat as its main character). I don't know what to do with the spreadsheet once I have it more detailed and more organized, but I guess I can figure that out.
  • Becca (19 June 2008): Forgot to say that I also tested my dmg/mpkg file on the MacBook. It works fine, and I have added Numpy and PIL to it. Currently, it should download and install Numpy, PIL, Myro, xmpppy, and pyserial.
  • Meena (20 June 2008): Came up with initial list of functions that can be used for doing stuff with Robonova in Myro/Pyro:
#Commands

#stepForward()
#stepBackward()
#moveOneLeg("leg","direction")
##leg = left, right
##direction = forward, back, left, right, forOut, backOut, lOut, rOut, bend
#bend()
#moveArm("arm", "direction")
##arm = left, right
##direction = front, back, up, horiz, toChest
#standardPose()

#kick("direction")
##directon = left, right
#chop("direction")
##directon = left, right
#dance()
#fly()
#punch("direction")
##directon = left, right

#read<sensor>() //no sensors to read yet :/

#playSound(pitch, length)
#playMusic([listOfNotes])
##notes = A-G
##T = tempo;
##L = low octave;
##M = mid octave;
##H = high octave;
##+,# = sharp;
##$,- = flat
##. = dotted note
##P,<sp>,(rest) = rest
##<,L = drop an octave
##>,H = raise an octave
##1 = whole note; 2 = half note, 4 = quarter note, 8 = eighth note
##6 = sixteenth note; 0 = thirty-second note

Haven't actually written them yet; read some BASIC tutorials to get a better feel for the language so I could try and figure out how to make easy Python code that will also easily translate into a BASIC format. Read some info about hardware on Robonova and think RoboBasic does something to its code to make it recognizable to the software on the robot, and that this thing can't be emulated with other languages or compilers. There is a possible way to program in C, but the steps to getting to this point went over my head since I'm not familiar enough with hardware/software engineering, and procedure was potentially harmful to the robot if not carried out correctly. Also would not necessarily make the Python problem less of a problem. Problem might be able to be resolved with new chip that can accept languages like Python, but read that they might not work as quickly as the one included due to the amount of servos they have to control simultaneously. Also would require doing a lot of things I would rather not have to do (changing boards and stuff).

Week 5, June 23 - June 27, 2008

Meena (23 June 2008): No sensors to test out; will read through Myro code to figure out how robots are connected to the computer with Myro; test out more features of Robonova and maybe see if I can make the motions more fluid and/or "human-like."

Becca (23 June 2008): Worked with Scheme. Attempted to test broken code from workshop participant, but the bluetooth kept disconnecting. Tried to update the fluke but the command prompt in Windows said the command was not a proper command. Will try it in Linux tomorrow.

Meena (24 June 2008): Was going to install Pyro on my laptop, but instructions didn't explain how to install on Ubuntu-like OSes. Will mess around with it to see if it can be installed, since installing it on my comp will make debugging/learning easier. Will continue trying to get robot to walk more convincingly.

Kerstin: I needed a break from readings and simulations, so I wrote a program that probably works much like RAVQs (I don't know much about RAVQs though, so I might be wrong). My program takes vectors with numerical entries (preferably on the same scale) as input and arranges them in a list such that the (Euclidean) distance between neighboring list elements is minimal. Once the length of the list reaches a certain threshold it is split into two lists of variable length such that the total deviation of the elements in each list from the average (arithmetic mean) vector of that list is minimal. I implemented several ways to estimate the ideal cutoff for the list split, and finally settled with the exact but computationally expensive one. Then I tested the program with real pictures. I built a "playground" for a Scribbler robot that I laid out with white paper to reduce the background noise and put several items in it (pink ball, another Scribbler etc). I programmed one Scribbler to move through the playground with an obstacle avoidance behavior for about 1000 steps, taking a color picture at each step. I fed these pictures into my program, and I was quite surprised when the program sorted the pictures by object and not by background. The endeavor didn't have a whole lot to do with robot attention, but I had a good time and I finally know what I took statistics for. Tomorrow I will get back on track and start reading the books that you (Doug) gave me.

Meena (26 June 2008): Myro code leaves me to believe that software on Scribbler flukes is specifically designed to be able to receive whatever's sent in Python, so it won't help with getting Robonova to work with Python. RoboBasic apparently doesn't support any sort of inheritance, so I can't even make an abstract set of commands to use within RoboBasic. I borderline understand how to send byte commands in C while using a bluetooth device, but of course that doesn't help much here. :] Will just write a program that allows the person to write the commands in Python and then save a Robobasic-compatible file.

Becca (24-26 June 2008): The fluke is still not upgraded, but at least it's down to now knowing the serial port name now; the command for Linux works (add ./ to beginning). I made 12/15 robots kits for Monday's demo, and will make the other 3 on Friday. I read a lot more about Ruby and about Turing tests. I also organized my comments on Alice and Scratch into a list divided by subject. Some ideas depend on which age group Dinah is aimed at.

Week 6, June 30 - July 4th, 2008

Becca (30 June 2008): I helped with the workshop for high school girls through the morning and early afternoon. We taught them a good bit of the intro. course's syllabus, at their own pace, in a few hours. Maybe the kind of lab session we did would be effective in the intro. as well. I also installed Scratch on the XO laptop, and played with a Pico Cricket. It turns out that using a Pico Board (not included in the Cricket kit), you can add its sensors to Scratch and have them affect scripts. This sort of idea will probably be useful when incorporating the robots into Dinah. I added some more ideas to the Dinah list based on comments from educators on the Scratch website, for example, including the ability to comment code.

Meena (1 July 2008): Writing program to translate the simple Python commands into roboBasic. More annoying than previously expected, but almost done with recognizing if/else statements correctly (problem comes with the "end" statement that's got to come at the end of the whole block, instead of just after if blocks or just after else blocks).

Meena (2 July 2008): Finished program. Started on a GUI, and ended up with something resembling a grey chatroom window. Looking around to see if there's a(n easy) way of putting text boxes in a graphics window so I can make something that looks a tad nicer (I could do it with JAVA >__>;;; ). Made a short help dictionary for the GUI when it gets finished. Also looked at sensors again and picked out a few that seemed cool; lurked the RoboSavvy forums to see what bluetooth devices seemed most popular. Should get some sensors in soon.

Becca (1-2 July 2008): Got more ideas for Dinah, put together an initial GUI, which has now been trashed. I think it's going to be a regular programming language that just happens to be pieced together with blocks, rather than one which focuses on graphics and doing rather than returning. Read half of the article on programming languages designed to help beginners; noticed that most of them are graphics heavy or focused on a robot, with a few that just correct syntax. I prefer the graphics heavy/robot approach.

Priscy (3 July 2008): To reiterate what I said at the meeting on Tuesday, I've been reading the Pyro tutorial online at http://www.pyrorobotics.org and some articles on Developmental Robotics at http://cs.brynmawr.edu/devrob/pubs.html. While reading the tutorial, I've been doing a couple of sample programs and exercises. Currently, I'm reading up the neural networks section of the tutorial.

Week 7, July 7th - July 11th, 2008

Meena (7 July 2008): Will be working on GUI and the robot movements; see if I can make some original ones that could be useful for general programs, as well as make the existing movements better, nicer-looking.

Becca (7-8 July 2008): Read lots of articles about Alice, including a dissertation which gave me a lot of ideas about how to implement the graphics of Dinah so that they are intuitive. Will read articles about Scratch next, as well as finish the article about the various intro languages that are used. I also designed the look of the "blocks" for Dinah, and had the idea of making them handle boxes instead of customized buttons to make them easier to work with. I think robots will be just another kind of sprite in Dinah, and a dialog asking for the com port will pop up when one is added. Hopefully, it will pop up in front of the window, instead of behind it.

Becca (10 July 2008): I drew out the initial set of code blocks to use in Dinah, other than the Myro ones (under Dinah, Robots). I also put most of them into the main Pyjama window. I combined the play/pause/stop buttons with the stepper, using tooltips to make it clear what the buttons do. I created the webpage for my project, Dinah (see higher up on this page for the link as well). I have also started looking at CodeDOM, which is a "base language" which enables translation between its included programming languages. Dinah will be linked to CodeDOM.

Becca (11 July 2008): I finished adding the code blocks to Dinah, renamed a lot of the widgets to make it easier to find them, and started writing a program in pygtk to run Pyjama. So far, it opens the window and destroys it when it's closed. I read enough about buttons and their signals to make a start on that.

Week 8, July 14 - July 18th, 2008

  • Meena (16 July 2008): GUI got erased in freak Ubuntu accident, but apparently won't be needing it anyway.

Instead, have list of actions that will (as of now) be included in Myro (Along with their code letter. If you were interested.):

STANDARD_POSE    'A
BEND             'B
SIT              'C
STEP_FORWARD     'D
STEP_BACKWARD    'E
STEP_LEFT        'F
STEP_RIGHT       'G
TURN_LEFT        'H
TURN_RIGHT       'I
LEFT_KICK        'J
RIGHT_KICK       'K
LEFT_CHOP        'L
RIGHT_CHOP       'M
FORWARD_STANDUP  'N
BACKWARD_STANDUP 'O
PUNCH_FRONT      'P
PUNCH_LEFT       'Q
PUNCH_RIGHT      'R
TUMBLE_FORWARD   'S
TUBLE_BACKWARD   'T
CARTWHEEL_LEFT   'U
CARTWHEEL_RIGHT  'V

Writing the Myro stuff now.

  • Becca (14-16 July 2008): I figured out the drag and drop commands in GTK+ (after much banging of my head against an intangible wall), and set it up so that the four script blocks, when their "drag" button is dragged to the main script, appear in said script. It took a lot longer than it sounds like it took, and was much more complicated.
  • Meena (17 July 2008): Most attempts to contact robot via serial cable and pySerial ended in failure (a few made the robot spazz and beep a lot, so they were at least successful on that note). Probably has something to do with the serial cable; bluetooth should make this process work.

Learned the art of soldering; set up the fluke to be connected to the robot via wires. Battery on the robot wasn't enough to power fluke; had to use external power source for fluke. Then fluke was able to take a picture; robot does a bit of spazzing still when turned on/off, which is strange given no program loaded on it recently should be making it move unless it receives a special character telling it to do so. Is probably reading some real old programs; have to find a way to erase what's stored on the board so I can load the command program and test the bluetooth.

  • Meena (18 July 2008): Cleared old programs (hopefully). Robot having trouble with receiving commands through Bluetooth (unsure whether it has to do with hardware, Myro setup, or the pre-loaded RoboBASIC program).

EDIT: Robot was reading in binary, not ASCII. >___>

  • Becca (17-18 July 2008): I got a hello world program working--initially, it ran when you clicked on 'print', but I changed it to run when you click on 'play'. I also started writing up my Dinah notes for whoever gets this project next, added the project files to svn, started working on my poster, and updated the Dinah webpage. Finally, I added a lot of the Myro blocks to the Dinah window and changed all of the existing blocks to a format which would support the drag and drop. Next week I will start setting up the drag and drop for more blocks than just the scripts and print blocks.

Week 9, July 21 - July 25th, 2008

  • Meena (21 July 2008): Given the larger nature of the Robonova's present head, the fancy tumbling/cartwheel moves will not be included in the final Myro code after all.

Turned on robot with fluke; fluke started feeding all those bytes we'd sent it trying to get the bluetooth to work and the robot wouldn't stop bowing/bending until the fluke was unplugged. Was going to let the commands go through until they'd finished, but fluke and robot started running out of battery power. Will figure out problem so I can try doing something other than watching it bow repeatedly. Worked on a Powerpoint manual for Robonova; will include stuff it has, stuff it can have, and basics of how to program it to do stuff. Idea is to create something that the next person will be able to easily understand (unlike the included Instruction Manuals, which are written in Engrish and aren't always clear).

Edit: Attached on/off switch to fluke power, in order to try and limit amount of junk sent to robot (previously was plugging/unplugging the power for the fluke, which seemed to cause problems.

  • Becca (21 July 2008): Added many more buttons to the drag-and-drop. Also planned how to generate code (will just read line by line and execute code, instead of creating a file, using eval() and exec() methods).
  • Becca (23 July 2008): Moved scripts to script window so can switch between them. Set up creation of new tabs and drag-and-drop/script switching if only 2 tabs. Started drafting a file format for saved files to have.

Week 10, July 28th - August 1st, 2008

  • Meena (28 July 2008): Turns out robot uses TTL and fluke uses RS-232, which is why nothing worked. Teyvonia is finding way to make a converter for the fluke and robot; should be completed soon. Also improved instruction manual I started on, started reading about MRDS again, and reading about serial connections in more detail.
  • Becca (28 July 2008): Got multiple lines of code to drag and drop. Added more blocks to dnd, made drag_drop code a little bit prettier, and got one block to drop onto another (point onto line).