Monday, December 14, 2015

EIPS eSports Tournament 2015

image credit: D. Tomeldan
Last Friday (December 11, 2015) EIPS hosted it's first official eSports tournament at Salisbury Composite High School. There was a total of about 120 junior high and high school students in two parallel competitions, League of Legends 5v5 (team) and Super Smash Bros. Brawl Project M 1v1 (individual). Competitors represented Ardrossan Junior Senior High, Bev Facey Community High School, Clover Bar Junior High, F. R. Haythorne Junior High School, Fultonvale School, Salisbury Composite High SchoolStrathcona Christian Academy Secondary School, and Vegreville Composite High.

While competitors were charged $10 each to cover the cost of prizes and a donation to the Stollery Children's Hospital Foundation at the behest of Nitza's Pizza.
the prize table
Nitza's Pizza provided pizzas for lunch.
Microsoft provided Xbox One consoles for casual gaming.
Winners of the Project M competition (left to right): King (SAL) in first, Crow (SAL) in second, and HDPizzas (AJS) in third.

Unfortunately due to time constraints the LoL tournament bracket wasn't completed, but the judges consulted the statistics and decided to award the prizes to Team GHZ from SCS.
Team GHZ

setting up early in the morning
students checking in and reporting game outcomes
Project M competition screens
Project M on the south side
League on the north side
some LoL student shoutcasters
The day was live streamed via YouTube for wide angle and Project M, and Twitch for LoL. Unfortunately many comments on both streams were somewhat toxic, so commenting was disabled on YouTube and moderated by EIPS staff on Twitch. You can also view a flyover video of the experience.

Participants were expected to abide by a code of conduct, and we didn't have any behavior issues from competitors or spectators.

As organizers we had expected that parents and staff would be questioning the value of a video game tournament during a school. We were prepared to talk about how students are often pulled out of classes for traditional sports tournaments, that many of the benefits of sports are also evident in esports, and that these students are often under-served by traditional extracurricular activities. However we were surprised at how positive and encouraging everyone has been about this event.

We've been encouraged to start planning the next event. Hopefully there will be another grades 7 to 12 tournament in the spring, as well as an elementary tournament at some point soon. Games being considered are Rocket League, Mario KartHalo 5, and Hearthstone. Obviously the latter two are rated "Teen" and won't be used for elementary tournaments.

Tuesday, May 19, 2015

Bulk generation of custom short URLs for prefilled Google forms

One of the departments at work wanted to send out pre-filled Google Forms to parents based on a CSV file that they generated from their database.

Check out this Python script I wrote for them that generates a shortened URL for each line in the CSV file.

Feel free to use and share, and to ask for clarification where documentation or comments are lacking.

Just a reminder, of course, to consider FOIP or other privacy implications associated with any data being submitted via online forms or stored in the cloud.

Thursday, April 23, 2015

Automated Drive Imaging for Xubuntu Install

Instead of sending old laptops to ewaste, we are experimenting with having students install Xubuntu on them. So we made a class set of installation DVDs and had a three classes (Grade 4, Grade 6, and Grade 9) install Xubuntu on some older Dell Latitude machines (D530, E6400, and E6410 respectively). That seems to be going well so far, but that's a topic for another post.

Where we needed to change tactics was with some Dell Latitude 2100 machines. Our set of install DVDs wouldn't work because they are 32 bit and don't have optical drives. We consider netboot install, but that seemed overly complicated. So a USB-based solution... the easy answer is to just install Xubuntu from USB Stick, but since the devices are mostly identical perhaps an imaging solution.

Enter Clonezilla.

There are two options here. One option is similar to netboot, but we chose instead to create a few USB drives that would boot the computer and automatically clone a previously-created image on to the hard drive.

So now all a student (or teacher) needs to do in order to set up a new machine (or "fix" a machine that a student has "adjusted") is to insert the USB drive, turn on the computer, press F12, and boot from the USB Storage Device.

For those interested in how the USB storage devices were constructed, we started from this post. For everyone else, check out this cool graph.

Saturday, March 14, 2015

16-channel relay box controlled by a Raspberry Pi

It's not quite finished yet, but it's in a usable state. This isn't full instructions, but hopefully enough to get you started if you're interested. Please comment below if you'd like more information.

