Example #1
0
    def InitUI(self):
        blockAutorun = Block(self, 'Autorun')
        self.bindAutorun = BindInput(blockAutorun,
                                     hotkey=config.get_param('autorun_hk'),
                                     isOneKey=True)
        self.checkAutorun = wx.CheckBox(blockAutorun)
        self.checkAutorun.SetValue(config.get_param('autorun_state'))
        blockAutorun.add(self.bindAutorun)
        blockAutorun.add(self.checkAutorun, label='Activated: ')

        blockDwarfglitch = Block(self, 'Dwarf glitch')
        self.bindDwarfglitch = BindInput(
            blockDwarfglitch, hotkey=config.get_param('dwarfglitch_hk'))
        self.checkDwarfglitch = wx.CheckBox(blockDwarfglitch)
        self.checkDwarfglitch.SetValue(config.get_param('dwarfglitch_state'))
        blockDwarfglitch.add(self.bindDwarfglitch)
        blockDwarfglitch.add(self.checkDwarfglitch, label='Activated: ')

        hbox2 = wx.BoxSizer(wx.HORIZONTAL)
        self.applyBtn = wx.Button(self, label='Apply')
        # # self.applyBtn.Enable(False)
        hbox2.Add(self.applyBtn)

        vbox = wx.BoxSizer(wx.VERTICAL)
        vbox.Add(blockAutorun, flag=wx.ALL | wx.EXPAND, border=5)
        vbox.Add(blockDwarfglitch, flag=wx.ALL | wx.EXPAND, border=5)
        vbox.Add(hbox2, flag=wx.ALIGN_CENTER | wx.TOP | wx.BOTTOM, border=10)
        self.SetSizer(vbox)

        self.applyBtn.Bind(wx.EVT_BUTTON, self.OnApply)
Example #2
0
 def on_config(self, e):
     self.autorunHK.disable()
     dlg = SettingsDialog(self.frame)
     dlg.ShowModal()
     self.autorunHK.hkAutorun = config.get_param('autorun_hk')
     self.autorunHK.hkDwarfglitch = config.get_param('dwarfglitch_hk')
     self.autorunHK.enable(config.get_param('autorun_state'),
                           config.get_param('dwarfglitch_state'))
Example #3
0
def inline_query(params,\
                 proxy_type=config.get_param('proxy_type'),\
                 proxy_url=config.get_param('proxy_url'),\
                 telegram_url=config.get_param('telegram_url'),\
                 bot_token=config.get_param('bot_token')):
    proxies = {proxy_type: proxy_url}
    telegram_method = telegram_url + bot_token + '/answerInlineQuery'
    return requests.get(telegram_method, params=params, proxies=proxies)
Example #4
0
def send_message(params,\
                 proxy_type=config.get_param('proxy_type'),\
                 proxy_url=config.get_param('proxy_url'),\
                 telegram_url=config.get_param('telegram_url'),\
                 bot_token=config.get_param('bot_token')):
    proxies = {proxy_type: proxy_url}
    telegram_method = telegram_url + bot_token + '/sendMessage'
    return requests.get(telegram_method, params=params, proxies=proxies)
Example #5
0
def update_message(params,\
                 proxy_type=config.get_param('proxy_type'),\
                 proxy_url=config.get_param('proxy_url'),\
                 telegram_url=config.get_param('telegram_url'),\
                 bot_token=config.get_param('bot_token')):
    proxies = {proxy_type: proxy_url}
    telegram_method = telegram_url + bot_token + '/editMessageReplyMarkup'
    return requests.get(telegram_method, params=params, proxies=proxies)
Example #6
0
def get_updates(params,\
                 proxy_type=config.get_param('proxy_type'),\
                 proxy_url=config.get_param('proxy_url'),\
                 telegram_url=config.get_param('telegram_url'),\
                 bot_token=config.get_param('bot_token')):
    proxies = {proxy_type: proxy_url}
    telegram_method = telegram_url + bot_token + '/getUpdates'
    print(telegram_method)
    return requests.get(telegram_method, params=params, proxies=proxies)
