示例#1
0
/**
 * @brief Sets the speed of the movement.
 * @param speed the speed in pixels per second (0 means auto, based on the length of the jump)
 */
void JumpMovement::set_speed(int speed) {

  if (speed == 0) {
    set_delay(std::max(4, 14 - length / 10));
  }
  else {
    set_delay(1000 / speed);
  }
  restart();
}
示例#2
0
/**
 * \brief Sets the speed of the movement.
 * \param speed the speed in pixels per second (0 means auto, based on the length of the jump)
 */
void JumpMovement::set_speed(int speed) {

  if (speed == 0) {
    set_delay(std::max(4, 14 - distance / 10));
  }
  else {
    set_delay(1000 / speed);
  }
  this->speed = speed;
  restart();
}
static int set_euler_delay(struct yas_state *st, int delay)
{
	if (atomic_read(&st->mag_enable) && atomic_read(&st->euler_enable)) {
		if (set_delay(st, MIN(st->mag_delay, delay)) < 0)
			return -EINVAL;
	} else if (atomic_read(&st->euler_enable)) {
		if (set_delay(st, delay) < 0)
			return -EINVAL;
	}
	st->euler_delay = delay;
	return 0;
}
示例#4
0
static int logo_filter_video(TCModuleInstance *self,
                             TCFrameVideo *frame)
{
    LogoPrivateData *pd = NULL;
    WorkItem W = { NULL, 0, 0.0 };

    TC_MODULE_SELF_CHECK(self,  "filter");
    TC_MODULE_SELF_CHECK(frame, "filter");

    pd = self->userdata;

    if (frame->id < pd->start || frame->id > pd->end) {
        /* out of the interval, so skip processing */
        return TC_OK;
    }

    set_fade(&W, frame->id, pd);
    set_delay(pd);

    W.pixels = GetImagePixels(pd->images, 0, 0,
                              pd->images->columns,
                              pd->images->rows);

    return pd->render(pd, &W, frame);
}
示例#5
0
void  adjust_trg_delay(int old_sweep, int new_sweep)
{
    /* variables */
      /* none */



    /* multiply by 10 times the ratio of sweep rates */
    delay *= (10 * sweep_rates[new_sweep].sample_rate) / sweep_rates[old_sweep].sample_rate;
    /* now divide the factor of 10 back out */
    delay /= 10;

    /* make sure delay is not out of range */
    if (delay > MAX_DELAY)
        /* delay is too large - set to maximum */
        delay = MAX_DELAY;
    if (delay < MIN_DELAY)
        /* delay is too small - set to minimum */
	delay = MIN_DELAY;


    /* tell the hardware the new trigger delay */
    set_delay(delay);


    /* all done adjusting the trigger delay - return */
    return;

}
		TITANIUM_PROPERTY_SETTER(Animation, delay)
		{
			TITANIUM_ASSERT(argument.IsNumber());
			const auto delay = std::chrono::milliseconds(static_cast<std::chrono::milliseconds::rep>(static_cast<std::uint32_t>(argument)));
			set_delay(delay);
			return true;
		}
