CS 1020 - Winter 2013 - Class 5
- Eight-ball competition on Friday
- Have your robots ready to start at 9pm
- work out all of the bugs, etc. the night before
- come in a few minutes early and make sure everything is still working :)
- make sure to plug in your boards AND turn them off the night before (they charge much better when they're off)
- We'll run the competition with the lights off and the blinds down
- this will make it easier on your sensors
- test your robot in these conditions!
- Time limit?
- Visit Quarry Hill School on Friday at 1pm
- ~30 minutes at the school (should be back by 2, 2:30 at the latest)
- we'll need to put together a few robots to take along
- extra credit
- who want to come?
- looking for 7-10 people...
- who can drive?
- may have another visit for another school, but I'll keep you posted...
look at the bad-motor procedure in
- what will it do when I run it?
- the *hope* is that it will change the direction when the switch is press
- It doesn't though. What will it actually do?
- when you hold down the switch it will constantly reverse direction until you let go
- what is the problem?
- the key problem is that "switch 7" becomes true the when the switch is activated
- this is called an "edge" triggered event
- draw diagram
- in some situations this is great
- in others, not so great :(
- one solution is to put in a "wait" command after the "a, rd"
- how long do we wait for?
- what we really want is for the direction to change, but then not continue in the loop (i.e. check switch 7 again) until the switch is released
- how could we write that?
- look at good-motor procedure
- what does it mean for two things to happen "concurrently"?
- at the same time
- what does concurrency mean for computers?
- concurrency is crucial for modern computers/computer science
- rarely is any one single thing running on a computer at a time
- you can actually see all the different things running at once
- we can talk some other time about how that actually happens on the hardware...
what does concurrency mean for a computer program?
- the program can be doing multiple things simultaneously
- normally when we think about a program we think about it executed a sequential set of steps
- with concurrency a program can have 2 or more sequential set of steps occurring at the same time
- in the simplest case, think of running two procedures **at the same time**
- a "process" is a single executing unit that executes its code sequentially (this is not quite technically ture with multi-threading, but we'll ignore that complication for now)
- concurrency involves running multiple processes at the "same time"
Handy Logo concurrency
- run motor-demo from
- Notice that while the song is playing I can still interact with the motor via the switch
- with what we've learned so far, could you do this?
- No! (or definitely not very easily)
- what is happening?
- we have two separate things running at the same time:
- our play-song procedure
- our good-motor procedure
- the launch command executes some code concurrent (i.e. in parallel) to the current running code
- specifically it creates a new process and starts executing the code
- the main process then continues to run
- the two processes run concurrently
- given the launch command, how could I get the behavior from motor-demo?
- call launch with either play-song OR good-motor
- then, call the other one after it normally
- a similar command to launch is forever, which execute the code in the square brackets over and over again as if it were in a loop **as a separate process**!
- run motor-demo2 from
- how could we do this with forever?
- want to beep and wait in a loop continuously
- put that in a forever statement
when [some-question] [some-code]
- the when statement allows us to execute some-code whenever some-question is true
- similar to an if statement
- however, this checking and executing happens in a different process
- the current code does NOT stop and continues executing
- think of it like telling Logo to listen in the background, but to continue doing what it was doing
- could we implement the same beeping and motor changing behavior with a when statement?
- look at motor-demo3 in
every <time> [some-code]
- executes some-code in another process (i.e. concurrently or in the background) every <time> tenths of a second
- similar to when
- when: runs only when a particular
- every: runs at some timed interval
- could we implement the same beeping and motor changing behavior with an every statement?
- look at motor-demo4 in
- eventually, you may want to stop having your concurrent processes running in the background
- the "stoprules" command stops all processes that were spawned by the current process EXCEPT those that were started with launch
- look at motor-demo5 in
- what will happen when I run the code?
- what will happen when I activate sensor 7?
- what will happen when I active sensor 8?
- will anything happen if I now activate sensor 7 again?
look at fancy-ping-pong in
- what does the procedure do?
- similar to the ping-pong procedure you wrote
- but makes beeping noises when it backs up
- why do we need the stoprules?
- it kills the parallel process that was beeping up
- notice that this is one of the advantages of not using launch
look at too-much-concurrency in
- what does the procedure do?
- causes trouble :)
- loops and concurrency often don't mix
- we'll freeze up the Handy board
- basically we spawn a bunch of processes from the loop
- generally, just don't include concurrency in loops
look at eight-ball-challenge in
- here's a hypothetical example of how concurrency might be useful
- in theory we might be able to do all of these things in one giant loop
- can make things much cleaner (and easier to debug) by making them separate procedures run concurrently
- we've seen time come up with a few commands
- sometimes wait isn't enough
- Handy Logo has a built in timer that counts by tenths up to ~64s (I wouldn't go past 30)
- two associate commands
- resett: resets the timer
- timer: gets the current value of the timer
- look at procedures in