#!/usr/bin/env python3
# Control snowflake and "Wizards in Winter" (Trans-Siberian Orchestra) over Bluetooth/USB/3.5mm/HDMI (I have some lines of code commented out for using the 3.5mm jack or HDMI)
# Give snowflake its own power supply (sharing GND with the Pi)
# Requires "04 - Wizards in Winter.mp3" to be in the folder.
# Be sure to have already done...
#   sudo apt-get install mpg123
# If using audio for first time since reboot, I have encountered delays or errors!
#  (c) 2018 Bradley Knockel

# The song...
#  https://youtu.be/okyO1Fze7Jo
#  https://musescore.com/user/25698851/scores/4787304

# If using Bluetooth, you should already be paired with the speakers.
# The following worked for me...
#   sudo apt-get install bluealsa
#   sudo bluetoothctl
#     power on
#     scan on
#     scan off  <-- wait until the device shows up (device in discoverable mode)
#     connect 00:13:EF:00:05:17    <-- replace MAC address with one found by scanning
#     disconnect 00:13:EF:00:05:17  <-- wait until connected
#     quit

# Numbering I use for my snowflake:
#    1
#   6 2   <-- row 2
#   5 3   <-- row 3
#    4


# use USB speakers instead of Bluetooth?
USBinstead = True
USBstartSleep = 0.28
volume = 30  # between 0 and 255

# for Bluetooth speakers
MACaddress=b"00:13:EF:00:05:17"
startSleep = 0.77


pin1 = 21
pin2 = 20
pin3 = 16
pin4 = 12
pin5 = 7  # CE1
pin6 = 8  # CE0

freq = 100  # for PWM

# seconds for an eighth note
eighth=0.2023  

# for after the song, here's a time in seconds
timme=0.25




import RPi.GPIO as IO
IO.setmode(IO.BCM)
IO.setup(pin1, IO.OUT)
IO.setup(pin2, IO.OUT)
IO.setup(pin3, IO.OUT)
IO.setup(pin4, IO.OUT)
IO.setup(pin5, IO.OUT)
IO.setup(pin6, IO.OUT)
p1 = IO.PWM(pin1, freq)
p2 = IO.PWM(pin2, freq)
p3 = IO.PWM(pin3, freq)
p4 = IO.PWM(pin4, freq)
p5 = IO.PWM(pin5, freq)
p6 = IO.PWM(pin6, freq)
p1.start(0)
p2.start(0)
p3.start(0)
p4.start(0)
p5.start(0)
p6.start(0)



def write1(c):
  p1.ChangeDutyCycle(c)
def write2(c):
  p2.ChangeDutyCycle(c)
def write3(c):
  p3.ChangeDutyCycle(c)
def write4(c):
  p4.ChangeDutyCycle(c)
def write5(c):
  p5.ChangeDutyCycle(c)
def write6(c):
  p6.ChangeDutyCycle(c)


def writeAll(c):
  p1.ChangeDutyCycle(c)
  p2.ChangeDutyCycle(c)
  p3.ChangeDutyCycle(c)
  p4.ChangeDutyCycle(c)
  p5.ChangeDutyCycle(c)
  p6.ChangeDutyCycle(c)

def writeRow2(c):
  p2.ChangeDutyCycle(c)
  p6.ChangeDutyCycle(c)

def writeRow3(c):
  p3.ChangeDutyCycle(c)
  p5.ChangeDutyCycle(c)



t=100
f=0
half = 6.25   # 100 * 2^4 / 2^8

# As decimal part of phase goes from 0.0 to 0.5,
#   brightness increases exponentially from 1 to 100
# As decimal part of phase goes from 0.5 to 1.0,
#   brightness decreases exponentially from 100 to 1
def brightness(phase):
  phase = phase - int(phase)
  if phase<=0.5 and phase>=0.0:
    return int(min(2.**(phase*13.2877),100.0))
  elif phase>0.5 and phase<=1.0:
    return int(min(2.**((1.0-phase)*13.2877),100.0))
  else:
    return 0  # if phase is negative

# As phase goes from 0.0 to 0.5,
#   brightness increases exponentially from 1 to 100
# As phase goes from 0.5 to 1.0,
#   brightness decreases exponentially from 100 to 1
def brightness2(phase):
  if phase<=0.5 and phase>=0.0:
    return int(min(2.**(phase*13.2877),100.0))
  elif phase>0.5 and phase<=1.0:
    return int(min(2.**((1.0-phase)*13.2877),100.0))
  else:
    return 0  # if phase is negative or larger than 1.0





import time




def blink(c):
  a=(c-time.time())/2
  writeAll(t)
  time.sleep(c-a-time.time())
  writeAll(f)
  time.sleep(c-time.time())