Some of the Parts:
8-Channel 5V Relay Board (two of these)
Raspberry Pi, SD card, associated cables
female to female jumper wire for connecting Raspberry Pi GPIO pins to relay board pins
thick wire for connecting relays to outlets
nine outlets
CNC or laser-cut front plate from this drawing
LightShow Pi software (haven't tried this yet)




An example Python script to flash through the relays one at a time:


import time
delayTime = 0.25
import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BCM)
pins = [2, 3, 4, 17, 27, 22, 10, 9, 14, 15, 18, 23, 24, 25, 8, 7]

for pin in pins:
    GPIO.setup(pin, GPIO.OUT) 
    GPIO.output(pin, GPIO.HIGH)
    time.sleep(delayTime)
    GPIO.output(pin, GPIO.LOW)
    time.sleep(delayTime)
GPIO.cleanup

Wednesday, March 11, 2015

Elementary Music and Notes in Sonic Pi

In this activity we are going to play some notes with Sonic Pi.

The song "Johnny Works With One Hammer" is a fairly simple tune, listen to someone singing it:



Did you hear how the sound goes higher and lower? Sonic Pi will play higher sounds when you tell it to play higher numbers, and lower sounds with lower numbers. Try pasting this into Sonic Pi and pushing play to see how it sounds:

# Johnny part one
use_bpm 200
play_pattern [53, 53, 53, 57, 60, 53, 53]

Each of those numbers is a different sound, what we would call a different note. You heard higher numbers as higher sounds, which are higher notes. The use_bpm part is just telling Sonic Pi how fast to play.
But let's get back to our song. We've seen that we can play high and low sounds by telling Sonic Pi to play different numbers.

The number pattern for the first part of "Johnny Works With One Hammer" would be:
53 53 53 57 60 53 53
55 60 60 57 53 53

I've done the first line of the song, try pasting it into Sonic Pi and then completing the second line of numbers.

# Johnny part one
use_bpm 200
play_pattern [53, 53, 53, 57, 60, 53, 53]
play_pattern []

Did that sound like the song we are trying to play? It was close, but some of the notes are supposed to be longer than others. So instead of play_pattern we can use play_pattern_timed, like this:

# Johnny part one and two, with timing
play_pattern_timed [53, 53, 53, 57, 60, 53, 53], [0.25, 0.25, 0.25, 0.25, 0.5, 0.25, 0.25]
play_pattern_timed [55, 60, 60, 57, 53, 53], [0.5, 0.25, 0.25, 0.5, 0.25, 0.25]

The second list of numbers on each line is the amount of time that Sonic Pi will play the note for. Notice that the note 60 will be played for a longer time (0. 5 seconds). In musical notation we say that the shorter notes are "quarter notes" because they take up a quarter of a bar. The longer notes here are half notes. See what the notes would look like for this part of the song.


A quarter note is sort of a filled-in circle, a half note looks kind of hollow. Now let's try to make our program easier for humans to read by storing the note patterns and timing patterns before we actually play them:

# Johnny part one and two, with timing
play_pattern_timed [53, 53, 53, 57, 60, 53, 53], [0.25, 0.25, 0.25, 0.25, 0.5, 0.25, 0.25]
play_pattern_timed [55, 60, 60, 57, 53, 53], [0.5, 0.25, 0.25, 0.5, 0.25, 0.25]

That's starting to look complicated, but hopefully you can see how it can be broken down into parts. There are four "arrays" there, which are basically lists of numbers. The first one is called notes1 and it contains the notes for the first line of the song. The array called timings1 is a list of how long to play each of those notes. Then we just say play_pattern_timed notes1, timings1 when we want to have Sonic Pi play that list of notes with those timings. Let's try it including variables as well. Will this play the same song?

# Johnny with variables and arrays
quarter = 0.25
half = 0.5
notes1 = [53, 53, 53, 57, 60, 53, 53]
timings1 = [0.25, 0.25, 0.25, 0.25, 0.5, 0.25, 0.25]
notes2 = [55, 60, 60, 57, 53, 53]
timings2 = [0.5, 0.25, 0.25, 0.5, 0.25, 0.25]
play_pattern_timed notes1, timings1
play_pattern_timed notes2, timings2

In this example, we said the time for the shorter notes (quarter notes) should be a quarter of a second (0.25) and the time for a longer note (half note) should be half of a second (0.5). We could also have said:

