def main(channel = 'Z'):
    ##channel = 'X' # This can be 'X' or 'Y' or 'Z' channels
    min_position = -4 # mm
    max_position = 12.2 # m
    rate = 0.5 # number of points written per second to the stage
    density = 2 # number of points across the full scale range
    wait =  6 # Wait time before sweeping back in seconds

    x_mm_array_f = numpy.linspace(min_position,max_position,density)
    x_mm_array_b = numpy.linspace(max_position,min_position,density)
    xps = qt.instruments['xps']

    while 1:
        if (msvcrt.kbhit() and (msvcrt.getch() == 'q')): break
        print 'Sweeping %s forward...' % channel
        for i in x_mm_array_f:
            xps.set('abs_position%s' % channel, i)
            time.sleep(1.0/rate)
        time.sleep(wait)
        if (msvcrt.kbhit() and (msvcrt.getch() == 'q')): break
        print 'Sweeping %s backward...' % channel
        for i in x_mm_array_b:
            xps.set('abs_position%s' % channel, i)
            time.sleep(1.0/rate)
        time.sleep(wait)


    f_string = 'set_abs_position' + channel
    # Create function that corresponds to the abs_position set function of
    # the correct channel, then call it to reset the voltage to 0.
    reset_channel = getattr(xps, f_string)
    reset_channel(0.0)
    return

def player(sm, sprite, fb, global_frame_number: int):
    fb_width = len(fb[0])
    fb_height = len(fb)
    # Reduce invincibility frames TODO checks if attribute exists or better, make invincibility more generic
    if sprite.info['invincibility'] > 0:
        sprite.info['invincibility'] -= 1
    # Player movement
    if msvcrt.kbhit():
        x = sprite.info['x']
        y = sprite.info['y']
        parsed_chars = set()
        while msvcrt.kbhit():
            input_char = msvcrt.getch()
            input_int = struct.unpack('B', input_char)[0]
            if input_int in parsed_chars:
                continue
            parsed_chars.add(input_int)
            if input_char == b'w':
                sprite.info['y'] = max(0, y - 2)
            if input_char == b's':
                sprite.info['y'] = min(fb_height - sprite.info['height'], y + 2)
            if input_char == b'a':
                sprite.info['x'] = max(0, x - 3)
            if input_char == b'd':
                sprite.info['x'] = min(fb_width - sprite.info['width'], x + 3)
            if input_char == b'\x1b':
                # See game loop for details
                sprite.info['ai_quit_to_main_menu'] = True
    # Player is shooting every 10 frames
    sprite.info['ai_last_move'] += 1
    if sprite.info['ai_last_move'] > 3:
        sm.add_sprite('projectile_p_big', sprite.info['x'] + sprite.info['width'], sprite.info['y'])
        sprite.info['ai_last_move'] = 0

def alarm(hours, minutes, seconds):
    time.sleep(abs(hours * 3600 + minutes * 60 + seconds))
    while msvcrt.kbhit():
        msvcrt.getch()
    while not msvcrt.kbhit():
        winsound.Beep(440, 250)
        time.sleep(0.25)

def get_ui_to(prompt, toSec=None, tSleepSec=None):
  # import sys
  from time import time, sleep
  from msvcrt import getch, getche, kbhit

  if toSec==None: # wait forever
    userKey = raw_input(prompt)
    return userKey

  tElapsed = 0
  t0 = time()
  if tSleepSec == None:
    tSleep = 0.1*toSec
  else:
    tSleep = tSleepSec
  while True:
    if tElapsed > toSec:
      print "Timeout after tElapsed secs...%.3f"%tElapsed
      userKey = ''
      break
    print "\n", prompt,
    if kbhit():
      userKey = getche()
      while kbhit(): # flush input
        getch() # sys.stdin.flush()
      # userKey = raw_input(prompt)
      break
    # print "sleep tSleep secs...%.3f"%tSleep
    sleep(tSleep)
    tNow = time()
    tElapsed = tNow - t0

  return userKey

