def water(value): val = helpers.translate(value, -100, 100, 0, 255) r = val b = 255-val g = 255-(val*(val/200)) if g<0:g=0 return r, g, b
def get_selection(self): value = self.adc.read_adc(self.pin, gain=self.gain) selection = int( round( helpers.translate(value, self.knob_hi, self.knob_lo, 1, self.selections))) return selection
def apply_replace(self, s): if not self.matchreplacecheck or not self.matchedit: return s if not self.regex: matchpat = fnmatch.translate(self.matchedit) replacepat = helpers.translate(self.replaceedit) else: matchpat = self.matchedit replacepat = self.replaceedit try: s = re.sub(matchpat, replacepat, s, flags=self.ignorecase) except: pass return s
def translate_struct(ref_lang, target_lang, ref_struct, target_struct, db, token, parent_key=None): for k, v in ref_struct.items(): kp = k.split("|") kr = kp[0] full_key = kr if parent_key is None else f'{parent_key}.{kr}' if isinstance(v, str): kh = hash(v) rh = db.get(target_lang, full_key) if rh == kh: continue # translation is still up-to-date print( f"Translating {full_key} from {ref_lang} to {target_lang}...") try: if target_lang == ref_lang: translation = deserialize_text(serialize_text(v)) else: translation = deserialize_text( translate(serialize_text(v), ref_lang, target_lang, token)) except: print("Cannot translate, skipping...") continue target_struct[k] = translation db.set(target_lang, full_key, kh) else: if not isinstance(target_struct.get(k), dict): target_struct[k] = {} translate_struct(ref_lang, target_lang, v, target_struct[k], db, token, parent_key=full_key) return target_struct
def image_generate(self): noise = [] loadingbar = loadingbars.LoadingBar(minval=0, maxval=self.image_size) print "Generating planet named '%s' from seed '%s'..." % (self.name, str(self.seed)) for y in xrange(1, self.image_size+1): loadingbar.set(y) for x in xrange(1, self.image_size+1): if helpers.dist_between(x, y, *[self.image_size/2]*2) < self.image_size/2: n = helpers.translate(helpers.noise2D(x, y, self.seed, sharp=self.sharp), -1, 1, 0, 1) if n > self.water/100.: r = int(n*self.land_color[0]) g = int(n*self.land_color[1]) b = int(n*self.land_color[2]) else: r = int(n*self.ocean_color[0]) g = int(n*self.ocean_color[1]) b = int(n*self.ocean_color[2]) noise.append((r, g, b)) else: noise.append((0, 0, 0, 0)) self.sharp_img.putdata(noise) self.blurred_img = self.sharp_img.filter(self.blur_filter)
def set_speed(self, speed): if speed > 0 + self.threshold: self.turn_on() self.stop = False self.pi.write(self.dir_pin, 1) elif speed < 0 - self.threshold: self.turn_on() self.stop = False self.pi.write(self.dir_pin, 0) speed = -1.0 * speed else: self.stop = True self.turn_off() speed_index = int( round( helpers.translate(speed, 0.0, 1.0, 0, len(self.speeds) - 1, self.translate_mode))) frequency = self.speed_params[self.speeds[speed_index]][0] step_res = self.speed_params[self.speeds[speed_index]][1] if not frequency == self.frequency: self.logger.debug("Frequency changed to %s" % str(frequency)) self.frequency = frequency self.pi.set_PWM_frequency(self.step_pin, frequency) self.change_step_res(step_res)
def get_value(self): value = self.adc.read_adc(self.pin, gain=self.gain) mapped_value = helpers.translate(value, self.knob_lo, self.knob_hi, self.sweep_range[0], self.sweep_range[1], self.translate_mode) if self.hard_limit: if self.sweep_range[1] - self.sweep_range[0] > 0: if mapped_value < self.sweep_range[0]: mapped_value = self.sweep_range[0] elif mapped_value > self.sweep_range[1]: mapped_value = self.sweep_range[1] else: if mapped_value > self.sweep_range[0]: mapped_value = self.sweep_range[0] elif mapped_value < self.sweep_range[1]: mapped_value = self.sweep_range[1] return mapped_value
def translate_struct(ref_lang, target_lang, translations, db, token): if not target_lang in translations: translations[target_lang] = {} for k, v in translations.get('$' + ref_lang, {}).items(): kp = k.split("|") kr = kp[0] kh = hash(v) rh = db.get(target_lang, kr) if rh == kh: continue #translation is still good print(f"Translating {kr} from {ref_lang} to {target_lang}...") try: if target_lang == ref_lang: translation = deserialize_text(serialize_text(v)) else: translation = deserialize_text( translate(serialize_text(v), ref_lang, target_lang, token)) except KeyboardInterrupt: raise except: continue translations[target_lang][kr] = translation db.set(target_lang, kr, kh) return translations
def main(): #initialize pigpio object pi = pigpio.pi() #initialize 4 channel 16-bit analog to digital converter adc = Adafruit_ADS1x15.ADS1115() display = interface.Display() # Create an instance of the logger frankies_log = interface.FrankiesLog().logger status = interface.Status(logger=frankies_log, display=display) ''' #add a handler to the logger to output to the display sh = interface.ScreenHandler() sh.setLevel(config.LOG_SHELL_VERBOSITY) sh.set_display(display) simple_formatter = logging.Formatter('%(message)s') sh.setFormatter(simple_formatter) frankies_log.addHandler(sh) ''' cleaner = helpers.Cleanup(frankies_log) cleaner.cleanup_list.append(display) # Output logger info frankies_log.info("Starting up the frankie_steen") stepper_sprocket_01 = physical_control.Stepper(pi=pi, logger=frankies_log, dir_pin=config.GPIO_STEPPER_0_DIR, on_pin=config.GPIO_STEPPER_0_ON, step_pin=config.GPIO_STEPPER_0_STEP, mode0_pin=config.GPIO_STEPPER_0_MODE0, mode1_pin=config.GPIO_STEPPER_0_MODE1, mode2_pin=config.GPIO_STEPPER_0_MODE2 ) cleaner.cleanup_list.append(stepper_sprocket_01) stepper_sprocket_02 = physical_control.Stepper(pi=pi, logger=frankies_log, dir_pin=config.GPIO_STEPPER_2_DIR, on_pin=config.GPIO_STEPPER_2_ON, step_pin=config.GPIO_STEPPER_2_STEP, mode0_pin=config.GPIO_STEPPER_2_MODE0, mode1_pin=config.GPIO_STEPPER_2_MODE1, mode2_pin=config.GPIO_STEPPER_2_MODE2 ) cleaner.cleanup_list.append(stepper_sprocket_02) motor_takeup = physical_control.Stepper( pi=pi, logger=frankies_log, dir_pin=config.GPIO_MOTOR_1_DIR, step_pin=config.GPIO_STEPPER_1_ON, ) cleaner.cleanup_list.append(motor_takeup) knob_spring = interface.Knob( pin=config.ADC_KNOB_1, adc=adc, mode=config.ADC_KNOB_SWEEP, sweep_range=[-1,1] ) cleaner.cleanup_list.append(knob_spring) knob_select = interface.Knob( pin=config.ADC_KNOB_0, adc=adc, mode=config.ADC_KNOB_SELECT, selections=2 ) cleaner.cleanup_list.append(knob_select) knob_motor = interface.Knob( pin=config.ADC_KNOB_2, adc=adc, mode=config.ADC_KNOB_SWEEP, knob_hi=24000, knob_lo=13000, sweep_range=[0.0,1.0], hard_limit=True ) cleaner.cleanup_list.append(knob_motor) blue_light = interface.Light( pi=pi, logger=frankies_log, light_pin=config.GPIO_STATUS_BLUE, ) btn_calibrate_cbs = [ { "function":btn_calibrate_cb0, "time":0.0, "args":[pi], "notify_function":btn_calibrate_n0, "notify_args":[status]}, { "function":btn_calibrate_cb1, "time":2.0, "args":[], "notify_function":btn_calibrate_n1, "notify_args":[status]} ] btn_calibrate = interface.Switch( name="Calibrate Button", logger=frankies_log, pi=pi, switch_pin=config.GPIO_BTN_CALIBRATE, callbacks=btn_calibrate_cbs, mode="BUTTON", PULL_UP_DOWN="UP") cleaner.cleanup_list.append(btn_calibrate) camera = physical_control.Camera(pi=pi) last_warning = "" advancing = False try: while True: motor_dutycycle = helpers.translate( knob_motor.get_value(), knob_motor.sweep_range[0], knob_motor.sweep_range[1], 0, 255, "LINEAR") #################THIS IS FOR YOU PAT!!!############################### motor_dutycycle = 100 - motor_dutycycle################################################MOTOR SPEED if motor_dutycycle < 0: motor_dutycycle = 0 motor_takeup.dc_motor(dutycycle=motor_dutycycle) #pi.write(config.GPIO_STEPPER_1_ON, 0) if knob_select.get_selection() == 1: if not stepper_sprocket_01.steps and not stepper_sprocket_02.steps and not advancing: #display.message(title="RUN MODE") step_index = int( helpers.translate( knob_spring.get_value(), knob_spring.sweep_range[0], knob_spring.sweep_range[1], 0, len(config.STEPPER_FLOATS), "LINEAR" ) ) stepper_sprocket_01.turn_on() stepper_sprocket_02.turn_on() stepper_sprocket_01.change_step_res(config.STEPPER_FLOATS[step_index]) stepper_sprocket_02.change_step_res(config.STEPPER_FLOATS[step_index]) stepper_sprocket_01.advance_frame() stepper_sprocket_02.advance_frame() advancing = True elif not stepper_sprocket_01.steps and not stepper_sprocket_02.steps and advancing: advancing = False motor_takeup.dc_motor(dutycycle=0) pi.write(config.GPIO_STEPPER_1_ON, 0) frame_count, lifetime_frame_count = helpers.increment_frame_count() camera.shutter() frankies_log.info("Captured Frame: %s. Lifetime Capture: %s Frames" % (str(frame_count), lifetime_frame_count)) display.message(text=["Captured Frame", str(frame_count), "Lifetime Capture", str(lifetime_frame_count), "Frames"]) time.sleep(.500) else: t1 = Thread(target=stepper_sprocket_01.one_step) t2 = Thread(target=stepper_sprocket_02.one_step) t1.start() t2.start() stepper_sprocket_01.steps -= 1 stepper_sprocket_02.steps -= 1 t1.join() t2.join() elif knob_select.get_selection() == 2: stepper_sprocket_01.set_speed(knob_spring.get_value()) stepper_sprocket_02.set_speed(knob_spring.get_value()) stepper_sprocket_01.motor() stepper_sprocket_02.motor() else: if last_warning != "Invalid Selection": last_warning = "Invalid Selection" frankies_log.warning("%s is an invalid selection" % str(knob_select.get_value())) btn_calibrate.check_button() #status.update_display() if not advancing: time.sleep(.02) #blue_light.set_light(mode="CONSTANT") except KeyboardInterrupt: cleaner.clean_all()
def get_fig_for_2(value): global CURRENT_WHO_2 global CURRENT_CAT_2 tmp = dfs[CURRENT_WHO_2][dfs[CURRENT_WHO_2][CURRENT_CAT_2] == value][[REMU_COL, DATE_COL]].sort_values(DATE_COL) tmp = tmp[tmp[DATE_COL] < pd.Timestamp('2019-07-01T12')] tmp = tmp[tmp[DATE_COL] > pd.Timestamp('2012-01-01T12')] return go.Figure( data=[go.Scatter(x=tmp[DATE_COL], y=tmp[REMU_COL])], layout= { 'title': 'Evolution du montant des rémunération pour %s > %s > %s'%(WHO_MSG[CURRENT_WHO_1], helpers.cols_to_codes[CURRENT_CAT_2], helpers.translate(CURRENT_CAT_2, value)) })
def get_value_option_2(value): global CURRENT_WHO_2 global CURRENT_CAT_2 CURRENT_CAT_2 = value options = [{'label':helpers.translate(CURRENT_CAT_2, u), 'value':u } for u in dfs[CURRENT_WHO_2][CURRENT_CAT_2].dropna().unique()] return options
children=[ dcc.Dropdown( id='who-dropdown_2', options= WHO_OPTIONS, value= WHO_OPTIONS[0]['value'], className='four columns' ), dcc.Dropdown( id='cat-dropdown_2', options= CAT_OPTIONS[0], value= CAT_OPTIONS[0][0]['value'], className='four columns' ), dcc.Dropdown( id='value-dropdown_2', options= [{'label':helpers.translate(CURRENT_CAT_2, u), 'value':u } for u in dfs[CURRENT_WHO_2][CURRENT_CAT_2].unique()], value= dfs[CURRENT_WHO_2][CURRENT_CAT_2].unique()[0], className='four columns' ), ], className='row flex-display' ), # SCATTER html.Div( children=[ dcc.Graph( id='cat-fig-output_2', ) ] ) ]),