void _inputSet(unsigned int channel, unsigned int value, In8TestState * refState)
{
unsigned int mask = 1 << channel;
digitalWrite(inputPins [channel], value);
_loop(refState);
if (value) refState->inputs |= mask;
else refState->inputs &= ~mask;
}
void Game::message(const Message &msg)
{
switch (msg.type) {
case QUIT:
_running = false;
break;
case START:
_loop();
break;
default:
_broadcast(msg);
break;
}
}
int main( int argc , char** argv )
{
ros::init( argc , argv , "enableMotor");
ros::NodeHandle nodeHandle;
ros::Publisher _publisher = nodeHandle.advertise<p2os_msgs::MotorState>( "cmd_motor_state" , 10 );
ros::Rate _loop( 10 );
p2os_msgs::MotorState enableFlag;
enableFlag.state = 1;
int count = 0;
while( ros::ok() && ( count < 10 ) )
{
_publisher.publish( enableFlag );
_loop.sleep();
++count;
}
return 0;
}
int main(int argc, char **argv)
{
struct protoent *pe;
int s;
usage(argc);
if (!(pe = getprotobyname("TCP")))
return (EXIT_FAILURE);
if ((s = _set_from_hostname(argv[1], argv[2], pe)) == -1)
{
perror("./client");
return (EXIT_FAILURE);
}
check_signal(s);
_handle_server(s);
if (user(s, NULL, NULL, NULL))
{
my_close(s);
return (EXIT_FAILURE);
}
(void)_loop(s);
my_close(s);
return (EXIT_SUCCESS);
}
void
_lw6dsp_thread_func (lw6sys_context_t * sys_context, _lw6dsp_data_t * data)
{
int frames_increment = 1; // mustn't be 0
int frames_counter = 0;
int64_t nb_ticks = 0;
int64_t last_display_ticks = 0;
int64_t last_rounds_ticks = 0;
int64_t ticks = 0;
int64_t delta_ticks = 0;
int64_t cpu_ticks = 0;
int rounds;
int delta_rounds = 0;
int last_display_rounds = 0;
int do_skip = 0;
int delay_skip = 1;
int delay_cpu = 0;
int delay_real = 0;
lw6sys_log (sys_context, LW6SYS_LOG_DEBUG, _x_ ("display thread"));
LW6SYS_MUTEX_LOCK (sys_context, data->render_mutex);
#ifdef LW6_MAC_OS_X
data->macosx_vthread_handler = _lw6dsp_macosx_thread_init (sys_context);
#endif // LW6_MAC_OS_X
if (!data->gfx_backend)
{
_init (sys_context, data);
}
LW6SYS_MUTEX_UNLOCK (sys_context, data->render_mutex);
if (data->gfx_backend)
{
lw6sys_log (sys_context, LW6SYS_LOG_DEBUG, _x_ ("display loop"));
while (data->run)
{
ticks = lw6sys_get_timestamp (sys_context);
LW6SYS_MUTEX_LOCK (sys_context, data->render_mutex);
if (data->param.misc.target_fps > 0)
{
frames_increment = LW6SYS_TICKS_PER_SEC / data->param.misc.target_fps;
delay_skip = LW6SYS_TICKS_PER_SEC / (2 * data->param.misc.target_fps);
}
else
{
lw6sys_log (sys_context, LW6SYS_LOG_WARNING, _x_ ("can't handle target_fps of %d"), data->param.misc.target_fps);
}
frames_increment = lw6sys_imax (frames_increment, 1);
delay_skip = lw6sys_imax (delay_skip, 1);
nb_ticks = ticks - data->start_ticks;
if (frames_counter < nb_ticks)
{
/*
* The following is more efficient than a plain +=
* it will avoid going too fast after a slowdown
*/
frames_counter = lw6sys_imax (frames_counter + frames_increment, nb_ticks - frames_increment);
data->nb_frames++;
delta_ticks = ticks - last_display_ticks;
if (delta_ticks < 0)
{
last_display_ticks = ticks;
data->slow_fps = 0;
}
if (delta_ticks > 0)
{
data->instant_fps = ((float) LW6SYS_TICKS_PER_SEC) / delta_ticks;
data->average_fps =
(WEIGHT_INSTANT_FPS * delta_ticks * data->instant_fps +
WEIGHT_AVERAGE_FPS * ((float) LW6SYS_TICKS_PER_SEC) *
data->average_fps) / (WEIGHT_INSTANT_FPS * delta_ticks + WEIGHT_AVERAGE_FPS * ((float) LW6SYS_TICKS_PER_SEC));
last_display_ticks = ticks;
data->slow_fps = data->average_fps < (data->param.misc.target_fps / 2);
}
if (data->param.game_state && data->param.game_struct)
{
delta_ticks = ticks - last_rounds_ticks;
if (delta_ticks < 0)
{
last_rounds_ticks = ticks;
data->slow_mps = 0;
}
if (delta_ticks > LW6SYS_TICKS_PER_SEC / MPS_REFRESH_PER_SEC)
{
rounds = data->rounds;
delta_rounds = rounds - last_display_rounds;
if (delta_rounds > 0)
{
data->mps = ((float) (delta_rounds * LW6SYS_TICKS_PER_SEC * data->param.game_struct->rules.moves_per_round)) / delta_ticks;
last_display_rounds = rounds;
data->slow_mps =
(data->rounds >
data->param.game_struct->rules.rounds_per_sec)
&& (data->mps < ((data->param.game_struct->rules.rounds_per_sec * data->param.game_struct->rules.moves_per_round) / 2));
}
last_rounds_ticks = ticks;
}
}
else
{
data->slow_mps = 0;
}
lw6sys_log (sys_context, LW6SYS_LOG_DEBUG, _x_ ("frame %d at ticks %" LW6SYS_PRINTF_LL "d"), data->nb_frames, (long long) ticks);
_loop (sys_context, data);
do_skip = 0;
}
else
{
/*
* It's important not to sleep now but only
* after the mutex has been released so we
* just set a flag for later usage.
*/
do_skip = 1;
}
cpu_ticks = lw6sys_get_timestamp (sys_context) - ticks;
delay_cpu = 0;
if (!do_skip)
{
data->last_frame_rendering_time = cpu_ticks;
if (data->param.misc.gfx_cpu_usage > 0.0f && data->param.misc.gfx_cpu_usage < 1.0f)
{
delay_cpu = ((float) cpu_ticks) * (1.0f - data->param.misc.gfx_cpu_usage);
}
}
LW6SYS_MUTEX_UNLOCK (sys_context, data->render_mutex);
if (!do_skip)
{
lw6sys_log (sys_context, LW6SYS_LOG_DEBUG, _x_ ("frame %d rendering took %d ms"), (int) data->nb_frames, (int) cpu_ticks);
}
if (do_skip || (delay_cpu > 0))
{
delay_real = lw6sys_imin (LW6SYS_TICKS_PER_SEC, lw6sys_imax (1, lw6sys_imax (do_skip ? delay_skip : 0, delay_cpu)));
lw6sys_log (sys_context, LW6SYS_LOG_DEBUG, _x_ ("sleeping %d ms (delay_skip=%d, delay_cpu=%d)"), delay_real, delay_skip, delay_cpu);
lw6sys_delay (sys_context, delay_real);
}
}
}
else
{
lw6sys_log (sys_context, LW6SYS_LOG_WARNING, _x_ ("display thread can't initialise graphics"));
}
}