def update():
    global bx, by, vx, vy, p1, p2, score, paused
    if msvcrt.kbhit():
        k = msvcrt.getch()
        if msvcrt.kbhit():
            k += msvcrt.getch()
        if k == b'\xe0K' and not paused:
            p1 -= 2
        elif k == b'\xe0M' and not paused:
            p1 += 2
        elif k == b'p':
            paused = not paused
        elif k in (b'\x1b', b'q'):
            return QUIT
    if paused:
        return CONT
    p1 = max(4, min(W-5, p1))
    p2 = max(4, min(W-5, bx))
    bx += vx
    by += vy
    if bx == 0 or bx == W-1:
        vx = -vx
    if by == 1 and abs(bx - p2) < 5:
        vy = -vy
    if by == H-2 and abs(bx - p1) < 5:
        vy = -vy
        score += 1
    if by < 0:
        return WIN
    if by >= H:
        return LOSE
    return CONT

def main():
    channel = 'X' # This can be 'X' or 'Y' channels
    min_position = -10 # Volts
    max_position = 10 # Volts
    rate = 100 # number of points written per second to DAQ
    density = 100 # number of points across the full scale range
    wait = 1 # Wait time before sweeping back in seconds

    x_V_array_f = numpy.linspace(min_position,max_position,density)
    x_V_array_b = numpy.linspace(max_position,min_position,density)
    fsm = qt.instruments['fsm']

    while 1:
        if (msvcrt.kbhit() and (msvcrt.getch() == 'q')): break
        print 'Sweeping %s forward...' % channel
        fsm.simple_sweep_V(x_V_array_f,rate,channel)
        time.sleep(wait)
        if (msvcrt.kbhit() and (msvcrt.getch() == 'q')): break
        print 'Sweeping %s backward...' % channel
        fsm.simple_sweep_V(x_V_array_b,rate,channel)
        time.sleep(wait)


    f_string = 'set_abs_position' + channel
    # Create function that corresponds to the abs_position set function of
    # the correct channel, then call it to reset the voltage to 0.
    reset_channel = getattr(fsm, f_string)
    reset_channel(0.0)
    return

def ingreso_rapido():
    print "Ingrese el numero de la carta: "
    cr = 0
    while True:
        if kbhit():
            n = getch()
            if (n.isdigit() == False) or (int(n) < 1) or (int(n) > 12):
                print "Numero ingresado incorrecto"
            else:
                n2 = int(n)
                if (cr == 0) and (n2 == 1):
                    tt = n2
                    cr = 1
                elif (cr == 1) and (n2 == 1):
                    n2 += tt
                    break
                else:
                    break
                n = str(n2)
    print "Ingrese el palo de la carta: "
    while True:
        if kbhit():
            palo = getch()
            if palo not in ['c', 'o', 'e', 'b']:
                print "Palo ingresado incorrecto"
            else:
                break
    return n+palo

def getKey():
    import msvcrt
    if msvcrt.kbhit():
        msvcrt.getch()
    while (1):
        if msvcrt.kbhit():
            msvcrt.getch()
            break

def recalibrate_lt2_lasers(names=['MatisseAOM', 'NewfocusAOM', 'GreenAOM', 'YellowAOM'], awg_names=['NewfocusAOM']):
    turn_off_all_lt2_lasers()
    for n in names:
        if (msvcrt.kbhit() and (msvcrt.getch() == 'q')): break
        recalibrate_laser(n, 'PMServo', 'adwin')
    for n in awg_names:
        if (msvcrt.kbhit() and (msvcrt.getch() == 'q')): break
        recalibrate_laser(n, 'PMServo', 'adwin',awg=True)

def recalibrate_lasers(names = ADWINAOMS, awg_names = AWGAOMS):    
    turn_off_all_lasers()
    for n in names:
        if (msvcrt.kbhit() and (msvcrt.getch() == 'q')): break
        stools.recalibrate_laser(n, PMSERVO, ADWIN)
    
    for n in awg_names:
        if (msvcrt.kbhit() and (msvcrt.getch() == 'q')): break
        stools.recalibrate_laser(n, PMSERVO, ADWIN, awg=True)

 def run(self):
     this_char = ''
     while this_char != self.exit_criteria:
         # print("waiting for", self.exit_criteria)
         msvcrt.kbhit() # waits for the keyboard hit
         this_char = msvcrt.getwch() # eats the character just hit
         if this_char == self.exit_criteria:
             self.trigger_all_events()
         else:
             print("waiting for '%s' : got '%s'" % (str(self.exit_criteria), this_char))

 def __call__(self):
   import msvcrt
   if msvcrt.kbhit():
     while msvcrt.kbhit():
       ch = msvcrt.getch()
     while ch in b'\x00\xe0':
       msvcrt.getch()
       ch = msvcrt.getch()
     return ord( ch.decode() )
   else:
     return -1

