order_result_t trash_water_treatment(void){ ROME_LOG(&rome_paddock,INFO,"Trashing water in treatment area"); order_result_t or; set_speed(RS_FAST); _wait_meca_ready(); ROME_SENDWAIT_MECA_CMD(&rome_meca,ROME_ENUM_MECA_COMMAND_PREPARE_TRASH_TREATMENT); _wait_meca_ground_clear(); //store nb balls for scoring purpose uint8_t balls_loaded = robot_state.cylinder_nb_bad; //push away the cubes in front of treatment area //the angle is changed to avoid pushing cubes towards recyling area float angle = arfast(TEAM_SIDE_VALUE(ROBOT_SIDE_BACK, ROBOT_SIDE_BALLEATER), TABLE_SIDE_MAIN); or = goto_pathfinding_node(PATHFINDING_GRAPH_NODE_MIDDLE_BOT, angle); if (or != ORDER_SUCCESS) return or; //go in position to trash the bad water or = goto_xya(KX(-250),250+130, arfast(ROBOT_SIDE_TURBINE,TABLE_SIDE_DOWN)); if (or != ORDER_SUCCESS) return or; _wait_meca_ready(); ROME_SENDWAIT_MECA_CMD(&rome_meca,ROME_ENUM_MECA_COMMAND_TRASH_TREATMENT); _wait_meca_ground_clear(); update_score(10*balls_loaded); or = goto_xya(KX(-250), 400, arfast(ROBOT_SIDE_TURBINE, TABLE_SIDE_DOWN)); set_speed(RS_NORMAL); return or; }
/*void follow_wall() { set_speed(0); while (true) { take_picture(); bool seen_wall = false; for (int i = -100; i < 100; i++) { for (int j = -50; j <= 50; j++) { int pixel = get_pixel(IMAGE_SIZE_X / 2 + i, IMAGE_SIZE_Y / 2 + j, COLOR_WHITE); if (pixel >= WHITE_THRESHOLD) { seen_wall = true; goto found_wall; } }} found_wall: if (seen_wall) { set_speed(20);//20 turn(75);//-80 } else { set_speed(30);//30 turn(-75);//80 } } halt(); } */ void follow_wall(){ set_speed(50); turn(0); while(true){ frontVal = read_analog(FRONT_PIN); leftVal = read_analog(LEFT_PIN); rightVal = read_analog(RIGHT_PIN); while(leftVal < (rightVal+40) && leftVal > (rightVal-40)){ set_speed(50); } while(leftVal > (rightVal+40)){ set_speed(40); turn(10); Sleep(0, 500); } while(leftVal < (rightVal+40)){ set_speed(40); turn(-10); Sleep(0, 500); } if(frontVal > 550){ if(rightVal < 300){ turn(1 * SHARP_TURN); Sleep(0, TURN_WAIT); } if(leftVal < 300){ turn(-1 * SHARP_TURN); Sleep(0, TURN_WAIT); } } } }
void Material::move(Map *map) { if (!m_ref_done) { int dx; if (m_from_chest) { dx = get_attribute("chest_speed"); } else { dx = get_attribute("move_speed"); } if (get_reference() == Right) { set_speed(dx, -get_attribute("rise_speed")); } else { set_speed(-dx, -get_attribute("rise_speed")); } set_accelration(0, get_attribute("weight")); m_ref_done = true; } Body::move(map); if (get_moving()) { animate_move(); } else { m_frame = get_attribute("move_still"); } if (get_fall()) { m_reachable = true; } }
bool Player::set_hit(Object *object) { bool result = false; if (!m_invisible) { // TODO: Check if player hp is above zero instead result = Actor::set_hit(object); if (result) { set_lock_direction(true); // Move backwards and upwards if (m_dir == Right) { set_speed(-get_attribute("move_speed"), -get_attribute("jump_speed")); } else { set_speed(get_attribute("move_speed"), -get_attribute("jump_speed")); } // Make player invisible for a certain time set_invisible(true); } } return result; }
bool Monster::set_hit(Object *object) { bool result = false; if (!m_invinsible && m_hit == HitNone) { result = Actor::set_hit(object); if (result) { set_lock_direction(true); // Move backwards and upwards if (get_reference() == Right) { set_speed(-get_attribute("move_speed"), 0); } else { set_speed(get_attribute("move_speed"), 0); } // Reduce hp // TODO: Get attackers attack power m_curr_hp--; if (m_curr_hp <= 0) { set_perish(); } } } return result; }
bool Monster::set_hit(Object *object, Status *status) { bool result = false; if (!m_invinsible) { result = Actor::set_hit(object); if (result) { set_lock_direction(true); // Move backwards if (get_reference() == Right) { set_speed(-get_attribute("move_speed"), 0); } else { set_speed(get_attribute("move_speed"), 0); } // Reduce hp m_curr_hp -= status->get_ap(); if (m_curr_hp <= 0) { set_perish(); } } } return result; }
/* * i2c_set_bus_speed - Set the i2c speed * @speed: required i2c speed * * Set the i2c speed. */ void i2c_set_bus_speed(int speed) { if (speed >= I2C_MAX_SPEED) set_speed(IC_SPEED_MODE_MAX); else if (speed >= I2C_FAST_SPEED) set_speed(IC_SPEED_MODE_FAST); else set_speed(IC_SPEED_MODE_STANDARD); }
void TpFanDriver::ping_watchdog_and_depulse(const Level *level) { if (depulse_ > std::chrono::milliseconds(0)) { FanDriver::set_speed("level disengaged"); std::this_thread::sleep_for(depulse_); set_speed(level); } else if (last_watchdog_ping_ + watchdog_ + sleeptime >= std::chrono::system_clock::now()) set_speed(level); }
static int demo_play_click(int b, int d) { if (d) { if (b == SDL_BUTTON_WHEELUP) set_speed(+1); if (b == SDL_BUTTON_WHEELDOWN) set_speed(-1); } return 1; }
static void demo_play_stick(int id, int a, float v, int bump) { if (!bump) return; if (config_tst_d(CONFIG_JOYSTICK_AXIS_Y0, a)) { if (v < 0) set_speed(+1); if (v > 0) set_speed(-1); } }
/* * card_uart_setup - specail setup for card reader UART * @fd : card reader fd * @return : status */ int card_uart_setup(int fd) { #if 1 struct termios option; memset(&option, 0, sizeof(option)); option.c_cflag = B9600|CS8|CLOCAL|CREAD; option.c_iflag = IGNPAR; option.c_oflag = 0; option.c_lflag = 0; option.c_cc[VMIN] = 0; option.c_cc[VTIME] = 30; tcflush(fd, TCIFLUSH); if(tcsetattr(fd, TCSANOW, &option) < 0){ return FAIL; } #else int ret; set_speed(fd, 9600); ret = set_parity(fd, 8, 1, 'N'); if (ret < 0) return FAIL; #endif return SUCCESS; }
void EightDirections::update(float dt) { if (max_speed == 0) return; bool on = false; int dir = get_joystick_direction(1); if (dir == 8) dir = instance->direction; else { on = true; dir *= 4; instance->set_direction(dir, false); } double mul = instance->frame->timer_mul; double change; if (on) change = get_accelerator(acceleration); else change = -get_accelerator(deceleration); set_speed(int_max(0, int_min(speed + change * mul, max_speed))); if (speed == 0) return; double add_x, add_y; get_dir(instance->direction, add_x, add_y); double m = get_pixels(speed) * mul; move(add_x * m, add_y * m); last_move = m; }
int xmos_dev_open() { int fd_xmos = open_serial(SERIAL_DEV); if (fd_xmos == -1) { printf("Cannot open device\n"); return ROKID_XMOS_ERROR_DEVICE_OPEN_FAILED; } int ret; ret = set_speed(fd_xmos, 115200); if (ret == -1) { printf("Set speed failed : %d\n", ret); return ROKID_XMOS_ERROR_INIT_FAILED; } ret = set_parity(fd_xmos, 8, 1, 0); if (ret == -1) { printf("Set parity failed : %d\n", ret); return ROKID_XMOS_ERROR_INIT_FAILED; } back_led_fd = open("/dev/dm163", O_RDWR | O_NONBLOCK); if (back_led_fd < 0) { perror("open dm163 error"); } return fd_xmos; }
int main(void) { struct client *cl = (struct client *)malloc(sizeof(struct client)); cl->state = initial; cl->inbuf = 0; cl->fd = open("/dev/ttyUSB0", O_RDWR); if (cl->fd < 0) { fprintf(stderr, "Can't open the uart\n"); exit(1); } set_speed(cl->fd, 115200); if (set_parity(cl->fd, 8, 1, 'N') == FALSE) { fprintf(stderr, "Set Parity Error\n"); exit(0); } /* Infinite while loop -- server must be killed */ while (1) { processclient(cl); } printf("-------------------\n"); free(cl); close(cl->fd); return 1; }
static int brf_set_serial_params(struct bts_action_serial *serial_action, int fd, int *speed, struct termios *ti) { fprintf(stderr, "texas: changing baud rate to %u, flow control to %u\n", serial_action->baud, serial_action->flow_control ); tcflush(fd, TCIOFLUSH); if (serial_action->flow_control) ti->c_cflag |= CRTSCTS; else ti->c_cflag &= ~CRTSCTS; if (tcsetattr(fd, TCSANOW, ti) < 0) { perror("Can't set port settings"); return -1; } tcflush(fd, TCIOFLUSH); if (set_speed(fd, ti, serial_action->baud) < 0) { perror("Can't set baud rate"); return -1; } if (speed) *speed = serial_action->baud; return 0; }
int main(int argc, char **argv) { int fd; int nread; char *ptr = argv[2]; char *dev = argv[1]; //maybe "/dev/ttyS0"; if (argc < 3) { printf("pls usage %s /dev/ttyS[n] your_message.\n", argv[1]); exit(EXIT_FAILURE); } if ((fd = open(dev, O_RDWR)) == -1) { perror("open"); exit(EXIT_FAILURE); } set_speed(fd, 19200); if (set_Parity(fd, 8, 1, 'N') == FALSE) { printf("Set Parity Error\n"); exit(EXIT_FAILURE); } if (write(fd, ptr, strlen(ptr)) < 0) { perror("write"); exit(EXIT_FAILURE); } printf("pls check the tty data\n"); close(fd); exit(EXIT_SUCCESS); }
void dt_circle_note_on::set_beats(int beat_num){ seq->setup(beat_num); data.rev_speed = (float)360.0 / (float)seq->total_steps; change_rshape(ofRandom(-1000, 1000)); set_speed(data.speed); }
/** *@breif main() */ int main(int argc, char **argv) { int fd; int nread; char buff[512]; char *dev ="/dev/ttty0"; fd = OpenDev(dev); if (fd>0) set_speed(fd,19200); else { printf("Can't Open Serial Port!\n"); exit(0); } if (set_Parity(fd,8,1,'N')== FALSE) { printf("Set Parity Error\n"); exit(1); } while(1) { while((nread = read(fd,buff,512))>0) { printf("\nLen %d\n",nread); buff[nread+1]='\0'; printf("\n%s",buff); } } //close(fd); //exit(0); }
void create_planet() { Uint32 x, y; Uint32 i; char *image = NULL; /* Get random coordinates. */ x = ( rand() % screen_width() ); y = -( rand() % 1000) + 100; /* Get random image name. */ i = ( rand() % PLANET_IMAGE_NUM ) + 1; switch( i ) { case 1: image = get_data( MOON_1_IMAGE, DATA_IMAGES ); break; default: image = NULL; } /* Make the planet sprite. */ planet = new_sprite( x, y, 1, image, 0 ); set_speed( planet, PLANET_SPEED ); if( planet == NULL ) { fprintf( stderr, "Error creating new sprite: %s.\n", SDL_GetError() ); exit(-1); } }
void load_config(char * path) { int i; char *p; //__android_log_print(ANDROID_LOG_DEBUG, "org.rin", "path in load_config: %s",path); jfile fd = jfopen(env_game_thread, path, JF_MODE_READ, NULL, 0); if(!fd) { init_config(); return; } memset(&setting, 0, sizeof(setting)); jfread(env_game_thread, fd, &setting, sizeof(setting)); jfclose(env_game_thread, fd); tmpsetting = setting; memcpy(m_pal16[PAL_CUSTOM_LOCAL],setting.custom_palette, sizeof(short)*4*3); check_config(); set_gb_type(); set_speed(setting.speed); }
/** * @brief Calculates the direction and the speed of the movement * depending on the target. */ void TargetMovement::recompute_movement() { if (target_entity != NULL) { // the target may be a moving entity target_x = target_entity->get_x(); target_y = target_entity->get_y(); } if (get_x() != target_x || get_y() != target_y) { finished = false; double angle = Geometry::get_angle(get_x(), get_y(), target_x, target_y); int dx = target_x - get_x(); int dy = target_y - get_y(); sign_x = (dx >= 0) ? 1 : -1; sign_y = (dy >= 0) ? 1 : -1; if (std::fabs(angle - get_angle()) > 1E-6 || get_speed() < 1E-6) { set_speed(speed); set_angle(angle); set_max_distance((int) Geometry::get_distance( get_x(), get_y(), target_x, target_y)); } } }
int thread_fn(void *data) { short cpu_temp,gpu_temp,max_temp; set_current_state(TASK_INTERRUPTIBLE); while(!kthread_should_stop()) { SLEEP_MILLI_SEC(30000); cpu_temp = 0; gpu_temp = 0; cpu_temp = read_ec(0xA8); gpu_temp = read_ec(0xAF); max_temp = get_max(cpu_temp, gpu_temp); if (max_temp < 60) { fanSpeed = minFanSpeed; } if (max_temp > 60) { fanSpeed = minFanSpeed+20; } if (max_temp > 70) { fanSpeed = minFanSpeed+40; } if (max_temp > 80) { fanSpeed = maxFanSpeed; } set_speed(fanSpeed); printk(KERN_INFO "cpu temp: %d, gpu temp: %d, fan speed: %d", cpu_temp, gpu_temp, fanSpeed); schedule(); set_current_state(TASK_INTERRUPTIBLE); } set_current_state(TASK_RUNNING); return 0; }
/** *@breif main() */ int main(int argc, char *argv[]) { int fd; int nread; char buff[512]; char *dev ="/dev/ttyACM0"; char recchr[512]; int device, c; sleep(1); fd = OpenDev(dev); if (fd>0){ set_speed(fd,9600); } else{ printf("Can't Open Serial Port!\n"); exit(0); } if (set_Parity(fd,8,1,'N')== FALSE) { printf("Set Parity Error\n"); exit(1); } // while(1) // { scanf("%s",recchr) ; write(fd, "c", 1); write(fd, "\"\n", 2); printf("发完!\n"); // } close(fd); exit(0); }
void Character::move(float tdelta) { if (the_state == gsINPROGRESS) // Перемещаемся только во время игры Unit::move(tdelta); if (way.path.size() == 0) return; if ((speed.x > F_EPSILON && position.x >= way.neigpos.x) || (speed.x < -F_EPSILON && position.x <= way.neigpos.x) || (speed.y > F_EPSILON && position.y >= way.neigpos.y) || (speed.y < -F_EPSILON && position.y <= way.neigpos.y)) { // Этап завершен position = way.neigpos; if (way.stage >= way.path.size() - 1) { // Цель достигнута way.path.clear(); way.stage = 0; way.target = position; } else { // Следующий этап ++way.stage; way.neighbour += way.path[way.path.size() - way.stage - 1]; way.neigpos = way.neighbour; } set_speed(); } }
void init_wave(struct wave * const wave, enum waveform waveform, midi_value_t speed, midi_value_t amplitude, midi_value_t offset) { wave->settings.amplitude = amplitude; wave->settings.offset = offset; set_speed(wave, speed); set_waveform(wave, waveform); }
void BallMovement::init() { if (flags & MOVE_AT_START) set_speed(max_speed); else stop_speed = max_speed; }
void callback_set_speed(const std_msgs::Float64::ConstPtr& msg) { if(command_mode!=globe_epas::globe_epas_cmd::SPEED_CONTROL) { ROS_INFO("Ignoring Globe EPAS command due to incorrect command mode"); return; } set_speed(msg->data); }
static void release_engine( struct dce_i2c_hw *dce_i2c_hw) { bool safe_to_reset; /* Restore original HW engine speed */ set_speed(dce_i2c_hw, dce_i2c_hw->original_speed); /* Release I2C */ REG_UPDATE(DC_I2C_ARBITRATION, DC_I2C_SW_DONE_USING_I2C_REG, 1); /* Reset HW engine */ { uint32_t i2c_sw_status = 0; REG_GET(DC_I2C_SW_STATUS, DC_I2C_SW_STATUS, &i2c_sw_status); /* if used by SW, safe to reset */ safe_to_reset = (i2c_sw_status == 1); } if (safe_to_reset) REG_UPDATE_2(DC_I2C_CONTROL, DC_I2C_SOFT_RESET, 1, DC_I2C_SW_STATUS_RESET, 1); else REG_UPDATE(DC_I2C_CONTROL, DC_I2C_SW_STATUS_RESET, 1); /* HW I2c engine - clock gating feature */ if (!dce_i2c_hw->engine_keep_power_up_count) REG_UPDATE_N(SETUP, 1, FN(SETUP, DC_I2C_DDC1_ENABLE), 0); }
/** * @brief Constructor. * @param speed speed of the movement in pixels per seconds * @param max_distance if the object goes further than this distance, it will come back */ RandomMovement::RandomMovement(int speed, int max_distance): RectilinearMovement(true), max_distance(max_distance) { set_speed(speed); set_next_direction(); }
static int acpuclk_cortex_set_rate(int cpu, unsigned long rate, enum setrate_reason reason) { struct clkctl_acpu_speed *tgt_s, *strt_s; int rc = 0; if (reason == SETRATE_CPUFREQ) mutex_lock(&acpuclk_init_data->lock); strt_s = acpuclk_init_data->current_speed; /* Return early if rate didn't change */ if (rate == strt_s->khz) goto out; /* Find target frequency */ for (tgt_s = acpuclk_init_data->freq_tbl; tgt_s->khz != 0; tgt_s++) if (tgt_s->khz == rate) break; if (tgt_s->khz == 0) { rc = -EINVAL; goto out; } /* Increase VDD levels if needed */ if ((reason == SETRATE_CPUFREQ || reason == SETRATE_INIT) && (tgt_s->khz > strt_s->khz)) { rc = increase_vdd(tgt_s->vdd_cpu, tgt_s->vdd_mem); if (rc) goto out; } pr_debug("Switching from CPU rate %u KHz -> %u KHz\n", strt_s->khz, tgt_s->khz); /* Switch CPU speed. */ rc = set_speed(tgt_s); if (rc) goto out; acpuclk_init_data->current_speed = tgt_s; pr_debug("CPU speed change complete\n"); /* Nothing else to do for SWFI or power-collapse. */ if (reason == SETRATE_SWFI || reason == SETRATE_PC) goto out; /* Update bus bandwith request */ set_bus_bw(tgt_s->bw_level); /* Drop VDD levels if we can. */ if (tgt_s->khz < strt_s->khz) decrease_vdd(tgt_s->vdd_cpu, tgt_s->vdd_mem); out: if (reason == SETRATE_CPUFREQ) mutex_unlock(&acpuclk_init_data->lock); return rc; }