First Prototype Reflection

Code Review

The code could be divided into 3 parts, codes in Arduino IDE, code to receive data from Arduino, and code to convert and play out as music.

The code in the Arduino UNO is just a simple could to print out the serials data of the FSR.

To output the music notes and chords, it's essential to define music note as a Class in the program:

noteDict = {}               #create a dictionary for music notes

Notes = ["c2","c2s","d2","d2s","e2","f2","f2s","g2","g2s","a2","a2s","b2","c3","c3s","d3","d3s","e3","f3","f3s","g3","g3s","a3","a3s","b3","c4","c4s","d4","d4s","e4","f4","f4s","g4","g4s","a4","a4s","b4","c5"]

startpoint = 48

for i in Notes:

    noteDict[i] = startpoint

    startpoint += 1

The midi signal is formed by several numbers, each music notes was matched with a certain integer, we have middle C(C3) match with 60, and we could easily know the other numbers.

Create class for music notes and chords：

class Note():                   # A class of the music notes

    

    def __init__(self, notename):

        self._notename = notename

    def get_note_number(self):

        return noteDict[self._notename]

    def play_notes(self, duration, velocity):

        return [self.get_note_number(), duration, velocity]

        

for i in Notes:             # create instance for each note

    locals()[i] = Note(i)

class Chord():              # A class of chords, which is fromed by a list of notes

    def __init__(self,notes):

        self.notes = notes

        self.base = notes[0]

    

    def note_included(self, note):

        included = False

        for i in self.notes:

            if i.get_note_number() == note.get_note_number():

                included = True

        return included

    

    def get_notes(self):

        return self.notes

# Pre defined common chords

chord_C = Chord([c2,g2,e3])

chord_Cmaj7 = Chord([c2,e2,g2,b2])

chord_D7 = Chord([d2,a2,c3])

chord_Dm7 = Chord([d2,f2,a2,c3])

chord_E7 = Chord([e2,g2s,b2,d3])

chord_F = Chord([f2,c3,f3])

chord_G = Chord([g2,b2,d3])

chord_Am = Chord([a2,c3,e3])

chord_Bdim = Chord([b2,d3,f3])

chord_Em = Chord([e2,g2,b2])

Use rtmidi to send virtual signal to music software.

class Player():

    '''A Class of the music player'''

    def __init__(self):

        self.midiout = rtmidi.MidiOut()

        self.available_ports = self.midiout.get_ports()

        #print(available_ports)

        if self.available_ports:

            self.midiout.open_port(0)

        else:

            self.midiout.open_virtual_port("My virtual output")

    def play_note_start(self,note, velocity):               #Start to send a midi signal that start a music note

        self.midiout.send_message([0x90, note.get_note_number(),velocity])

    def play_note_end(self, note):

        self.midiout.send_message([0x80, note.get_note_number(),0])

    def play_chordnote(self, target, duration, velocity):           

        # [(c3,chord_C)]

        if type(target) !=tuple:

            self.note = target

            # play single note

            self.play_note_start(self.note, velocity)

            time.sleep(duration*0.8)

            self.play_note_end(self.note)

            time.sleep(duration*0.2)

        else:

            #play chord and note

            self.note = target[0]

            self.chord = target[1]

            self.play_note_start(self.note,velocity)

            interval = (len(self.chord.get_notes())-1)*0.1

            for i in self.chord.get_notes():

                self.play_note_start(i,velocity*0.7)

                time.sleep(duration*0.05)

            time.sleep(duration*(0.8-interval))

            self.play_note_end(self.note)

            time.sleep(duration*0.2)

            for i in self.chord.get_notes():

                self.play_note_end(i)

    def close(self):

        del self.midiout

A music note played with midi is based on following parameters, the certain note that is going to be played, velocity of the note, and duration. The duration is actualy not a independent parameter, the whole signal if formed by Start message and End message, the start message define the time start to play the note and the end will stop it.

Converting data into Drum Beats is based on following code:

when the read data is larger than 500, the program start to send a start message of a drum beats and if it drop under 500 send a message to stop it.

while 1:

    data = server.readline()                

    result = convertData(data)

    print(hit,result)               # Read data from Arduino UNO

    if result>500:

        if hit == False:

            if hit_count%2 == 1:

                player1.play_note_start(e2,100)

            else:

                player1.play_note_start(f2,100)

            hit = True

            hit_count += 1

            continue

    elif result < 500:

        if hit == True:

            if hit_count%2 == 1:

                player1.play_note_end(e2)

            else:

                player1.play_note_end(f2)

            hit = False

            continue

    else:

        continue

Code used to play chords progression:

We pre defined some chords progressions for testing, it should be able for user to change it.

Chords_Kanon = [chord_C, chord_G, chord_Am, chord_Em, chord_F, chord_C, chord_F, chord_G]

Chords_Blues = [chord_Cmaj7, chord_Dm7, chord_E7, chord_F, chord_G, chord_Am, chord_Bdim, chord_Cmaj7]

while 1:

    data = server.readline()

    result = convertData(data)

    last_chord = Chords_Kanon[hit_count%8-1]

    this_chord = Chords_Kanon[hit_count%8]

    print(hit,result)

    if result ==0:

        if hit == True:

            player1.play_chords_end(this_chord)

            hit = False

            hit_count += 1

    else:

        if hit == False:

            player1.play_chords_start(this_chord,int(result/6))

            hit = True

        else:

            player1.play_chords_end(this_chord)

            player1.play_chords_start(this_chord, int(result/6))

player1.close()

server.close

The velocity of the chords is based on the pressure use placed on the sensor. Each time the system detect a "Press" action, it will change the chord to play.

This Week

This week we were planning for our final prototype, we are going to combine our work together for the exhibition. Our final prototype will be an installation in a much larger scale than teh current one, so we will need some more materials.

We discussed the form our prototype will be. There should be a structure to contain all the sensors and wires inside, and should be stable enough to allow our user to stand on. It should be like a "Box", the FSR sensor placed on the top of the surface, and LED lights on the bottom side. The top surface should be transparent to allow the light comes out. So we considered Acrylic Board. Also it should be structed on its edge and corner a little bit higher than the ground to allow sensors and wires stuff.

Future plan

For the comming weeks, the focus of the work will be deciding "how we are going to allow our user to switch between different types of exercising". We could have a switch for our user to switch themselves, we could also have the system to detect it automactically, however there are still things need to be considered.

If we have system detect it automatically: there will be a lot of code work, and I am not sure whether we could carry it out, it may involve some work concern machine learning...

If we have our user to select themselves:We need to find a way to allow our user select the type of exercise, we don't have buttons, switch nor remote or touch screen, so it might be related with the sensor, but we still need some user research to support our idea.