Example #7
0
def servo_180(state):

    servo_channel = config.get_param('servo_camera_channel')

    if state:
        gpio.set_servo_pulsewidth(servo_channel, servo_camera_front )
    else:
        gpio.set_servo_pulsewidth(servo_channel, servo_camera_back )

    master.after(500, lambda: gpio.set_servo_pulsewidth(config.get_param('servo_camera_channel'), 0))
Example #8
0
def start_vision():
    os.system('killall mplayer')
    time.sleep(1)    
    print "start caputre"
    os.system(capture_hd_image_cmd % config.get_param('ip'))
    print "finish capture"
    img_hd = cv2.imread("img.jpg")
    print "get picture"

    analyse_picture(config.get_param('matrix_calibration_camera'), config.get_param('coefficient_distortion'), img_hd) 
    pass
Example #9
0
    def __init__(self, frame):
        self.frame = frame
        self.autorunHK = autorun.AutoRunner(config.get_param('autorun_hk'),
                                            config.get_param('dwarfglitch_hk'))
        super().__init__()
        self.set_icon(TRAY_ICON)
        self.Bind(wx.adv.EVT_TASKBAR_LEFT_DOWN, self.on_config)

        self.onGo = True
        self.dayzState = None
        if self.onGo:
            wx.CallLater(1000, self.on_timer)
Example #10
0
 def on_timer(self):
     if not self.onGo:
         return
     newState = proccheck.process_exists(PROCESS_NAME)
     if self.dayzState != newState:
         if newState:
             self.autorunHK.enable(config.get_param('autorun_state'),
                                   config.get_param('dwarfglitch_state'))
             notify('Autorun is ready.')
         elif not self.dayzState is None:
             self.autorunHK.disable()
             notify('Autoran is stopped.')
     self.dayzState = newState
     wx.CallLater(1000, self.on_timer)
Example #11
0
def main():
    global arm, gpio, master, running, sm

    ip = config.get_param('control_ip')
    arm = rpyc.connect(ip, 18861).root
    gpio = pigpio.pi(ip)

    master = Tk()
    labels = init_ui(master)

    t = gpioloop()
    t.start()

    t1 = gamepadloop()
    t1.start()

    t2 = dynamixelInfoPinger(labels, arm)
    t2.start()

    sm = ArmStateManager(arm, keys, gpio)
    sm.start()

    mainloop()

    sm.running = False
    running = False

    t.join()
    t1.join()
    t2.join()
    sm.join()
Example #12
0
def main():
    global luminosity, gpio, w, running, master

    ip = config.get_param('ip')
    gpio = pigpio.pi(ip)

    master = Tk()
    master.title('Pupper control')
    master.geometry('500x500')

    Button(master, text="START VISION", command=start_vision).grid(row=2, column=0)

    master.bind("<KeyPress>", keydown)
    master.bind("<KeyRelease>", keyup)

    start_stream()

    t = gpioloop()
    t.start()

    t1 = gamepadloop()
    t1.start()

    mainloop()

    running = False

    t.join()
    t1.join()
Example #13
0
def start_stream():
    if not os.getenv('NO_CAMERA'):

        os.system(start_stream_cmd % config.get_param('ip'))

        time.sleep(1)

        os.system('''i3-msg '[class="MPlayer"] floating enable' ''')