quarter = 1.0/4
half = 1.0/2

or even:

quarter = 1.0/4
half = quarter/2

In case you're curious, the reason it is 1.0/4 instead of 1/4 is that we need to tell Sonic Pi that we want the numbers to be type float instead of integer. If we said1/4 it would equal 0. Don't worry about this yet though.

Hopefully you are starting to see that there can be a lot of math in music. So far we have done the first half of the song "Johnny Works With One Hammer". If I show you the musical notation version of the whole song, do you think you could translate it into something that Sonic Pi could play? It's a little bit like figuring out a code, you need to figure out what numbers mean the same thing as the notes in the musical notation.



You can also try out different instruments by putting a line like one of these at the top of your code:
use_synth :pretty_bell
use_synth :fm

So now you can make music with Sonic Pi. Try some other songs, and tell your friends.

Monday, February 23, 2015

Elementary Music and Sonic Pi Drum Loops

We are going to investigate drum beats and learn a little programming. If you don't have Sonic Pi installed, you'll need to have that done.

Paste the following code into one of the Sonic Pi workspaces, and click Run.


# Drum loop one, half notes
beat_length = 0.25

4.times do
sample :drum_heavy_kick
sleep beat_length
sample :drum_snare_hard
sleep beat_length
end

This is a basic drum loop. Let’s look at the parts of the code line by line.
  1. The # symbol means that anything on the rest of the line is a comment. It’s for humans to read, the computer ignores it.
  2. We’ve made a variable named beat_length that means a value of 0.25. We’ll use this a few times later.
  3. This line is blank so we know that there is something different coming next.
  4. Here we are creating a loop that will do something four times.
  5. This plays a sample (recording) of a kick drum.
  6. The command sleep means to rest for a certain amount of time (in seconds). It will rest for the time stored in the variable beat_length.
  7. Play a different sample, this time a snare drum.
  8. This tells the computer that it is the end of the loop that started on line 4.


Now lets try adding a few things to the code to make it look like this:


# Drum loop two, quarter notes
beat_length = 0.5

4.times do
sample :drum_heavy_kick
sample :drum_cymbal_closed
sleep beat_length
sample :drum_snare_hard
sample :drum_cymbal_open
sleep beat_length
end


When you click Run you’ll hear high hat cymbal playing at the same time as the kick and snare drums.


Bars of music often have four beats in them, so let’s change it to this and it will play four bars with four beats in each:


# Drum loop three, quarter notes
beat_length = 0.5

4.times do
sample :drum_heavy_kick
sample :drum_cymbal_closed
sleep beat_length
sample :drum_snare_hard
sample :drum_cymbal_open
sleep beat_length
sample :drum_heavy_kick
sample :drum_cymbal_closed
sleep beat_length
sample :drum_snare_hard
sample :drum_cymbal_open
sleep beat_length
end


Now try changing the value in the beat_length variable to 0.25 or 0.7, and try replacing some of those samples with different drum samples:
sample :drum_heavy_kick
sample :drum_tom_mid_soft
sample :drum_tom_mid_hard
sample :drum_tom_lo_soft
sample :drum_tom_lo_hard
sample :drum_tom_hi_soft
sample :drum_tom_hi_hard
sample :drum_splash_soft
sample :drum_splash_hard
sample :drum_snare_soft
sample :drum_snare_hard
sample :drum_cymbal_soft
sample :drum_cymbal_hard
sample :drum_cymbal_open
sample :drum_cymbal_closed
sample :drum_cymbal_pedal
sample :drum_bass_soft
sample :drum_bass_hard


Cool, eh.


Next we’ll try some different rhythms by playing some samples halfway between beats. If each beat before was a quarter note, these would be eighth notes (because half of a quarter is an eighth). Listen to the kick drum:


# Drum loop four, quarter and eighth notes
beat_length = 0.5

4.times do
sample :drum_heavy_kick
sample :drum_cymbal_closed
sleep beat_length
sample :drum_snare_hard
sample :drum_cymbal_open
sleep beat_length/2
sample :drum_heavy_kick
sleep beat_length/2
sample :drum_heavy_kick
sample :drum_cymbal_closed
sleep beat_length
sample :drum_snare_hard
sample :drum_cymbal_open
sleep beat_length
end