# Does not care about previous LED state.
# Leaves 2,4 on
def alternate(c):
  a=(c-time.time())/2
  write1(t)
  writeRow2(f)
  writeRow3(t)
  write4(f)
  time.sleep(c-a-time.time())
  write1(f)
  writeRow2(t)
  writeRow3(f)
  write4(t)
  time.sleep(c-time.time())




def towardsCenterA(c):
  a=(c-time.time())/6
  write1(half)
  time.sleep(c-5*a-time.time())
  write1(t)
  time.sleep(c-4*a-time.time())
  writeRow3(half)
  time.sleep(c-3*a-time.time())
  write1(half)
  writeRow3(t)
  time.sleep(c-2*a-time.time())
  write1(f)
  writeRow3(t)
  time.sleep(c-a-time.time())
  writeRow3(half)
  time.sleep(c-a/2-time.time())
  writeRow3(f)
  time.sleep(c-time.time())




def towardsCenterB(c):
  a=(c-time.time())/6
  write4(half)
  time.sleep(c-5*a-time.time())
  write4(t)
  time.sleep(c-4*a-time.time())
  writeRow2(half)
  time.sleep(c-3*a-time.time())
  write4(half)
  writeRow2(t)
  time.sleep(c-2*a-time.time())
  write4(f)
  writeRow2(t)
  time.sleep(c-a-time.time())
  writeRow2(half)
  time.sleep(c-a/2-time.time())
  writeRow2(f)
  time.sleep(c-time.time())



def towardsCenter(c):
  a=(c-time.time())/6
  write1(half)
  write4(half)
  time.sleep(c-5*a-time.time())
  write1(t)
  write4(t)
  time.sleep(c-4*a-time.time())
  writeRow2(half)
  writeRow3(half)
  time.sleep(c-3*a-time.time())
  write1(half)
  write4(half)
  writeRow2(t)
  writeRow3(t)
  time.sleep(c-2*a-time.time())
  write1(f)
  write4(f)
  writeRow2(t)
  writeRow3(t)
  time.sleep(c-a-time.time())
  writeRow2(half)
  writeRow3(half)
  time.sleep(c-a/2-time.time())
  writeRow2(f)
  writeRow3(f)
  time.sleep(c-time.time())


def shrinkTowardsTop(c):
  a=(c-time.time())/4
  writeAll(t)
  time.sleep(c-3*a-time.time())
  write4(f)
  time.sleep(c-2*a-time.time())
  writeRow3(f)
  time.sleep(c-a-time.time())
  writeRow2(f)
  time.sleep(c-a/2-time.time())
  write1(f)
  time.sleep(c-time.time())