def ascii_challenge(stop):
    '''
    separate image_to_ascii function to have guessing game.
    image_folder: where the images are stored
    (All images need to have 3-letter formats a.k.a. .jpegs won't work)
    img: string from stop.attrs
    img_txt: possible text string that would've already been generated
    '''
    global rhymes
    global ats
    play_music(stop,True) #pauses music
    image_folder = os.listdir('images/')
    img = str(stop.attrs["im"]).strip(string.whitespace)
    img_txt = img[:-4]+'.txt'
    logging.debug("Image Text:",img_txt) #log image text for debugging
    play_music(stop)
    boss = str(stop.attrs["kw"]).strip(string.whitespace)
    if img_txt not in image_folder: #convert image to txt file if not already.
        print "Converting jpg to txt!"
        ascii_string = ASC.image_diff('images/'+img)
        fin = open('images/'+img_txt,'w')
        print "file opened"
        for i in range(len(ascii_string)):
            fin.write(ascii_string[i]+'\t')
        fin.close()
    with open('images/'+img_txt) as f:
        lines = f.read()
        print "Guess ascii by pressing enter!"
        for l in lines.split('\t'):
            while not msvcrt.kbhit():
                time.sleep(1.2)
                print l
                break

            while msvcrt.kbhit():
                play_music(stop,True)
                msvcrt.getch()
                print "_________________________________________________________________"
                print "What's your guess?"
                print boss
                boss_guess = raw_input(">>")
                if boss_guess[:2] == boss[:2]:
                    play_music(stop)
                    print "You guessed right! Here are 5 hashes and ats for your prowess!"
                    rhymes += 5
                    ats += 5
                    return rhymes, ats
                else:
                    print "You guessed wrong!"
                    play_music(stop)
    return rhymes,ats

def countdown(timeout):
    '''A countdown function, asking for a keypress.
    It returns whether a key was pressed during countdown or not.
    Works on both linux on windows. Timeout in seconds.'''
    sys.stdout.write("Press any key to abort... %02d" % (timeout))
    sys.stdout.flush()
    keypressed = False
    try:
        # Windows
        import msvcrt
        while not msvcrt.kbhit() or timeout == 0:
            time.sleep(1)
            timeout = timeout - 1
            sys.stdout.write("\b"*len("%02d"%(timeout+1)) + "%02d"%(timeout))
            sys.stdout.flush()
        if msvcrt.kbhit():
            keypressed = True
    except:
        # Linux
        try:
            import termios, select
            fd = sys.stdin.fileno()
            new_term = termios.tcgetattr(fd)
            old_term = termios.tcgetattr(fd)
            # new terminal setting unbuffered
            new_term[3] = (new_term[3] & ~termios.ICANON & ~termios.ECHO)
            # switch to unbuffered terminal
            termios.tcsetattr(fd, termios.TCSAFLUSH, new_term)

            dr, _, _ = select.select([sys.stdin], [], [], 0)
            while dr == [] and timeout > 0:
                time.sleep(1)
                timeout = timeout - 1
                sys.stdout.write("\b"*len("%02d"%(timeout+1)) + "%02d"%(timeout))
                sys.stdout.flush()
                dr, _, _ = select.select([sys.stdin], [], [], 0)

            if dr != []:
                keypressed = True
        finally:
            try:
                # switch to normal terminal
                termios.tcsetattr(fd, termios.TCSAFLUSH, old_term)
            except:
                sys.stdout.write("\nAttention: Terminal unacessable. If SGpp was built within Eclipse, everything is fine!\n")
                sys.stdout.flush()
                return keypressed

    sys.stdout.write("\n")
    sys.stdout.flush()
    return keypressed