Example #14
0
def keydown(e):
    global x, y, z, r, light_state, light_value, rotated_servo
    k = e.char

    keys[e.char] = 1

    if e.char == 'l':
        if(light_state == True):
            light_value = 50
            light_state = False
        else:
            light_value = 0
            light_state = True
    elif e.char == 'm' and light_value <= 100:
        light_value += 5
    elif e.char == 'n' and light_value > 5:
        light_value -= 5

    gpio.set_PWM_dutycycle(5, light_value)

    if e.char == 'p':
        global val_servo
        if(val_servo <= 2450):
            val_servo += 50
            gpio.set_servo_pulsewidth(config.get_param('servo_camera_channel'), val_servo)
            master.after(100, lambda: gpio.set_servo_pulsewidth(config.get_param('servo_camera_channel'), 0))

    if e.char == 'o':
        global val_servo
        if(val_servo >= 550):
            val_servo -= 50
            gpio.set_servo_pulsewidth(config.get_param('servo_camera_channel'), val_servo)
            master.after(100, lambda: gpio.set_servo_pulsewidth(config.get_param('servo_camera_channel'), 0))

    if e.char == 'k':

        if rotated_servo:
            gpio.set_servo_pulsewidth(config.get_param('servo_camera_channel'), servo_camera_front)
            val_servo = servo_camera_front
            #gpio.hardware_PWM(19, 50, 100000) # 800Hz 25% dutycycle
        else:
            gpio.set_servo_pulsewidth(config.get_param('servo_camera_channel'), servo_camera_back)
            val_servo = servo_camera_back
            #gpio.hardware_PWM(19, 50, 900000) # 800Hz 25% dutycycle

        rotated_servo = not rotated_servo

        master.after(500, lambda: gpio.set_servo_pulsewidth(config.get_param('servo_camera_channel'), 0))


    if e.char == 'j':
        gpio.set_servo_pulsewidth(config.get_param('servo_camera_channel'), 0)
Example #15
0
    def __init__(self):
        Thread.__init__(self)
        self.speed = 0
        self.state = 'stop'
        self.target_x = 0
        self.actual_x = 0

        self.acceleration_ratio = config.get_param('acceleration_ratio')

        self.motor_left_actual_speed = 0
        self.motor_left_target_speed = 0

        self.motor_right_actual_speed = 0
        self.motor_right_target_speed = 0

        self.states = {}
Example #16
0
    def check(self, directory, files):
        # {{{
        super(CheckerPath, self).check(directory, files)

        # Get the correct path from the configuration file
        pattern_str = get_param('patterns', 'path')

        pat = re.compile(pattern_str)

        LOG.debug("matching %s with %s",directory,pattern_str)
        mat = pat.match(directory)

        if mat:
            result = True
        else:
            LOG.warn("Path '%s' does not match pattern '%s'")
            result = False

        return result
Example #17
0
    def run(self):
        while running:

            if 'w' in keys and 'd' in keys:
                self.motor_left_target_speed = forward_mov_speed
                self.motor_right_target_speed = forward_mov_speed/2

            elif 'w' in keys and 'a' in keys:
                self.motor_left_target_speed = forward_mov_speed/2
                self.motor_right_target_speed = forward_mov_speed


            elif 's' in keys and 'd' in keys:
                self.motor_left_target_speed = -backwards_mov_speed
                self.motor_right_target_speed = -backwards_mov_speed/2

            elif 's' in keys and 'a' in keys:
                self.motor_left_target_speed = -backwards_mov_speed/2
                self.motor_right_target_speed = -backwards_mov_speed


            elif 'w' in keys or 'forward' in pad_keys:
                self.motor_left_target_speed = forward_mov_speed
                self.motor_right_target_speed = forward_mov_speed

            elif 'e' in keys:
                self.motor_right_target_speed = forward_mov_speed
                self.motor_left_target_speed = 0

            elif 'q' in keys:
                self.motor_left_target_speed = forward_mov_speed
                self.motor_right_target_speed = 0

            elif 's' in keys or 'backward' in pad_keys:
                self.motor_left_target_speed = -backwards_mov_speed
                self.motor_right_target_speed = -backwards_mov_speed

            elif 'd' in keys or 'right' in pad_keys:
                self.motor_left_target_speed = rotation_speed
                self.motor_right_target_speed = -rotation_speed

            elif 'a' in keys or 'left' in pad_keys:
                self.motor_left_target_speed = -rotation_speed
                self.motor_right_target_speed = rotation_speed

            elif 'z' in keys:
                self.motor_left_target_speed = -2*backwards_mov_speed
                self.motor_right_target_speed = -2*backwards_mov_speed

            elif 'f' in keys:
                self.motor_left_target_speed = boost_forward_speed
                self.motor_right_target_speed = boost_forward_speed
            else:
                self.motor_left_target_speed = 0
                self.motor_right_target_speed = 0

            dx_left = sign(int(self.motor_left_target_speed * 10) - int(self.motor_left_actual_speed * 10))
            dx_right = sign(int(self.motor_right_target_speed * 10) - int(self.motor_right_actual_speed * 10))

            self.motor_left_actual_speed += dx_left * self.acceleration_ratio
            self.motor_right_actual_speed += dx_right * self.acceleration_ratio

            # self.motor_left_actual_speed = self.motor_left_target_speed
            # self.motor_right_actual_speed = self.motor_right_target_speed

            self.motor_left_actual_speed =  int(self.motor_left_actual_speed * config.get_param('speed_motor_left')/100.0)
            self.motor_right_actual_speed = int(self.motor_right_actual_speed * config.get_param('speed_motor_right')/100.0)

            if self.motor_left_actual_speed < 0:
                write_pwm([config.get_param('motor_left_back_channel')], abs(self.motor_left_actual_speed))
                write_pwm([config.get_param('motor_left_for_channel')], 0)
            else:
                write_pwm([config.get_param('motor_left_for_channel')], self.motor_left_actual_speed)
                write_pwm([config.get_param('motor_left_back_channel')], 0)

            if self.motor_right_actual_speed < 0:
                write_pwm([config.get_param('motor_right_back_channel')], abs(self.motor_right_actual_speed))
                write_pwm([config.get_param('motor_right_for_channel')], 0)
            else:
                write_pwm([config.get_param('motor_right_for_channel')], self.motor_right_actual_speed)
                write_pwm([config.get_param('motor_right_back_channel')], 0)

            time.sleep(1/60.0)