示例#7
0
tower::tower(const tower_attributes &attributes,double posx,double posy,const ALLEGRO_TIMER *timer) {
    this->attributes=&attributes;
    this->position=make_pair(posx,posy);
    this->timer=timer;
    set_delay();
    reset_counter();
    active=true;
}
示例#8
0
DSN_API void dsn_task_call(dsn_task_t task, int delay_milliseconds)
{
    auto t = ((::dsn::task*)(task));
    dassert(t->spec().type == TASK_TYPE_COMPUTE, "must be common or timer task");

    t->set_delay(delay_milliseconds);
    t->enqueue();
}
int PressSensor::update_delay(int sensor_type)
{
    if (mEnabled[sensor_type]) {
        return set_delay(mDelay[sensor_type]);
    }
    else
	    return 0;
}
示例#10
0
文件: task.cpp 项目: SunnyGyb/rDSN
timer_task::timer_task(task_code code,  uint32_t interval_milliseconds, int hash) 
    : task(code, hash), _interval_milliseconds(interval_milliseconds) 
{
    dassert (TASK_TYPE_COMPUTE == spec().type, "this must be a computation type task, please use DEFINE_TASK_CODE to define the task code");

    // enable timer randomization to avoid lots of timers execution simultaneously
    set_delay(::dsn::service::env::random32(0, interval_milliseconds));
}
示例#11
0
文件: i2c.cpp 项目: hendrixjl/rPi
void i2c::init()
{
    bar_[CNTRL_REG] = 0;
    set_clk_divider();
    set_delay();
    set_clkt();
    bar_[SLAVE_ADDR_REG] = 0;
    bar_[DLEN_REG] = 0;
}
示例#12
0
scpi_result_t scpi_source_VoltageProtectionDelay(scpi_t * context) {
    Channel *channel = set_channel_from_command_number(context);
    if (!channel) {
        return SCPI_RES_ERR;
    }

    return set_delay(context, channel->prot_conf.u_delay,
        channel->OVP_MIN_DELAY, channel->OVP_MAX_DELAY, channel->OVP_DEFAULT_DELAY);
}
示例#13
0
文件: echo_mod.cpp 项目: bdapi/bdapi
// set echos
void echo::set_echos( f32 echos )
{
	if( echos < 1.f )
	{
		echos = 1.f;
	}

	set_delay( 1.f / echos );
}
示例#14
0
文件: task.cpp 项目: shengofsun/rDSN
void timer_task::enqueue()
{
    // enable timer randomization to avoid lots of timers execution simultaneously
    if (delay_milliseconds() == 0 && spec().randomize_timer_delay_if_zero) {
        set_delay(rand::next_u32(0, _interval_milliseconds));
    }

    return task::enqueue();
}
示例#15
0
void
AudioProcessor::set_state(const AudioProcessorState *state)
{
  if (!state) return;

  // Channel order
  set_input_order(state->input_order);
  set_output_order(state->output_order);
  // Master gain
  set_master(state->master);
  // AGC
  set_auto_gain(state->auto_gain);
  set_normalize(state->normalize);
  set_attack(state->attack);
  set_release(state->release);
  // DRC
  set_drc(state->drc);
  set_drc_power(state->drc_power);
  // Matrix
  // (!) Auto matrix option must be set before setting the matrix
  // because when auto matrix is on, mixer rejects the new matrix.
  set_auto_matrix(state->auto_matrix);
  set_matrix(state->matrix);
  // Automatrix options
  set_normalize_matrix(state->normalize_matrix);
  set_voice_control(state->voice_control);
  set_expand_stereo(state->expand_stereo);
  // Automatrix levels
  set_clev(state->clev);
  set_slev(state->slev);
  set_lfelev(state->lfelev);
  // Input/output gains
  set_input_gains(state->input_gains);
  set_output_gains(state->output_gains);
  // SRC
  set_src_quality(state->src_quality);
  set_src_att(state->src_att);
  // Eqalizer
  set_eq(state->eq);
  if (state->eq_master_bands)
    set_eq_bands(CH_NONE, state->eq_master_bands, state->eq_master_nbands);
  for (int ch = 0; ch < CH_NAMES; ch++)
    if (state->eq_bands[ch])
      set_eq_bands(ch, state->eq_bands[ch], state->eq_nbands[ch]);
  // Bass redirection
  set_bass_redir(state->bass_redir);
  set_bass_freq(state->bass_freq);
  set_bass_channels(state->bass_channels);
  // Delays
  set_delay(state->delay);
  set_delay_units(state->delay_units);
  set_delays(state->delays);
  // Dithering
  set_dithering(state->dithering);
}
示例#16
0
文件: task.cpp 项目: zjc95/rDSN
timer_task::timer_task(dsn_task_code_t code, dsn_task_handler_t cb, void* param, uint32_t interval_milliseconds, int hash, service_node* node)
    : task(code, hash, node), 
    _interval_milliseconds(interval_milliseconds),
    _cb(cb),
    _param(param)
{
    dassert (TASK_TYPE_COMPUTE == spec().type, "this must be a computation type task, please use DEFINE_TASK_CODE to define the task code");

    // enable timer randomization to avoid lots of timers execution simultaneously
    set_delay(dsn_random32(0, interval_milliseconds));
}
示例#17
0
文件: task.cpp 项目: goksyli/rDSN
void timer_task::exec()
{
    _cb(_context);

    if (_interval_milliseconds > 0)
    {
        //_state must be TASK_STATE_RUNNING here
        dbg_dassert(_state.load(std::memory_order_relaxed) == TASK_STATE_RUNNING, "corrupted timer task state");
        _state.store(TASK_STATE_READY, std::memory_order_release);
        set_delay(_interval_milliseconds);
    }
}
示例#18
0
/* Initialize some basic config settings */
void init_default_settings(void)
{
	set_log_file(stdout);
	set_max_pin_attempts(P1_SIZE + P2_SIZE);
        set_delay(DEFAULT_DELAY);
        set_lock_delay(DEFAULT_LOCK_DELAY);
        set_debug(INFO);
        set_auto_channel_select(1);
        set_timeout_is_nack(1);
	set_oo_send_nack(1);
        set_wifi_band(BG_BAND);
}
示例#19
0
文件: task.cpp 项目: shengofsun/rDSN
void timer_task::exec()
{
    if (dsn_likely(_cb != nullptr)) {
        _cb();
    }
    // valid interval, we reset task state to READY
    if (dsn_likely(_interval_milliseconds > 0)) {
        dassert(set_retry(true),
                "timer task set retry failed, with state = %s",
                enum_to_string(state()));
        set_delay(_interval_milliseconds);
    }
}
示例#20
0
void do_quaff( char_data* ch, char* argument )
{
  obj_data*    obj;
  int        level;
  int     duration;
  int        spell;

  if( *argument == '\0' ) {
    send( ch, "Quaff what?\r\n" );
    return;
    }

  if( ( obj = one_object( ch, argument, "quaff", &ch->contents ) ) == NULL )
    return;

  if( obj->pIndexData->item_type != ITEM_POTION ) {
    send( ch, "You can quaff only potions.\r\n" );
    return;
    }

  if( ( spell = obj->pIndexData->value[0] ) < 0
    || spell >= MAX_SPELL ) {
    send( ch, "That potion contains a non-existent spell.\r\n" );
    bug( "Quaff: Spell out of Range." );
    bug( "-- Potion = %s.", obj->Seen_Name( NULL ) );
    return;
    }

  send( ch, "You quaff %s.\r\n", obj );
  send_seen( ch, "%s quaffs %s.\r\n", ch, obj );

  if( ( level = obj->value[1] ) < 1 || level > 25 ) {
    bug( "Quaff: Level out of range." );
    bug( "-- Potion = %s", obj->Seen_Name( NULL ) );
    level = 1;
    }

  if( ( duration = obj->value[2] ) < 1 ) {
    bug( "Quaff: Duration out of range." );
    bug( "-- Potion = %s", obj->Seen_Name( NULL ) );
    duration = 1;
    }  

  set_delay( ch, 10 );
  obj->Extract( 1 );

  ( *spell_table[ spell ].function )( NULL, ch, NULL,
    level, duration );

  return;
}
void PulsingColorAnimation::loadFromJSON(const QJsonObject & obj) {
    if (obj.contains("fromStart")) set_fromStart(obj["fromStart"].toDouble());
    if (obj.contains("duration")) set_duration(obj["duration"].toDouble());
    if (obj.contains("lowerColor") and obj.contains("upperColor")) {
        QColor lowerColor = QColor(obj["lowerColor"].toString());
        QColor upperColor = QColor(obj["upperColor"].toString());
        set_meanColor(QColor((upperColor.red() + lowerColor.red()) / 2, (upperColor.green() + lowerColor.green()) / 2, (upperColor.blue() + lowerColor.blue()) / 2));
        set_varColor(QColor((upperColor.red() - lowerColor.red()) / 2, (upperColor.green() - lowerColor.green()) / 2, (upperColor.blue() - lowerColor.blue()) / 2));
    }
    if (obj.contains("frequency")) set_pulsation(obj["frequency"].toDouble() * 2 * M_PI);
    if (obj.contains("delay")) set_delay(obj["delay"].toDouble());
    if (obj.contains("pulseSignal")) set_pulseSignal(obj["pulseSignal"].toString());
    if (obj.contains("priority")) set_priority(obj["priority"].toInt());
}
示例#22
0
文件: task.cpp 项目: zjc95/rDSN
void timer_task::exec()
{
    task_state RUNNING_STATE = TASK_STATE_RUNNING;
    
    _cb(_param);

    if (_interval_milliseconds > 0)
    {
        if (_state.compare_exchange_strong(RUNNING_STATE, TASK_STATE_READY))
        {
            set_delay(_interval_milliseconds);            
        }        
    }
}
示例#23
0
/**
 * @brief Creates a fade-in or fade-out transition effect.
 * @param direction direction of the transition effect (in or out)
 */