def image_to_ascii(stop):
    '''
    separate image_to_ascii function to have guessing game.
    image_folder: where the images are stored
    img:
    img_txt: possible text string that would've already been generated
    '''
    global hashes
    global ats
    image_folder = os.listdir('images/')
    img= str(stop.attrs["im"]).strip(string.whitespace)
    img_txt = img[:-4]+'.txt'

    play_music(stop)
    boss_kw = str(stop.attrs["nomen"]).strip(string.whitespace)
    if img_txt in image_folder:
        with open('images/'+img_txt) as f:
            lines = f.read()
            print "Guess ascii by pressing enter!"

            for l in lines.split('\t'):

                while not msvcrt.kbhit():
                    time.sleep(1.5)
                    break
                print l

                while msvcrt.kbhit():
                    msvcrt.getch()
                    play_music(stop,False)
                    print "-----------------------------------------------"
                    print "What's your guess?"
                    boss_guess = raw_input(">>")

                    if boss_guess == boss_kw:
                        print "You guessed right! Here are 5 hashes and ats for your prowess!"
                        hashes += 5
                        ats += 5

                        break
    else:
        #try:
        ascii_string = ASC.image_diff('images/'+img)
        print type(ascii_string)
        fin = open('../images/'+img_txt,'w')
        print "file opened"
        for i in range(len(ascii_string)):
            fin.write(ascii_string[i]+'\t')
        fin.close()

 def flush_input(str):
     while msvcrt.kbhit():
         ch = msvcrt.getch()
         if ch == '\xff':
             print("msvcrt is broken, this is weird.")
             sys.exit(0)
     return input(str)

 def readInput():
     start_time = time.time()
     while True:
         if kbhit():
             return _getch()
         if (time.time() - start_time) > timeout:
             return None

    def _wait_for_interval(self):
        """Wait for the time interval to expire
        
        This method issues a timing loop to wait for the specified interval to
        expire or quit if the user presses 'q' or 'Q'. The method passes all
        other keyboard requests to the _do_command() method for processing.

        If the interval expires, the method returns None.
        If the user presses a key, the method returns the numeric key number.
        
        Returns - None or int (see above)        
        """
        # If on *nix systems, set the terminal IO sys to not echo
        if os.name == "posix":
            import tty, termios
            old_settings = termios.tcgetattr(sys.stdin)
            tty.setcbreak(sys.stdin.fileno())
            
        key = None
        done = False
        # loop for interval in seconds while detecting keypress 
        while not done:
            done = self.alarm <= time.time()
            if kbhit() and not done:
                key = getch()
                done = True

        # Reset terminal IO sys to older state
        if os.name == "posix":
            termios.tcsetattr(sys.stdin, termios.TCSADRAIN, old_settings)

        return key

def main():
    grid = [[0]*4 for i in range(4)]
    x, y = random.randrange(4), random.randrange(4)
    grid[y][x] = 2 if random.random() < .9 else 4
    while True:
        print('\n' * H)
        print(grid_fmt.format(*[i or '' for r in grid for i in r]))
        gridcp = [r[:] for r in grid]
        if not (move_up(gridcp) or move_down(gridcp) or
                move_left(gridcp) or move_right(gridcp)):
            print('Game over!')
            break
        moved = False
        k = msvcrt.getch()
        if msvcrt.kbhit():
            k += msvcrt.getch()
        if k == b'\xe0H':
            moved = move_up(grid)
        elif k == b'\xe0P':
            moved = move_down(grid)
        elif k == b'\xe0K':
            moved = move_left(grid)
        elif k == b'\xe0M':
            moved = move_right(grid)
        elif k in (b'\x1b', b'q'):
            break
        if moved:
            x, y = random.randrange(4), random.randrange(4)
            while grid[y][x]:
                x, y = random.randrange(4), random.randrange(4)
            grid[y][x] = 2 if random.random() < .9 else 4

def getch():
    """getch() for Windows and Linux.
       This won't work unless run from a terminal.
    """
    # this must be executed from a terminal
    if not is_executed_from_console():
        system_exit("libastyle.getch() must be run from the console")
    # WINDOWS uses msvcrt
    if os.name == "nt":
        # clear buffer
        while msvcrt.kbhit():
            msvcrt.getch()
        # read char
        ch_in = msvcrt.getch()
    # LINUX uses termios and tty
    else:
        # clear buffer
        sys.stdin.flush()
        # read char
        fd_in = sys.stdin.fileno()
        old_settings = termios.tcgetattr(fd_in)
        try:
            tty.setraw(sys.stdin.fileno())
            ch_in = sys.stdin.read(1)
            if ch_in == '\x1b':			# alt key (27)
                ch_in = sys.stdin.read(1)
        finally:
            termios.tcsetattr(fd_in, termios.TCSADRAIN, old_settings)
    # convert to unicode for Python 3
    return ch_in.decode('utf-8')