Interpolieren zwischen Elementen in einem Array von Schwimmern

Question

Ich bekomme eine Liste von 5 Floats, die ich als Werte verwenden möchte, um PWM an eine LED zu senden. Ich möchte glatt in einer variablen Anzahl von Millisekunden zwischen den Elementen im Array rampen.

Also, wenn dies ist mein Array ...

list = [1.222, 3.111, 0.456, 9.222, 22.333] 

Ich möchte 1,222-3,111 über 3000 Millisekunden sagen, Rampe, dann 3,111-0,456 über die gleiche Menge an Zeit, und wenn es um bekommt Das Ende der Liste Ich möchte, dass das fünfte Element der Liste auf das erste Element der Liste hochläuft und unbegrenzt weiterläuft.

Answer 1

Denken Sie über so etwas nach?

import time 
l = [1.222, 3.111, 0.456, 9.222, 22.333] 

def play_led(value): 
    #here should be the led- code 
    print value 

def calc_ramp(given_list, interval_count): 
    new_list = [] 
    len_list = len(given_list) 
    for i in range(len_list): 
     first = given_list[i] 
     second = given_list[(i+1) % len_list] 
     delta = (second - first)/interval_count 
     for j in range(interval_count): 
      new_list.append(first + j * delta) 
    return new_list 

def endless_play_led(ramp_list,count): 
    endless = count == 0 
    count = abs(count) 

    while endless or count!=0: 
     for i in range(len(ramp_list)): 
      play_led(ramp_list[i]) 
      #time.sleep(1) 
     if not endless: 
      count -= 1 
     print '##############',count 


endless_play_led(calc_ramp(l, 3),2) 
endless_play_led(calc_ramp(l, 3),-2) 
endless_play_led(calc_ramp(l, 3),0) 

Answer 2

eine andere Version, der Version von dsgdfg ähnlich (basierend auf seiner/ihrer Idee), aber ohne Verzögerung Timing:

import time 
list_of_ramp = [1.222, 3.111, 0.456, 9.222, 22.333] 

def play_LED(value): 
    s = '' 
    for i in range(int(value*4)): 
     s += '*'   
    print s, value 

def interpol(first, second, fract): 
    return first + (second - first)*fract 

def find_borders(list_of_values, total_time, time_per_step): 
    len_list = len(list_of_values) 
    total_steps = total_time // time_per_step 
    fract = (total_time - total_steps * time_per_step)/float(time_per_step) 
    index1 = int(total_steps % len_list) 
    return [list_of_values[index1], list_of_values[(index1 + 1) % len_list], fract] 

def start_program(list_of_values, time_per_step, relax_time): 
    total_start = time.time() 
    while True: 
     last_time = time.time() 
     while time.time() - last_time < relax_time: 
      pass 
     x = find_borders(list_of_values,time.time(),time_per_step) 
     play_LED(interpol(x[0],x[1],x[2])) 

start_program(list_of_ramp,time_per_step=5,relax_time=0.5)