int
main(int argc, char **argv)
{
pthread_t sparky_thread;
fogger_args_t fogger_args = { 0.01, 0.01 };
track_t *cogs;
if (wb_init() < 0) {
fprintf(stderr, "failed to initialize wb\n");
exit(1);
}
if ((cogs = track_new("cogs.wav")) == NULL) {
exit(1);
}
pthread_create(&sparky_thread, NULL, sparky_main, NULL);
fogger_run_in_background(FOGGER_PIN, &fogger_args);
track_play_loop(cogs, NULL);
blink_main();
return 0;
}
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;
}
int lpack(lua_State *L) {
struct write_block b;
wb_init(&b, NULL);
_pack_from(L, &b, 0);
struct block * ret = wb_close(&b);
lua_pushlightuserdata(L, ret);
return 1;
}
static int
lappend(lua_State *L) {
struct write_block b;
wb_init(&b, lua_touserdata(L,1));
pack_from(L,&b,1);
struct block * ret = wb_close(&b);
lua_pushlightuserdata(L,ret);
return 1;
}
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);
}
}
}
wbArg_t wbArg_new(void) {
wbArg_t arg;
wb_init();
wbArg_setInputCount(arg, 0);
wbArg_setInputFiles(arg, NULL);
wbArg_setOutputFile(arg, NULL);
wbArg_setType(arg, NULL);
wbArg_setExpectedOutputFile(arg, NULL);
return arg;
}
void wbLogger_append(wbLogLevel_t level, string msg, const char *file,
const char *fun, int line) {
wbLogEntry_t elem;
wbLogger_t logger;
wb_init(NULL, NULL);
logger = _logger;
if (wbLogger_getLevel(logger) < level) {
return;
}
elem = wbLogEntry_initialize(level, msg, file, fun, line);
#ifdef wbLogger_printOnLog
if (wbLogger_printOnLog) {
if (level <= wbLogger_getLevel(logger) && elem) {
json11::Json json = json11::Json::object{
{"type", "logger"},
{"id", wbLogEntry_getId(elem)},
{"session_id", wbLogEntry_getSessionId(elem)},
{"data", wbLogEntry_toJSONObject(elem)}};
std::cout << json.dump() << std::endl;
}
}
#endif /* wbLogger_printOnLog */
if (wbLogger_getHead(logger) == NULL) {
wbLogger_setHead(logger, elem);
} else {
wbLogEntry_t prev = wbLogger_getHead(logger);
while (wbLogEntry_hasNext(prev)) {
prev = wbLogEntry_getNext(prev);
}
wbLogEntry_setNext(prev, elem);
}
#if 0
if (level <= wbLogger_getLevel(logger) && elem) {
const char *levelName = getLevelName(level);
fprintf(stderr, "= LOG: %s: %s (In %s:%s on line %d). =\n", levelName,
wbLogEntry_getMessage(elem), wbLogEntry_getFile(elem),
wbLogEntry_getFunction(elem), wbLogEntry_getLine(elem));
}
#endif
wbLogger_incrementLength(logger);
return;
}
static int cgwb_bdi_init(struct backing_dev_info *bdi)
{
int ret;
INIT_RADIX_TREE(&bdi->cgwb_tree, GFP_ATOMIC);
bdi->cgwb_congested_tree = RB_ROOT;
ret = wb_init(&bdi->wb, bdi, 1, GFP_KERNEL);
if (!ret) {
bdi->wb.memcg_css = &root_mem_cgroup->css;
bdi->wb.blkcg_css = blkcg_root_css;
}
return ret;
}
static int cgwb_bdi_init(struct backing_dev_info *bdi)
{
int err;
bdi->wb_congested = kzalloc(sizeof(*bdi->wb_congested), GFP_KERNEL);
if (!bdi->wb_congested)
return -ENOMEM;
err = wb_init(&bdi->wb, bdi, 1, GFP_KERNEL);
if (err) {
kfree(bdi->wb_congested);
return err;
}
return 0;
}
static int cgwb_bdi_init(struct backing_dev_info *bdi)
{
int err;
bdi->wb_congested = kzalloc(sizeof(*bdi->wb_congested), GFP_KERNEL);
if (!bdi->wb_congested)
return -ENOMEM;
atomic_set(&bdi->wb_congested->refcnt, 1);
err = wb_init(&bdi->wb, bdi, 1, GFP_KERNEL);
if (err) {
wb_congested_put(bdi->wb_congested);
return err;
}
return 0;
}
int
main(int argc, char **argv)
{
pi_usb_init();
wb_init();
wb_set(LIGHTS, 0);
if ((m = maestro_new()) == NULL) {
fprintf(stderr, "Failed to initialize servo controller\n");
exit(1);
}
song = track_new(SONG_WAV);
if (! song) {
perror(SONG_WAV);
exit(1);
}
init_servos();
while (1) {
wb_set(LIGHTS, 0);
rest_servos();
ween2018_wait_until_valid();
ms_sleep(BETWEEN_SONG_MS);
nano_gettime(&start);
wb_set(LIGHTS, 1);
talking_skull_actor_play(lead);
talking_skull_actor_play(backup);
talking_skull_actor_play(bass);
talking_skull_actor_play(triangle);
track_play(song);
}
return 0;
}
void wbLogger_append(wbLogLevel_t level, string msg, const char *file,
const char *fun, int line) {
wbLogEntry_t elem;
wbLogger_t logger;
wb_init();
logger = _logger;
if (wbLogger_getLevel(logger) < level) {
return;
}
elem = wbLogEntry_initialize(level, msg, file, fun, line);
if (wbLogger_getHead(logger) == NULL) {
wbLogger_setHead(logger, elem);
} else {
wbLogEntry_t prev = wbLogger_getHead(logger);
while (wbLogEntry_hasNext(prev)) {
prev = wbLogEntry_getNext(prev);
}
wbLogEntry_setNext(prev, elem);
}
#if 0
if (level <= wbLogger_getLevel(logger) && elem) {
const char *levelName = getLevelName(level);
fprintf(stderr, "= LOG: %s: %s (In %s:%s on line %d). =\n", levelName,
wbLogEntry_getMessage(elem), wbLogEntry_getFile(elem),
wbLogEntry_getFunction(elem), wbLogEntry_getLine(elem));
}
#endif
wbLogger_incrementLength(logger);
return;
}
int
main(int argc, char **argv)
{
if (wb_init() < 0) {
fprintf(stderr, "Failed to initialize wb\n");
exit(1);
}
pthread_mutex_init(&lock, NULL);
stop = stop_new();
pick_stop = stop_new();
stop_stopped(pick_stop);
winner = track_new_fatal("jousters_winner.wav");
loser = track_new_fatal("jousters_loser.wav");
jousting = track_new_fatal("jousters_jousting.wav");
crash = track_new_fatal("jousters_crash.wav");
beeping = track_new_fatal("jousters_beeping.wav");
wb_set_pull_up(HOME_1_PIN, WB_PULL_UP_UP);
wb_set_pull_up(WIN_1_PIN, WB_PULL_UP_UP);
wb_set_pull_up(HOME_2_PIN, WB_PULL_UP_UP);
wb_set_pull_up(WIN_2_PIN, WB_PULL_UP_UP);
motor_forward(0, 0.5);
motor_forward(1, 0.5);
ms_sleep(1000);
motor_stop(0);
motor_stop(1);
ms_sleep(500);
go_to_start_position();
animation_main(stations);
return 0;
}
int
main(int argc, char **argv)
{
int bank;
if (wb_init() < 0) {
fprintf(stderr, "Failed to initialize wb\n");
exit(1);
}
if (argc == 3 && strcmp(argv[1], "--out") == 0 && sscanf(argv[2], "%d", &bank) == 1) {
if (bank < 1 || bank > 2) {
fprintf(stderr, "Invalid output bank, must be either 0 or 1\n");
exit(1);
}
output_test(bank);
} else if (argc != 1) {
fprintf(stderr, "usage: [--out bank]\n");
exit(1);
} else {
input_test();
}
exit(0);
}
static int cgwb_create(struct backing_dev_info *bdi,
struct cgroup_subsys_state *memcg_css, gfp_t gfp)
{
struct mem_cgroup *memcg;
struct cgroup_subsys_state *blkcg_css;
struct blkcg *blkcg;
struct list_head *memcg_cgwb_list, *blkcg_cgwb_list;
struct bdi_writeback *wb;
unsigned long flags;
int ret = 0;
memcg = mem_cgroup_from_css(memcg_css);
blkcg_css = cgroup_get_e_css(memcg_css->cgroup, &io_cgrp_subsys);
blkcg = css_to_blkcg(blkcg_css);
memcg_cgwb_list = mem_cgroup_cgwb_list(memcg);
blkcg_cgwb_list = &blkcg->cgwb_list;
/* look up again under lock and discard on blkcg mismatch */
spin_lock_irqsave(&cgwb_lock, flags);
wb = radix_tree_lookup(&bdi->cgwb_tree, memcg_css->id);
if (wb && wb->blkcg_css != blkcg_css) {
cgwb_kill(wb);
wb = NULL;
}
spin_unlock_irqrestore(&cgwb_lock, flags);
if (wb)
goto out_put;
/* need to create a new one */
wb = kmalloc(sizeof(*wb), gfp);
if (!wb)
return -ENOMEM;
ret = wb_init(wb, bdi, blkcg_css->id, gfp);
if (ret)
goto err_free;
ret = percpu_ref_init(&wb->refcnt, cgwb_release, 0, gfp);
if (ret)
goto err_wb_exit;
ret = fprop_local_init_percpu(&wb->memcg_completions, gfp);
if (ret)
goto err_ref_exit;
wb->memcg_css = memcg_css;
wb->blkcg_css = blkcg_css;
INIT_WORK(&wb->release_work, cgwb_release_workfn);
set_bit(WB_registered, &wb->state);
/*
* The root wb determines the registered state of the whole bdi and
* memcg_cgwb_list and blkcg_cgwb_list's next pointers indicate
* whether they're still online. Don't link @wb if any is dead.
* See wb_memcg_offline() and wb_blkcg_offline().
*/
ret = -ENODEV;
spin_lock_irqsave(&cgwb_lock, flags);
if (test_bit(WB_registered, &bdi->wb.state) &&
blkcg_cgwb_list->next && memcg_cgwb_list->next) {
/* we might have raced another instance of this function */
ret = radix_tree_insert(&bdi->cgwb_tree, memcg_css->id, wb);
if (!ret) {
atomic_inc(&bdi->usage_cnt);
list_add_tail_rcu(&wb->bdi_node, &bdi->wb_list);
list_add(&wb->memcg_node, memcg_cgwb_list);
list_add(&wb->blkcg_node, blkcg_cgwb_list);
css_get(memcg_css);
css_get(blkcg_css);
}
}
spin_unlock_irqrestore(&cgwb_lock, flags);
if (ret) {
if (ret == -EEXIST)
ret = 0;
goto err_fprop_exit;
}
goto out_put;
err_fprop_exit:
fprop_local_destroy_percpu(&wb->memcg_completions);
err_ref_exit:
percpu_ref_exit(&wb->refcnt);
err_wb_exit:
wb_exit(wb);
err_free:
kfree(wb);
out_put:
css_put(blkcg_css);
return ret;
}
static status_t
wb840_open(const char *name, uint32 flags, void** cookie)
{
char *deviceName = NULL;
int32 i;
int32 mask;
struct wb_device *data;
status_t status;
LOG((DEVICE_NAME ": open()\n"));
for (i = 0; (deviceName = gDevNameList[i]) != NULL; i++) {
if (!strcmp(name, deviceName))
break;
}
if (deviceName == NULL) {
LOG(("invalid device name"));
return EINVAL;
}
// There can be only one access at time
mask = 1L << i;
if (atomic_or(&sOpenMask, mask) & mask)
return B_BUSY;
// Allocate a wb_device structure
if (!(data = (wb_device *)malloc(sizeof(wb_device)))) {
sOpenMask &= ~(1L << i);
return B_NO_MEMORY;
}
memset(data, 0, sizeof(wb_device));
*cookie = data;
#ifdef DEBUG
load_driver_symbols("wb840");
#endif
data->devId = i;
data->pciInfo = gDevList[i];
data->deviceName = gDevNameList[i];
data->blockFlag = 0;
data->reg_base = data->pciInfo->u.h0.base_registers[0];
data->wb_cachesize = gPci->read_pci_config(data->pciInfo->bus, data->pciInfo->device,
data->pciInfo->function, PCI_line_size, sizeof (PCI_line_size)) & 0xff;
wb_read_eeprom(data, &data->MAC_Address, 0, 3, false);
status = wb_create_semaphores(data);
if (status < B_OK) {
LOG((DEVICE_NAME ": Couldn't create semaphores\n"));
goto err;
}
status = wb_stop(data);
if (status < B_OK) {
LOG((DEVICE_NAME": Can't stop device\n"));
goto err1;
}
status = wb_initPHYs(data);
if (status < B_OK) {
LOG((DEVICE_NAME": Can't init PHYs\n"));
goto err1;
}
wb_init(data);
/* Setup interrupts */
data->irq = data->pciInfo->u.h0.interrupt_line;
status = install_io_interrupt_handler(data->irq, wb_interrupt, data, 0);
if (status < B_OK) {
LOG((DEVICE_NAME
" can't install interrupt handler: %s\n", strerror(status)));
goto err1;
}
LOG(("Interrupts installed at irq line %x\n", data->irq));
status = wb_create_rings(data);
if (status < B_OK) {
LOG((DEVICE_NAME": can't create ring buffers\n"));
goto err2;
}
wb_enable_interrupts(data);
WB_SETBIT(data->reg_base + WB_NETCFG, WB_NETCFG_RX_ON);
write32(data->reg_base + WB_RXSTART, 0xFFFFFFFF);
WB_SETBIT(data->reg_base + WB_NETCFG, WB_NETCFG_TX_ON);
add_timer(&data->timer, wb_tick, 1000000LL, B_PERIODIC_TIMER);
return B_OK; // Everything after this line is an error
err2:
remove_io_interrupt_handler(data->irq, wb_interrupt, data);
err1:
wb_delete_semaphores(data);
err:
sOpenMask &= ~(1L << i);
free(data);
LOG(("wb840: Open Failed\n"));
return status;
}
static inline void _wbLogger_setLevel(wbLogLevel_t level) {
wb_init();
_wbLogger_setLevel(_logger, level);
}
