예제 #1
0
static void *
sparky_main(void *unused)
{
    track_t *track;
    stop_t *stop;
    int last_state = 0;

    set_lights(false, false);

    if ((track = track_new("tesla.wav")) == NULL) {
	perror("tesla.wav");
	exit(1);
    }
    if (track) track_set_volume(track, 100);

    stop = stop_new();

    while (1) {
	stop_reset(stop);
	if (track) track_play_asynchronously(track, stop);
	while (! stop_is_stopped(stop)) {
	    int ms = random_number_in_range(25, 100);
	    int state;

	    while ((state = random_number_in_range(0, 3)) == last_state) {}
	    last_state = state;

	    set_lights(state & 1, state & 2);
	    ms_sleep(ms);
	}
    }

    return NULL;
}
예제 #2
0
파일: coffin.c 프로젝트: crpalmer/halloween
int
main(int argc, char **argv)
{
    stop_t *stop;
    track_t *track;
    fogger_args_t fogger_args = {
	.default_duty = 0.01,
	.delta_duty = 0.001,
    };

    seed_random();

    if (wb_init() < 0) {
	perror("wb_init");
	exit(1);
    }

    if ((track = track_new("coffin-dog.wav")) == NULL) {
	perror("coffin-dog.wav");
	exit(1);
    }

    //track_set_volume(track, 50);

    stop = stop_new();

    fogger_run_in_background(FOGGER_PIN, &fogger_args);

    wb_set(LIGHT_PIN, 1);
    wb_set(LID_PIN, 0);

    while (true) {
	bool is_lit = true;

	stop_reset(stop);

	track_play_asynchronously(track, stop);

	ms_sleep(ACTION_START);

	while (! stop_is_stopped(stop)) {
	    int open_time = random_number_in_range(LID_OPEN_LOW, LID_OPEN_HIGH);
	    int closed_time = random_number_in_range(LID_CLOSED_LOW, LID_CLOSED_HIGH);

printf("\t\tlid %d %d\n", open_time, closed_time); fflush(stdout);
	    wb_set(LID_PIN, 1);
	    blink_lights_for(&is_lit, open_time);
	    wb_set(LID_PIN, 0);
	    blink_lights_for(&is_lit, closed_time);
	}
	
	wb_set(LIGHT_PIN, 1);
	wb_set(LID_PIN, 0);

	ms_sleep(random_number_in_range(INTERDELAY_LOW, INTERDELAY_HIGH));
    }

    return 0;
}
예제 #3
0
static void
blink_main(void)
{
    unsigned mask = 31 | (31 << 8);	/* bits 1-5 of both banks*/

    while (1) {
	ms_sleep(random_number_in_range(200, 500));
	wb_set_outputs(mask, random_number_in_range(0, mask));
    }
}
예제 #4
0
void add_grain_on_random_square (int radius, int seed)
{
  TRACEINW("(radius=%d seed=%d)", radius, seed);
  srandom(seed);
  int random_x = random_number_in_range(-radius, radius);
  int random_y = random_number_in_range(-radius, radius);
  TRACEMESS("Add 1 grain on (%d,%d)", random_x, random_y);
  add_grains_on_square(random_x, random_y, 1);
  TRACEOUT;
}
예제 #5
0
int
main(int argc, char **argv)
{
    int last_track = -1;

    if (argc == 2 && strcmp(argv[1], "--always") == 0) {
	always = 1;
    } else if (argc > 1) {
	fprintf(stderr, "usage: [--always]\n");
	exit(1);
    }

    if (wb_init() < 0) {
	fprintf(stderr, "failed to initialize wb\n");
	exit(1);
    }

    set_flash(false);

    load_tracks();

    while (1) {
	int track;
	int bolt;

	if (! always) {
	    ween_time_wait_until_valid(ween_time_constraints, n_ween_time_constraints);
	}

	ms_sleep(random_number_in_range(2000, 5000));

	do {
	    track = random_number_in_range(0, N_TRACKS-1);
	} while (track == last_track);
	last_track = track;

	track_set_volume(tracks[track], ween_time_is_valid(&is_halloween_constraint, 1) ? 100 : 75);

	track_play_asynchronously(tracks[track], NULL);

	for (bolt = 0; bolt < N_BOLTS && bolt_times[track][bolt]; bolt++) {
	    int flashes = random_number_in_range(1, 2);
	    int ms_left = bolt_times[track][bolt];

	    while (flashes-- && ms_left) {
		set_flash(true);
		ms_left -= do_sleep(200, ms_left);
		set_flash(false);
		ms_left -= do_sleep(50, ms_left);
	    }
	    if (ms_left) ms_sleep(ms_left);
	}
    }
}
예제 #6
0
static void
do_attack(unsigned pin, lights_t *l, double up, double down)
{
    unsigned i;

    for (i = 0; i < 3; i++) {
	wb_set(ANIMATION_OUTPUT_BANK, pin, 1);
	ms_sleep((500 + random_number_in_range(0, 250) - 125)*up);
	wb_set(ANIMATION_OUTPUT_BANK, pin, 0);
	ms_sleep((200 + random_number_in_range(0, 100) - 50)*down);
    }
}
예제 #7
0
static int
do_sleep(int ms, int ms_left)
{
    int this_ms = random_number_in_range(50, ms+50);
    if (this_ms > ms_left) this_ms = ms_left;
    ms_sleep(this_ms);
    return this_ms;
}
예제 #8
0
static void joust(void *picked_winner_as_vp, lights_t *l, unsigned pin)
{
    unsigned picked_winner = (unsigned) picked_winner_as_vp;
    unsigned want_winner = picked_winner == WIN_2_PIN;
    unsigned winner_id = random_number_in_range(0, 1);

    stop_stop(pick_stop);

    fprintf(stderr, "Starting joust\n");

    lights_blink_one(l, pin);

    track_play_asynchronously(jousting, stop);
    motor_forward(0, 1);
    motor_forward(1, 1);
    ms_sleep(WIN_MS);
    stop_stop(stop);
    track_play_asynchronously(crash, stop);
    motor_forward(0, TROT_DUTY);
    motor_forward(1, TROT_DUTY);
    ms_sleep(TROT_MS);

    stop_stop(stop);
    motor_stop(0);
    motor_stop(1);

    fprintf(stderr, "wanted %d got %d\n", want_winner, winner_id);

    if (winner_id == 0) {
	wb_set(MOTOR_BANK, WINNER_LIGHT_1, 1);
    } else {
	wb_set(MOTOR_BANK, WINNER_LIGHT_2, 1);
    }

    if (winner_id == want_winner) {
	track_play(winner);
    } else {
	track_play(loser);
    }

    ms_sleep(1000);

    wb_set(MOTOR_BANK, WINNER_LIGHT_1, 0);
    wb_set(MOTOR_BANK, WINNER_LIGHT_2, 0);

    lights_off(l);

    track_play_asynchronously(beeping, stop);
    go_to_start_position();
    stop_stop(stop);
}
예제 #9
0
파일: coffin.c 프로젝트: crpalmer/halloween
static void blink_lights_for(bool *is_lit, int ms)
{
    struct timespec start;
    struct timespec now;

    nano_gettime(&start);
    do {
	int light_time = random_number_in_range(LIGHT_LOW, LIGHT_HIGH);

	*is_lit = !(*is_lit);
	wb_set(LIGHT_PIN, *is_lit);
printf("light %d for %d\n", *is_lit, light_time); fflush(stdout);
	ms_sleep(light_time);
	nano_gettime(&now);
    } while (nano_elapsed_ms(&now, &start) < ms);
}