TransitionFade::TransitionFade(Transition::Direction direction):
  Transition(direction), alpha(-1) {

  if (direction == OUT) {
    alpha_start = 256;
    alpha_limit = 0;
    alpha_increment = -8;
  }
  else {
    alpha_start = 0;
    alpha_limit = 256;
    alpha_increment = 8;
  }  

  set_delay(20);
}
示例#24
0
 //functions
 FullConnection(Layer* f, Layer* t, const vector<int>& d = empty_list_of<int>(), FullConnection* s = 0):
     Connection(make_name(f, t, d), f, t),
     source(s),
     paramRange(source ? source->paramRange : WeightContainer::instance().new_parameters(this->from->output_size() * this->to->input_size(), this->from->name, this->to->name, name))    {
     if (source)
     {
         WeightContainer::instance().link_layers(this->from->name, this->to->name, this->name, 
                                                 paramRange.first, paramRange.second);
     }
     set_delay(d);
     assert(num_weights() == (this->from->output_size() * this->to->input_size()));
     if (this->from->name != "bias" && this->from != this->to && !this->to->source)
     {
         this->to->source = this->from;
     }
 }
示例#25
0
void SpikingGroup::init(NeuronID n, double loadmultiplier, NeuronID total )
{
	group_name = "SpikingGroup";
	unique_id  = unique_id_count++;
	size = n;
	effective_load_multiplier = loadmultiplier;

	if ( total > 0 ) {
		anticipated_total = total;
		stringstream oss;
		oss << get_name() << ":: Anticipating " << anticipated_total << " units in total." ;
		logger->msg(oss.str(),NOTIFICATION);
	}

	// setting up default values
	evolve_locally_bool = true;
	locked_rank = 0;
	locked_range = communicator->size();
	rank_size = calculate_rank_size(); // set the rank size

	double fraction = (double)calculate_rank_size(0)*effective_load_multiplier/DEFAULT_MINDISTRIBUTEDSIZE;

	if ( anticipated_total > 0 )
		fraction = (1.*size*effective_load_multiplier)/anticipated_total;

	if ( fraction >= 0 && fraction < 1. ) { 
		lock_range( fraction );
	} else { // ROUNDROBIN which is default
		locked_rank = 0;
		locked_range = communicator->size();

		stringstream oss;
		oss << get_name() << ":: Size " << get_rank_size() << " (ROUNDROBIN)";
		logger->msg(oss.str(),NOTIFICATION);
	}

	stringstream oss;
	oss << get_name() << ":: Registering delay (MINDELAY=" << MINDELAY << ")";
	logger->msg(oss.str(),DEBUG);

	delay = new SpikeDelay( );
	set_delay(MINDELAY+1); 

	evolve_locally_bool = evolve_locally_bool && ( get_rank_size() > 0 );
}
示例#26
0
void  set_trg_delay(long int d)
{
    /* variables */
      /* none */



    /* set the trigger delay */
    delay = d;

    /* set the trigger delay in hardware too */
    set_delay(delay);


    /* all done initializing the trigger delay - return */
    return;

}
示例#27
0
bool update(const char * field, std::vector<uint8_t> data) {
    if (!strcmp(field, "dlpkt")) {
        return delete_packet(data);
    } else if (!strcmp(field, "dlcha")) {
        return delete_channel(data);
    } else if (!strcmp(field, "pnum")) {
        return set_pnumber(data);
    } else if (!strcmp(field, "chan")) {
        return set_channel(data);
    } else if (!strcmp(field, "pol")) {
        set_poll(data);
    } else if (!strcmp(field, "dir")) {
        const char * dirStr = byteVec2cstr(data);
        if (!strcmp(dirStr, "pos"))
            set_direction(DIR_POS);
        else if (!strcmp(dirStr, "neg"))
            set_direction(DIR_NEG);
        else return false;
    } else if (!strcmp(field, "data")) {
        return set_current(data);
    } else if (!strcmp(field, "wait")) {
        set_delay(data);
    } else if (!strcmp(field, "send")) {
        flag_return = true;
        send_packets();
    } else if (!strcmp(field, "reset")) {
        send_global_reset();
    } else if (!strcmp(field, "glob")) {
        set_global();
    } else if (!strcmp(field, "conn")) {
        flag_return = true;
        return connect_serial();
    } else if (!strcmp(field, "exit")) {
        return exit();
    } else if (!strcmp(field, "clrpks")) {
        clear_packets();
    } else if (!strcmp(field, "prev")) {
        if (debug_) preview_packets();
        preview_packet_bytes();
        flag_return = true;
    } else { return false; }
    return true;
}
示例#28
0
void  trg_delay_up()
{
    /* variables */
      /* none */



    /* increase the trigger delay, if not already the maximum */
    if (delay < MAX_DELAY)
        delay++;

    /* tell the hardware the new trigger delay */
    set_delay(delay);


    /* all done raising the trigger delay - return */
    return;

}
示例#29
0
void  trg_delay_down()
{
    /* variables */
      /* none */



    /* decrease the trigger delay, if not already the minimum */
    if (delay > MIN_DELAY)
        delay--;

    /* set the trigger delay for the hardware */
    set_delay(delay);


    /* all done with lowering the trigger delay - return */
    return;

}
示例#30
0
/**
 * \brief Creates a fade-in or fade-out transition effect.
 * \param direction direction of the transition effect (in or out)
 */
TransitionFade::TransitionFade(Transition::Direction direction):
  Transition(direction),
  finished(false),
  alpha(-1),
  dst_surface(NULL) {

  if (direction == OUT) {
    alpha_start = 256;
    alpha_limit = 0;
    alpha_increment = -8;
  }
  else {
    alpha_start = 0;
    alpha_limit = 256;
    alpha_increment = 8;
  }

  set_delay(20);
}