#!/usr/bin/env python
# coding: Latin-1
#import statements for required librarys
import threading
import PicoBorgRev
import time

#set up the piborg boards the
PBR = PicoBorgRev.PicoBorgRev()
PBR.busNumber = 0
PBR.i2cAddress = 0xA
PBR.Init()
PBR.ResetEpo()


PBR2 = PicoBorgRev.PicoBorgRev()
PBR2.busNumber = 0
PBR2.i2cAddress = 0x14
PBR2.Init()
PBR2.ResetEpo()


#PBR3 = PicoBorgRev.PicoBorgRev()
#PBR3.i2cAddress = 12
#PBR3.Init()
#PBR3.ResetEpo()

#Global BVariables for ride control
sleepTime = 10
cakeWalkRunning = False
ferrisWheelRunning = False
merryGoRoundRunning = False
swingBoatRunning = False
mLock = threading.Lock()


# class to ramp up a motor, this is a generic class 
# and takes a board and motor number
class mtrUp(threading.Thread):
    'ramp up class'
    def __init__(self, PBR, stepDelay, rampUp):
        threading.Thread.__init__(self)
        self.PBR = PBR
        self.stepDelay = stepDelay
        self.rampUp = rampUp
        
    def run(self):
        for step in self.rampUp:
            self.PBR(step)
            print ('%+.2f' % (step));
            time.sleep(self.stepDelay)
            
class mtrDwn(threading.Thread):
    'Ramp Down class'
    def __init__(self, PBR, stepDelay, rampDwn):
        threading.Thread.__init__(self)
        self.PBR = PBR
        self.delay = stepDelay
        self.rmpdwn = rampDwn
    
    def run(self):
        for step in self.rmpdwn:
            self.PBR(step)
            print ('%+.2f' % (step));
            time.sleep(self.delay)


class cakeWalk(threading.Thread): 
    'Controls cake walk'
    
    def __init__(self,PBR):
        threading.Thread.__init__(self)
        self.PBR = PBR
        self.stepDelay = 5
        self.sleepTime = 60
        self.rampUpFwd = [ +0.27,+0.28,+0.29, +0.3, +0.31, +0.32, +0.33, +0.34, +0.35]
        self.rampDownFwd = [+0.35, +0.34, +0.33, +0.32, +0.31, +0.3, +0.29, +0.28, +0.27]
           
    def run(self):
        global cakeWalkRunning
        if cakeWalkRunning == False:
            rmp1 = mtrUp(self.PBR.SetMotor1, self.stepDelay, self.rampUpFwd)
            rmp1.start()
            mLock.acquire()
            cakeWalkRunning = True
            mLock.release()
        print ('cakeWalkRunning value %s' % (cakeWalkRunning));
        
        time.sleep(self.sleepTime)
    
        if cakeWalkRunning == True:
            rmp1 = mtrDwn(self.PBR.SetMotor1, self.stepDelay, self.rampDownFwd)
            rmp1.start()
            mLock.acquire()
            cakeWalkRunning = False
            mLock.release()
        print ('cakeWalkRunning value %s' % (cakeWalkRunning));
                        
class ferrisWheel(threading.Thread): 
    'Controls ferris wheel'
    
    def __init__(self,PBR):
        threading.Thread.__init__(self)
        self.PBR = PBR
        self.stepDelay = 3
        self.sleepTime = 180
        self.rampUpFwd = [ +0.0, +0.1, +0.15, +0.2, +0.25, +0.3, +0.35]
        self.rampDownFwd = [+0.35, +0.3, +0.25, +0.2, +0.15, +0.1, +0.0]
           
    def run(self):
        global ferrisWheelRunning
        if ferrisWheelRunning == False:
            rmp2 = mtrUp(self.PBR.SetMotor1, self.stepDelay, self.rampUpFwd)
            rmp2.start()
            mLock.acquire()
            ferrisWheelRunning = True
            mLock.release()
        print ('ferrisWheelRunning value %s' % (ferrisWheelRunning));
        
        time.sleep(self.sleepTime)
    
        if ferrisWheelRunning == True:
            rmp2 = mtrDwn(self.PBR.SetMotor1, self.stepDelay, self.rampDownFwd)
            rmp2.start()
            mLock.acquire()
            ferrisWheelRunning = False
            mLock.release()
        print ('ferrisWheelRunning value %s' % (ferrisWheelRunning));

                        
class merryGoRound(threading.Thread):
    'Controls the merrygoround ride'

    def __init__(self, PBR):
        threading.Thread.__init__(self)
        self.PBR = PBR
        self.stepDelay = 5
        self.sleepTime = 60
        self.rampUpFwd = [ +0.0, +0.49, +0.50, +0.51, +0.52]
        self.rampDownFwd = [ +0.52, +0.51, +0.50, +0.49, +0.0]
    
       
    def run(self):
        global merryGoRoundRunning
        if merryGoRoundRunning == False:
            rmp1 = mtrUp(self.PBR.SetMotor2, self.stepDelay, self.rampUpFwd)
            rmp1.start()
            mLock.acquire()
            merryGoRoundRunning = True
            mLock.release()
        print ('merryGoRoundRunning value %s' % (merryGoRoundRunning));
        
        time.sleep(self.sleepTime)
    
        if merryGoRoundRunning == True:
            rmp1 = mtrDwn(self.PBR.SetMotor2, self.stepDelay, self.rampDownFwd)
            rmp1.start()
            mLock.acquire()
            merryGoRoundRunning = False
            mLock.release()
        print ('merryGoRoundRunning value %s' % (merryGoRoundRunning));

class swingBoat(threading.Thread):  
    'Controls Swing Boat'
    
    def __init__(self, PBR):
        threading.Thread.__init__(self)
        self.PBR = PBR
        self.stepDelay = 5
        self.sleepTime = 60
        self.rampUpRvs = [ -0.0,-0.5, -0.6, -0.7, -0.8, -0.9, -1.0]
        self.rampDownRvs = [-1.0, -0.9, -0.8, -0.7, -0.6, -0.5,-0.0]
    
    def run(self):
        global swingBoatRunning
        if swingBoatRunning == False:
            rmp3 = mtrUp(self.PBR.SetMotor2, self.stepDelay, self.rampUpRvs)
            rmp3.start()
            mLock.acquire()
            swingBoatRunning = True
            mLock.release()
        print ('swingBoat value %s' % (swingBoatRunning));
        
        time.sleep(self.sleepTime)
    
        if swingBoatRunning == True:
            rmp3 = mtrDwn(self.PBR.SetMotor2, self.stepDelay, self.rampDownRvs)
            rmp3.start()
            mLock.acquire()
            swingBoatRunning = False
            mLock.release()
        print ('swingBoat value %s' % (swingBoatRunning));


  
#main thread
if __name__ =='__main__':
    print ('Press CTRL C to Finish');

    try:
    
        while True:
#            if cakeWalkRunning == False:
 #               cWK = cakeWalk(PBR)
  #              cWK.start()
        
   #         time.sleep(sleepTime)
        
    #        if ferrisWheelRunning == False:
     #           fWL = ferrisWheel(PBR2)
      #          fWL.start()
                
       #     time.sleep(sleepTime)   
   
#            if swingBoatRunning == False:
 #               sBR = swingBoat(PBR)
  #              sBR.start()
        
        #    time.sleep(sleepTime)
            
            if merryGoRoundRunning == False:
                mGR = merryGoRound(PBR)
                mGR.start()
                
            time.sleep(sleepTime)



    except KeyboardInterrupt:
        #stop all motors 
        PBR.MotorsOff()