updates = 50 # should be an even number
def moveUpAndDown(c):
  a=(c-time.time())
  b=time.time()
  for i in range(1,updates//2+1):
    d=0.5 + 1.5*(time.time()-b)/a
    write4(brightness2(d))
    writeRow3(brightness2(d-1.0/4.0))
    writeRow2(brightness2(d-2.0/4.0))
    write1(brightness2(d-3.0/4.0))
    time.sleep(c - (updates-i)*a/updates - time.time())
  for i in range(updates//2+1,updates+1):
    d=0.5 + 1.5*(1.0-(time.time()-b)/a)
    write4(brightness2(d))
    writeRow3(brightness2(d-1.0/4.0))
    writeRow2(brightness2(d-2.0/4.0))
    write1(brightness2(d-3.0/4.0))
    time.sleep(c - (updates-i)*a/updates - time.time())
  writeAll(f)



def neat(c):
  a=(c-time.time())
  b=time.time()
  for i in range(1,updates//2+1):
    d=2.0*(time.time()-b)/a
    write4(brightness(d))
    writeRow3(brightness(d+3.0/4.0))
    writeRow2(brightness(d+2.0/4.0))
    write1(brightness(d+1.0/4.0))
    time.sleep(c - (updates-i)*a/updates - time.time())
  for i in range(updates//2+1,updates+1):
    d=2.0 - 2.0*(time.time()-b)/a
    write4(brightness(d))
    writeRow3(brightness(d+3.0/4.0))
    writeRow2(brightness(d+2.0/4.0))
    write1(brightness(d+1.0/4.0))
    time.sleep(c - (updates-i)*a/updates - time.time())
  writeAll(f)



def moveFromCenter(c):
  a=(c-time.time())/5
  writeRow2(t)
  writeRow3(t)
  time.sleep(c-3*a-time.time())
  writeRow2(f)
  writeRow3(f)
  write1(t)
  write4(t)
  time.sleep(c-a-time.time())
  write1(f)
  write4(f)
  time.sleep(c-time.time())


def moveFromCenter2(c):
  a=(c-time.time())/4
  writeAll(t)
  time.sleep(c-3*a-time.time())
  write1(f)
  write4(f)
  time.sleep(c-2*a-time.time())
  writeRow2(f)
  writeRow3(f)
  write1(t)
  write4(t)
  time.sleep(c-a-time.time())
  write1(f)
  write4(f)
  time.sleep(c-time.time())


# leaves all LEDs on
def towardsCenter2(c):
  a=(c-time.time())/5
  write1(t)
  time.sleep(c-4*a-time.time())
  write4(t)
  time.sleep(c-3*a-time.time())
  writeRow2(t)
  time.sleep(c-2*a-time.time())
  writeRow3(t)
  time.sleep(c-time.time())


def flowUpwards(c):
  a=(c-time.time())/4
  write4(t)
  time.sleep(c-3*a-time.time())
  write4(f)
  writeRow3(t)
  time.sleep(c-2*a-time.time())
  writeRow3(f)
  writeRow2(t)
  time.sleep(c-a-time.time())
  writeRow2(f)
  write1(t)
  time.sleep(c-time.time())
  write1(f)



updates2 = 20
def flowUpwards2(c):
  a=(c-time.time())
  b=time.time()
  for i in range(1,updates2+1):
    d=(time.time()-b)/a
    write4(brightness(d))
    writeRow3(brightness(d+3.0/4.0))
    writeRow2(brightness(d+2.0/4.0))
    write1(brightness(d+1.0/4.0))
    time.sleep(c - (updates2-i)*a/updates2 - time.time())
  writeAll(f)


# YouTube tree did this as moveFromCenter,
# but I don't have enough LED sections
def moveUpwards(c):
  a=(c-time.time())/6
  write4(t)
  time.sleep(c-5*a-time.time())
  write4(f)
  writeRow3(t)
  time.sleep(c-4*a-time.time())
  writeRow3(f)
  writeRow2(t)
  time.sleep(c-2*a-time.time())
  writeRow2(f)
  write1(t)
  time.sleep(c-time.time())
  write1(f)




# leaves all LEDs on
def growUpwards(c):
  a=(c-time.time())/4
  write4(t)
  time.sleep(c-3*a-time.time())
  writeRow3(t)
  time.sleep(c-2*a-time.time())
  writeRow2(t)
  time.sleep(c-a-time.time())
  write1(f)
  time.sleep(c-time.time())


# leaves rows 1 and 3 lit
def moveUpwardsDouble(c):
  a=(c-time.time())/8
  writeAll(t)
  time.sleep(c-7*a-time.time())
  writeAll(f)
  write4(t)
  time.sleep(c-6*a-time.time())
  write4(f)
  writeRow3(t)
  time.sleep(c-4*a-time.time())
  writeRow3(f)
  write4(t)
  writeRow2(t)
  time.sleep(c-2*a-time.time())
  writeRow2(f)
  write4(f)
  write1(t)
  writeRow3(t)
  time.sleep(c-time.time())


def fallWithStyle(c):
  a=(c-time.time())/4
  write1(t)
  time.sleep(c-3*a-time.time())
  write1(f)
  writeRow3(t)
  time.sleep(c-2*a-time.time())
  writeRow3(f)
  writeRow2(t)
  time.sleep(c-a-time.time())
  writeRow2(f)
  write4(t)
  time.sleep(c-time.time())
  write4(f)






def spinCW(a):
  a=a/6
  write1(t)
  time.sleep(a)
  write1(f)
  write2(t)
  time.sleep(a)
  write2(f)
  write3(t)
  time.sleep(a)
  write3(f)
  write4(t)
  time.sleep(a)
  write4(f)
  write5(t)
  time.sleep(a)
  write5(f)
  write6(t)
  time.sleep(a)
  write6(f)


# leaves all on
def spinCW_on(a):
  a=a/6
  write1(t)
  time.sleep(a)
  write2(t)
  time.sleep(a)
  write3(t)
  time.sleep(a)
  write4(t)
  time.sleep(a)
  write5(t)
  time.sleep(a)
  write6(t)
  time.sleep(a)


# Requires all to be on.
# Leaves all on.
def spinCW_dark(a):
  a=a/6
  write1(f)
  time.sleep(a)
  write1(t)
  write2(f)
  time.sleep(a)
  write2(t)
  write3(f)
  time.sleep(a)
  write3(t)
  write4(f)
  time.sleep(a)
  write4(t)
  write5(f)
  time.sleep(a)
  write5(t)
  write6(f)
  time.sleep(a)
  write6(t)


# requires all to be on
def spinCW_off(a):
  a=a/6
  write1(f)
  time.sleep(a)
  write2(f)
  time.sleep(a)
  write3(f)
  time.sleep(a)
  write4(f)
  time.sleep(a)
  write5(f)
  time.sleep(a)
  write6(f)
  time.sleep(a)



def spinCCW(a):
  a=a/6
  write1(t)
  time.sleep(a)
  write1(f)
  write6(t)
  time.sleep(a)
  write6(f)
  write5(t)
  time.sleep(a)
  write5(f)
  write4(t)
  time.sleep(a)
  write4(f)
  write3(t)
  time.sleep(a)
  write3(f)
  write2(t)
  time.sleep(a)
  write2(f)



# leaves all on
def spinCCW_on(a):
  a=a/6
  write1(t)
  time.sleep(a)
  write6(t)
  time.sleep(a)
  write5(t)
  time.sleep(a)
  write4(t)
  time.sleep(a)
  write3(t)
  time.sleep(a)
  write2(t)
  time.sleep(a)



# Requires all to be on.
# Leaves all on.
def spinCCW_dark(a):
  a=a/6
  write1(f)
  time.sleep(a)
  write1(t)
  write6(f)
  time.sleep(a)
  write6(t)
  write5(f)
  time.sleep(a)
  write5(t)
  write4(f)
  time.sleep(a)
  write4(t)
  write3(f)
  time.sleep(a)
  write3(t)
  write2(f)
  time.sleep(a)
  write2(t)



# requires all to be on
def spinCCW_off(a):
  a=a/6
  write1(f)
  time.sleep(a)
  write6(f)
  time.sleep(a)
  write5(f)
  time.sleep(a)
  write4(f)
  time.sleep(a)
  write3(f)
  time.sleep(a)
  write2(f)
  time.sleep(a)










def spinOppCW(a):
  a=a/3
  write1(t)
  write4(t)
  time.sleep(a)
  write1(f)
  write4(f)
  write2(t)
  write5(t)
  time.sleep(a)
  write2(f)
  write5(f)
  write3(t)
  write6(t)
  time.sleep(a)
  write3(f)
  write6(f)



# leaves all on
def spinOppCW_on(a):
  a=a/3
  write1(t)
  write4(t)
  time.sleep(a)
  write2(t)
  write5(t)
  time.sleep(a)
  write3(t)
  write6(t)
  time.sleep(a)




# Requires all to be on.
# Leaves all on.
def spinOppCW_dark(a):
  a=a/3
  write1(f)
  write4(f)
  time.sleep(a)
  write1(t)
  write4(t)
  write2(f)
  write5(f)
  time.sleep(a)
  write2(t)
  write5(t)
  write3(f)
  write6(f)
  time.sleep(a)
  write3(t)
  write6(t)


# requires all to be on
def spinOppCW_off(a):
  a=a/3
  write1(f)
  write4(f)
  time.sleep(a)
  write2(f)
  write5(f)
  time.sleep(a)
  write3(f)
  write6(f)
  time.sleep(a)



def spinOppCCW(a):
  a=a/3
  write1(t)
  write4(t)
  time.sleep(a)
  write1(f)
  write4(f)
  write3(t)
  write6(t)
  time.sleep(a)
  write3(f)
  write6(f)
  write2(t)
  write5(t)
  time.sleep(a)
  write2(f)
  write5(f)



# leaves all on
def spinOppCCW_on(a):
  a=a/3
  write1(t)
  write4(t)
  time.sleep(a)
  write3(t)
  write6(t)
  time.sleep(a)
  write2(t)
  write5(t)
  time.sleep(a)




# Requires all to be on.
# Leaves all on.
def spinOppCCW_dark(a):
  a=a/3
  write1(f)
  write4(f)
  time.sleep(a)
  write1(t)
  write4(t)
  write3(f)
  write6(f)
  time.sleep(a)
  write3(t)
  write6(t)
  write2(f)
  write5(f)
  time.sleep(a)
  write2(t)
  write5(t)


# requires all to be on
def spinOppCCW_off(a):
  a=a/3
  write1(f)
  write4(f)
  time.sleep(a)
  write3(f)
  write6(f)
  time.sleep(a)
  write2(f)
  write5(f)
  time.sleep(a)








def spinDoubleCW(a):
  a=a/3
  write1(t)
  write2(t)
  time.sleep(a)
  write1(f)
  write2(f)
  write3(t)
  write4(t)
  time.sleep(a)
  write3(f)
  write4(f)
  write5(t)
  write6(t)
  time.sleep(a)
  write5(f)
  write6(f)


def spinDoubleCCW(a):
  a=a/3
  write1(t)
  write6(t)
  time.sleep(a)
  write1(f)
  write6(f)
  write5(t)
  write4(t)
  time.sleep(a)
  write5(f)
  write4(f)
  write2(t)
  write3(t)
  time.sleep(a)
  write2(f)
  write3(f)






def spinDouble2CW(a):
  a=a/6
  write6(t)
  write1(t)
  time.sleep(a)
  write6(f)
  write2(t)
  time.sleep(a)
  write1(f)
  write3(t)
  time.sleep(a)
  write2(f)
  write4(t)
  time.sleep(a)
  write3(f)
  write5(t)
  time.sleep(a)
  write4(f)
  write6(t)
  time.sleep(a)
  write5(f)
  write6(f)


def spinDouble2CCW(a):
  a=a/6
  write2(t)
  write1(t)
  time.sleep(a)
  write2(f)
  write6(t)
  time.sleep(a)
  write1(f)
  write5(t)
  time.sleep(a)
  write6(f)
  write4(t)
  time.sleep(a)
  write5(f)
  write3(t)
  time.sleep(a)
  write4(f)
  write2(t)
  time.sleep(a)
  write2(f)
  write3(f)






def spinTripleCW(a):
  a=a/6
  write5(t)
  write6(t)
  write1(t)
  time.sleep(a)
  write5(f)
  write2(t)
  time.sleep(a)
  write6(f)
  write3(t)
  time.sleep(a)
  write1(f)
  write4(t)
  time.sleep(a)
  write2(f)
  write5(t)
  time.sleep(a)
  write3(f)
  write6(t)
  time.sleep(a)
  write4(f)
  write5(f)
  write6(f)


def spinTripleCCW(a):
  a=a/6
  write3(t)
  write2(t)
  write1(t)
  time.sleep(a)
  write3(f)
  write6(t)
  time.sleep(a)
  write2(f)
  write5(t)
  time.sleep(a)
  write1(f)
  write4(t)
  time.sleep(a)
  write6(f)
  write3(t)
  time.sleep(a)
  write5(f)
  write2(t)
  time.sleep(a)
  write2(f)
  write3(f)
  write4(f)





# leaves all LEDs on
def spinFinishCW(a):
  a=a/12
  write4(t)
  write5(t)
  write6(t)
  write1(t)
  time.sleep(a)
  write4(f)
  write2(t)
  time.sleep(a)
  write5(f)
  write3(t)
  time.sleep(a)
  write6(f)
  write4(t)
  time.sleep(a)
  write1(f)
  write5(t)
  time.sleep(a)
  write2(f)
  write6(t)
  time.sleep(a)
  write1(t)  # now doing 5 at a time
  time.sleep(a)
  write3(f)
  write2(t)
  time.sleep(a)
  write4(f)
  write3(t)
  time.sleep(a)
  write5(f)
  write4(t)
  time.sleep(a)
  write6(f)
  write5(t)
  time.sleep(a)
  write1(f)
  write6(t)
  time.sleep(a)
  write1(t)





def blink0(a):
  a=a/2
  writeAll(t)
  time.sleep(a)
  writeAll(f)
  time.sleep(a)


# Does not care about previous LED state.
# Leaves 2,4,6 on
def alternate1(a):
  a=a/2
  write1(t)
  write2(f)
  write3(t)
  write4(f)
  write5(t)
  write6(f)
  time.sleep(a)
  write1(f)
  write2(t)
  write3(f)
  write4(t)
  write5(f)
  write6(t)
  time.sleep(a)



# Does not care about previous LED state.
# Leaves 3,5 on, and maybe 1,4 if they were on previously.
# Looks like wings!
def alternate2(a):
  a=a/2
  write2(t)
  write3(f)
  write5(f)
  write6(t)
  time.sleep(a)
  write2(f)
  write3(t)
  write5(t)
  write6(f)
  time.sleep(a)



# Does not care about previous LED state.
# Leaves 3,6 on, and maybe 1,4 if they were on previously.
# Looks like a seesaw!
def alternate3(a):
  a=a/2
  write2(t)
  write3(f)
  write5(t)
  write6(f)
  time.sleep(a)
  write2(f)
  write3(t)
  write5(f)
  write6(t)
  time.sleep(a)


# Does not care about previous LED state.
# Leaves 3,6 on, and maybe 1,4 if they were on previously.
# Goes left to right!
def alternate4(a):
  a=a/2
  write2(f)
  write3(f)
  write5(t)
  write6(t)
  time.sleep(a)
  write2(t)
  write3(t)
  write5(f)
  write6(f)
  time.sleep(a)






def spinSequence():
  spinCW(timme)
  spinCW(timme)
  time.sleep(timme)
  
  spinCCW(timme)
  spinCCW(timme)
  time.sleep(timme)

  spinCW_on(timme)
  spinCW_dark(timme)
  spinCW_dark(timme)
  spinCW_dark(timme)
  spinCW_off(timme)
  time.sleep(timme)

  spinCCW_on(timme)
  spinCCW_dark(timme)
  spinCCW_dark(timme)
  spinCCW_dark(timme)
  spinCCW_off(timme)
  time.sleep(timme)

  spinCW(timme)
  spinCCW(timme)
  spinCW(timme)
  spinCCW(timme)
  time.sleep(timme*2)




  spinOppCW(timme)
  spinOppCW(timme)
  time.sleep(timme)
  
  spinOppCCW(timme)
  spinOppCCW(timme)
  time.sleep(timme)

  spinOppCW_on(timme)
  spinOppCW_dark(timme)
  spinOppCW_dark(timme)
  spinOppCW_dark(timme)
  spinOppCW_off(timme)
  time.sleep(timme)

  spinOppCCW_on(timme)
  spinOppCCW_dark(timme)
  spinOppCCW_dark(timme)
  spinOppCCW_dark(timme)
  spinOppCCW_off(timme)
  time.sleep(timme)

  spinOppCW(timme)
  spinOppCCW(timme)
  spinOppCW(timme)
  spinOppCCW(timme)
  time.sleep(timme*2)




  spinDoubleCW(timme*2)
  spinDoubleCW(timme*2)
  spinDoubleCW(timme*2)
  time.sleep(timme*2)

  spinDoubleCCW(timme*2)
  spinDoubleCCW(timme*2)
  spinDoubleCCW(timme*2)
  time.sleep(timme*2)




  spinDouble2CW(timme*2)
  spinDouble2CW(timme*2)
  spinDouble2CW(timme*2)
  time.sleep(timme*2)

  spinDouble2CCW(timme*2)
  spinDouble2CCW(timme*2)
  spinDouble2CCW(timme*2)
  time.sleep(timme*2)




  spinTripleCW(timme*2)
  spinTripleCW(timme*2)
  spinTripleCW(timme*2)
  time.sleep(timme*2)

  spinTripleCCW(timme*2)
  spinTripleCCW(timme*2)
  spinTripleCCW(timme*2)
  time.sleep(timme*2)


  # neat!
  spinCW(timme)
  spinDouble2CW(timme)
  spinTripleCW(timme)
  spinFinishCW(timme*2)
  time.sleep(timme*2)
  writeAll(f)
  time.sleep(timme*2)


  # wings
  alternate2(timme)
  alternate2(timme)
  writeAll(f)
  time.sleep(timme)


  # seesaw
  alternate3(timme)
  alternate3(timme)
  writeAll(f)
  time.sleep(timme)


  # left to right
  alternate4(timme)
  alternate4(timme)
  writeAll(f)
  time.sleep(timme)


  alternate1(timme)
  alternate1(timme)
  writeAll(t)
  time.sleep(timme*4)
  spinCW_dark(timme*2)
  spinCCW_dark(timme*2)
  spinCW_dark(timme*2)
  spinCCW_dark(timme*2)
  time.sleep(timme*2)
  alternate2(timme*2)
  alternate2(timme*2)
  alternate2(timme*2)
  alternate2(timme*2)
  alternate2(timme*2)
  alternate2(timme*2)
  writeAll(t)
  time.sleep(timme*2)
  alternate1(timme)
  alternate1(timme)
  writeAll(f)
  time.sleep(timme*4)

  blink0(timme)
  blink0(timme)




import subprocess
if USBinstead:

  ## get some info
  #subprocess.call(["aplay", "-l"])
  #subprocess.call(["amixer", "-c0", "contents"])
  #subprocess.call(["amixer", "-c1", "contents"])

  ## the following lines are for using the 3.5mm jack or HDMI
  #subprocess.call(["amixer", "-c0", "cset", "numid=1", str(volume)])
  #proc1 = subprocess.Popen(["mpg123", "--no-control", "-a", "plughw:0", "04 - Wizards in Winter.mp3"])

  subprocess.call(["amixer", "-c1", "cset", "numid=3", str(volume)])
  #time.sleep(10)  # to fix a bug with running "mpg123 -a" right away
  proc1 = subprocess.Popen(["mpg123", "--no-control", "-a", "plughw:1", "04 - Wizards in Winter.mp3"])
  time.sleep(USBstartSleep)

else:

  # start Bluetooth!
  proc0 = subprocess.Popen(["sudo", "bluetoothctl"], bufsize=0, stdin=subprocess.PIPE)
  time.sleep(1)
  proc0.stdin.write(b'connect '+MACaddress+b'\n')
  time.sleep(10)
  proc1 = subprocess.Popen([b"mpg123", b"--no-control", b"-a", b"bluealsa:HCI=hci0,DEV="+MACaddress+b",PROFILE=a2dp", b"04 - Wizards in Winter.mp3"], bufsize=0, stdin=subprocess.PIPE)
  time.sleep(startSleep)



try:





  timee = time.time()

  timee += eighth*3*8
  towardsCenterA(timee)
  timee += eighth*8
  shrinkTowardsTop(timee)

  timee += eighth*3*8
  towardsCenterB(timee)
  timee += eighth*8
  shrinkTowardsTop(timee)

  timee += eighth*4
  moveUpAndDown(timee)
  timee += eighth*4
  moveUpAndDown(timee)
  timee += eighth*4
  moveUpAndDown(timee)
  timee += eighth*4
  moveUpAndDown(timee)
  timee += eighth*4
  moveUpAndDown(timee)
  timee += eighth*4
  moveUpAndDown(timee)
  timee += eighth*8
  shrinkTowardsTop(timee)

  for i in range(6):  # at measure 13
    timee += eighth*4
    moveUpAndDown(timee)
  timee += eighth*2
  blink(timee)
  timee += eighth;time.sleep(timee-time.time())
  timee += eighth*5
  moveFromCenter(timee)

  timee += eighth*2
  blink(timee)
  timee += eighth;time.sleep(timee-time.time())
  timee += eighth*5
  moveFromCenter(timee)
  timee += eighth*2
  blink(timee)  # start measure 18
  timee += eighth;time.sleep(timee-time.time())
  timee += eighth*2
  alternate(timee)
  timee += eighth*2;time.sleep(timee-time.time())
  timee += eighth*2
  alternate(timee)
  timee += eighth;time.sleep(timee-time.time())
  timee += eighth*4
  alternate(timee)
  write1(t);writeRow2(f);writeRow3(t);write4(f);timee += eighth;time.sleep(timee-time.time())
  writeAll(f);timee += eighth;time.sleep(eighth)

  for i in range(6):  # at measure 20
    timee += eighth*4
    moveUpAndDown(timee)
  timee += eighth*2
  blink(timee )
  timee += eighth;time.sleep(timee-time.time())
  timee += eighth*5
  moveFromCenter(timee)
  
  for i in range(6):  # at measure 24
    timee += eighth*4
    moveUpAndDown(timee)
  timee += eighth*2
  blink(timee)
  timee += eighth;time.sleep(timee-time.time())
  timee += eighth*5
  moveFromCenter(timee)

  timee += eighth*2
  blink(timee)  #start measure 28
  timee += eighth;time.sleep(timee-time.time())
  timee += eighth*5
  moveFromCenter(timee)
  timee += eighth*2
  blink(timee)  # start measure 29
  timee += eighth;time.sleep(timee-time.time())
  timee += eighth*2
  alternate(timee)
  timee += eighth*2;time.sleep(timee-time.time())
  write1(t);writeRow2(f);writeRow3(t);write4(f);timee += eighth;time.sleep(timee-time.time())

  timee += eighth*16
  shrinkTowardsTop(timee) # measures 30 and 31
    
  # measures 32, 33, 34, 35
  for i in range(16):
    timee += eighth*2
    flowUpwards(timee)

  # 1:02 in the YouTube video
  for i in range(3):
    timee += eighth*2;time.sleep(timee-time.time())
    timee += eighth*6
    moveUpwards(timee)
  timee += eighth*8
  flowUpwards(timee)  # measure 39
  
  for i in range(3):
    timee += eighth*2;time.sleep(timee-time.time())
    timee += eighth*6
    moveUpwards(timee)
  timee += eighth*8
  flowUpwards(timee)  # measure 43

  timee += eighth*2
  blink(timee)
  timee += eighth;time.sleep(timee-time.time())
  timee += eighth*5
  moveFromCenter(timee)
  timee += eighth*2
  blink(timee)
  timee += eighth;time.sleep(timee-time.time())
  timee += eighth*5
  moveFromCenter(timee)
  timee += eighth*2
  blink(timee)  # start measure 46
  timee += eighth;time.sleep(timee-time.time())
  timee += eighth*2
  alternate(timee)
  timee += eighth*2;time.sleep(timee-time.time())
  timee += eighth*2
  alternate(timee)
  timee += eighth;time.sleep(timee-time.time())
  timee += eighth*4
  alternate(timee)
  write1(t);writeRow2(f);writeRow3(t);write4(f);timee += eighth;time.sleep(timee-time.time())
  writeAll(f);timee += eighth;time.sleep(timee-time.time())

  for i in range(6):  # at measure 48
    timee += eighth*4
    moveUpAndDown(timee)
  timee += eighth*8
  shrinkTowardsTop(timee)

  for i in range(6):
    timee += eighth*4
    moveUpAndDown(timee)
  timee += eighth*2
  blink(timee)
  timee += eighth;time.sleep(timee-time.time())
  timee += eighth*5
  moveFromCenter(timee) # end at 1:34 in YouTube

  timee += eighth*2
  blink(timee)  #start measure 56
  timee += eighth;time.sleep(timee-time.time())
  timee += eighth*5
  moveFromCenter(timee)
  timee += eighth*2
  blink(timee)  # start measure 57
  timee += eighth;time.sleep(timee-time.time())
  timee += eighth*5
  towardsCenter2(timee)
  timee += eighth*16
  shrinkTowardsTop(timee) # measures 58 and 59

  timee += eighth*8
  growUpwards(timee)  #measure 60
  timee += eighth*8
  shrinkTowardsTop(timee)  #measure 61

  for i in range(32):
    timee += eighth
    blink(timee)
    timee += eighth*2
    blink(timee)
    timee += eighth
    blink(timee)
 
  # at measure 78 (at 2:10 in YouTube video)
  timee += eighth*2
  blink(timee)
  timee += eighth;time.sleep(timee-time.time())
  timee += eighth*5
  moveFromCenter(timee)
  timee += eighth*2
  blink(timee)
  timee += eighth;time.sleep(timee-time.time())
  timee += eighth*5
  moveFromCenter(timee)
  timee += eighth*2
  blink(timee)  # start measure 80
  timee += eighth;time.sleep(timee-time.time())
  timee += eighth*2
  alternate(timee)
  timee += eighth*2;time.sleep(timee-time.time())
  timee += eighth*2
  alternate(timee)
  timee += eighth;time.sleep(timee-time.time())
  timee += eighth*4
  alternate(timee)
  write1(t);writeRow2(f);writeRow3(t);write4(f);timee += eighth;time.sleep(timee-time.time())
  writeAll(f);timee += eighth;time.sleep(timee-time.time())

  for i in range(6):  # at measure 82
    timee += eighth*4
    moveUpAndDown(timee)
  timee += eighth*8
  shrinkTowardsTop(timee)

  for i in range(6):  # at measure 13
    timee += eighth*4
    moveUpAndDown(timee)

  timee += eighth*8
  moveUpwardsDouble(timee) # measure 89 (at 2:28 in YouTube video)
  writeRow2(t);write4(t);timee += eighth*2;time.sleep(timee-time.time())  # measure 90
  for i in range(3):
    timee += eighth*2
    alternate(timee)
  writeRow3(t);write1(t);timee += eighth/2;time.sleep(timee-time.time())  # start measure 91
  write1(f);writeRow2(t);writeRow3(f);write4(t);timee += eighth/2;time.sleep(timee-time.time())
  for i in range(3):
    timee += eighth
    alternate(timee)
  writeRow3(t);write1(t);timee += eighth/2;time.sleep(timee-time.time())
  write1(f);writeRow2(t);writeRow3(f);write4(t);timee += eighth/2;time.sleep(timee-time.time())
  for i in range(3):
    timee += eighth
    alternate(timee)
  for i in range(3):  # at measure 92
    timee += eighth*2
    moveUpAndDown(timee)
  timee += eighth*2
  shrinkTowardsTop(timee)

  #measures 93,94,95,96,97,98,99,100
  for i in range(16):
    timee += eighth*4
    moveUpAndDown(timee)  

  # at 2:47 in YouTube video
  for i in range(4):
    timee += eighth*4
    fallWithStyle(timee)

  for i in range(32):
    timee += eighth
    blink(timee)

  # at measure 107 (at 2:57 in YouTube video)
  timee += eighth*4
  shrinkTowardsTop(timee)
  timee += eighth*4
  moveFromCenter2(timee)
  timee += eighth*4
  moveUpwardsDouble(timee)
  timee += eighth*2
  blink(timee)
  timee += eighth*2
  alternate(timee)
  timee += eighth*4
  shrinkTowardsTop(timee)
  timee += eighth*4
  moveFromCenter2(timee)
  timee += eighth*4
  moveUpwardsDouble(timee)
  timee += eighth*2
  blink(timee)
  timee += eighth*2
  alternate(timee)
  # I guess the sheet sheet music leaves out 2 measures!

  # measures 109 and 110 of sheet music
  for i in range(8):
    timee += eighth*2
    flowUpwards2(timee)

  # measure 111 of sheet music
  timee += eighth*4
  blink(timee)



  time.sleep(5)
  spinSequence() # takes a while!
  time.sleep(5)
  # below are unused functions that are really neat!
  towardsCenter(time.time()+24*eighth)
  while 1:
    neat(time.time()+4*eighth)
  

  

 


except:
  pass


## cleanup GPIO
p1.stop()
p2.stop()
p3.stop()
p4.stop()
p5.stop()
p6.stop()
IO.cleanup()

## cleanup audio
proc1.terminate()
if not USBinstead: # for Bluetooth
  time.sleep(1)
  proc0.stdin.write(b'disconnect '+MACaddress+b'\n'+b'quit\n')
  proc0.stdin.close()