import json
import config
import main_functions

chat_id = config.get_param('chat_id')
print(chat_id)
if chat_id == '0':
    exit(-1)

test_mess = 'Please respond the message'

# https://core.telegram.org/bots/api#deletemessage
# https://core.telegram.org/bots/api#forcereply
force_reply = {
    'force_reply': True,
}
message_params_force_reply = {
    'chat_id': chat_id,
    'text': test_mess,
    'reply_markup': json.dumps(force_reply)
}
answer = main_functions.send_message(message_params_force_reply)
print(answer.text)
Example #19
0
running = True
label_vars = {}
keys = {}
pad_keys = {}
states = {}
grip_state = True
rotated_servo = False
master = None
light_state = True
light_value = 0

JOYSTICK_IGNORE_THRESHOLD = 32000

# Robot Moving speed
forward_mov_speed = config.get_param('for_speed')
backwards_mov_speed = config.get_param('back_speed')
rotation_speed = config.get_param('rotation_speed')
boost_forward_speed = config.get_param('boost_speed')

servo_camera_front = config.get_param('servo_camera_front')
servo_camera_back = config.get_param('servo_camera_back')


luminosity_step = 255/5
luminosity = luminosity_step

start_stream_cmd = "mplayer -fps 200 -demuxer h264es ffmpeg://tcp://%s:9999 > /dev/null &"
capture_hd_image_cmd = "nc %s 9000 > img.jpg"

Example #20
0
def main(instance):

    print 'waiting for connection to ' + instance + '...'
    wait_for_host(get_param('ip'))

    ui.main()
import json
import config
import main_functions

chat_id = config.get_param('chat_id')
print(chat_id)
if chat_id == '0':
    exit(-1)

test_mess = config.get_param('sample_text')

# ******************************************************
key1 = {'text': 'key1', 'callback_data': 'key1'}
key2 = {'text': 'key2', 'callback_data': 'key2'}
key3 = {'text': 'key3', 'callback_data': 'key3'}
key4 = {'text': 'key4', 'callback_data': 'key4'}
key_switch = {
    'text': 'switch_key',
    'switch_inline_query_current_chat': 'some query'
}
key_row1 = [key1, key2]
key_row2 = [key3, key4]
key_row3 = [
    key_switch,
]
inline_keyboard_markup = {'inline_keyboard': [key_row1, key_row2, key_row3]}
inline_keyboard_markup2 = {'inline_keyboard': [key_row2, key_row1]}
# https://core.telegram.org/bots/api#inlinekeyboardmarkup
# ******************************************************

print(json.dumps(inline_keyboard_markup))