That seems to be getting a little long, though, let’s try the same thing with a loop:


# Drum loop five, another loop
beat_length = 0.5

4.times do
sample :drum_heavy_kick
sample :drum_cymbal_closed
sleep beat_length
sample :drum_snare_hard
sample :drum_cymbal_open
2.times do
  sleep beat_length/2
  sample :drum_heavy_kick
end
sample :drum_cymbal_closed
sleep beat_length
sample :drum_snare_hard
sample :drum_cymbal_open
sleep beat_length
end


Not much shorter, but hopefully you get the idea. We two spaces at the beginnings of lines 11 and 12 to show that they belong to a different loop. The computer ignores the spaces, but it makes it easier for other people to read your code. If you want to learn more about code style in this language, check out the Ruby Style Guide.


Getting back to loops, though, try this:


# Drum loop six, another loop
beat_length = 0.5

4.times do
3.times do
  sample :drum_heavy_kick
  sample :drum_cymbal_closed
  sleep beat_length
end
sample :drum_snare_hard
sample :drum_cymbal_open
sleep beat_length
end


You can see that on the first three beats we played the same samples, then different samples on the fourth beat.


Now let’s try some functions.


# Drum loop seven, with functions
beat_length = 0.5

def kickAndClosed
  sample :drum_heavy_kick
  sample :drum_cymbal_closed
end

def kickAndOpen
  sample :drum_heavy_kick
  sample :drum_cymbal_open
end

4.times do
3.times do
  kickAndClosed
  sleep beat_length
end
kickAndOpen
sleep beat_length
end


First we define two functions (using the term def) and then we can call them by their names to get them to do their thing. A function is just a set of instructions that you can reuse later. You might also hear them called methods, procedures, subroutines, or callable units.


Let’s try something with parameters.


# Drum loop eight, with parameters
def play_a_beat(chosen_sample, beat_length)
  sample chosen_sample
  sleep beat_length
end

4.times do
  play_a_beat(:drum_cymbal_closed,0.25)
end


The variables chose_sample and beat_length are passed to the function when it is called.


Now see if you can figure out what this next section of code will do, and then run it to check if you’re right.


# Drum loop nine, nested functions
def cymbalClosed(beat_length)
  sample :drum_cymbal_closed
  sleep beat_length
end

def loop_this(n)
  n.times do
  cymbalClosed 0.25
  end
end

loop_this 16


One more thing, if you want your beat to go on forever, or until you stop it, try this.


# Drum loop ten, in_thread
beat_length = 0.25

in_thread do
  loop do
  sample :drum_heavy_kick
  sample :drum_cymbal_closed
  sleep beat_length
  sample :drum_snare_hard
  sample :drum_cymbal_closed
  sleep beat_length
  end
end


So now you know the basics of creating beats in Sonic Pi. Show your friends.


If you’d like to play with electronic drum machines and make different rhythms, check out free drum machines such as:
DMach (Android)
Hydrogen (Windows, Mac, or Linux)
GarageBand (iOS or Mac)
HammerHead (Windows)

Wednesday, February 18, 2015

what I'm up to these days

A while back I had been blogging daily about what I do, but had found that I seemed to then gravitate towards tasks that I could accomplish easily and then write about at the end of the day.

Instead, I'm going to occasionally write about some things I'm working on. This will include work-related things as well as tasks and projects related to the Masters in Education that I'm hoping to have completed by April 2016.

One of the bigger work-related projects I'm working on these days is open data. We are working on getting some of our data on Strathcona County's Open Data Portal, as well as taking data that we already release and posting it in a more accessible format. We are also interested in getting teachers and students utilizing open data. As I write this, International Open Data Day is coming up soon.

On a somewhat-related note, we're also looking at Open Badges to highlight professional learning among staff in EIPS.

In terms of ongoing work in EIPS, I wrote up a list the other day of things we are often talking to staff about these days.
And a few things on my to do list at work:
  • publish to do list
  • plan Scratch Day
  • Moodle migration
  • automate creation of Google Apps users from PowerSchool
  • build a Minecraft server image with a web-based (or VNC) control panel
  • help plan summer school technology camps
  • explore web-based project management ideas
And a little Python script I wrote today to translate addresses into latitude and longitude coordinates:

Hopefully next time I'll write about some course-related things that are in progress.