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 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',
)
]
)
]),
