double transfer(struct adafs_touch_state ts[],
enum state *s, enum event ev, double in) {
switch (*s) {
case ST_CON:
if (ev == EV_USER) {
update_hist_int(ts, ST_CON, in);
update_timer(ts, ST_CON);
return threshold(ts);
} else if (ev == EV_TIMER) {
*s = ST_DIS;
return predict_int(ts);
} else fprintf(stderr, "Invalid event %d on state %d\n", ev, *s);
break;
case ST_DIS:
rec_result(ts, in);
if (ev == EV_USER) {
if (in <= threshold(ts)) {
*s = ST_CON;
update_hist_int(ts, ST_CON, in);
update_timer(ts, ST_CON);
return threshold(ts);
} else {
*s = ST_DIS_DOWN;
update_hist_int(ts, ST_DIS, in);
return threshold(ts);
}
} else if (ev == EV_TIMER) {
*s = ST_DIS_UP;
} else fprintf(stderr, "Invalid event %d on state %d\n", ev, *s);
break;
case ST_DIS_DOWN:
if (ev == EV_USER) {
*s = ST_CON;
update_hist_int(ts, ST_CON, in);
update_timer(ts, ST_CON);
return threshold(ts);
} else if (ev == EV_TIMER) {
*s = ST_DIS;
return predict_int(ts);
} else fprintf(stderr, "Invalid event %d on state %d\n", ev, *s);
break;
case ST_DIS_UP:
if (ev == EV_USER) {
*s = ST_CON;
update_hist_int(ts, ST_DIS, in);
return threshold(ts);
} else fprintf(stderr, "Invalid event %d on state %d\n", ev, *s);
break;
}
return INVAL_TIME;
}
static void timer_queue_push(uint32_t core_id, task_t* task)
{
task_list_t* timer_queue = &readyqueues[core_id].timers;
spinlock_irqsave_lock(&readyqueues[core_id].lock);
task_t* first = timer_queue->first;
if(!first) {
timer_queue->first = timer_queue->last = task;
task->next = task->prev = NULL;
#ifdef DYNAMIC_TICKS
update_timer(task);
#endif
} else {
// lookup position where to insert task
task_t* tmp = first;
while(tmp && (task->timeout >= tmp->timeout))
tmp = tmp->next;
if(!tmp) {
// insert at the end of queue
task->next = NULL;
task->prev = timer_queue->last;
// there has to be a last element because there is also a first one
timer_queue->last->next = task;
timer_queue->last = task;
} else {
task->next = tmp;
task->prev = tmp->prev;
tmp->prev = task;
if(task->prev)
task->prev->next = task;
if(timer_queue->first == tmp) {
timer_queue->first = task;
#ifdef DYNAMIC_TICKS
update_timer(task);
#endif
}
}
}
spinlock_irqsave_unlock(&readyqueues[core_id].lock);
}
int riotcore_snapshot_write_module(riot_context_t *riot_context, snapshot_t *p)
{
snapshot_module_t *m;
m = snapshot_module_create(p, riot_context->myname,
RIOT_DUMP_VER_MAJOR, RIOT_DUMP_VER_MINOR);
if (m == NULL)
return -1;
update_timer(riot_context);
SMW_B(m, riot_context->riot_io[0]);
SMW_B(m, riot_context->riot_io[1]);
SMW_B(m, riot_context->riot_io[2]);
SMW_B(m, riot_context->riot_io[3]);
SMW_B(m, riot_context->r_edgectrl);
SMW_B(m, (BYTE)(riot_context->r_irqfl | (riot_context->r_irqline ? 1 : 0)));
SMW_B(m, (BYTE)(riot_context->r_N - (*(riot_context->clk_ptr)
- riot_context->r_write_clk)
/ riot_context->r_divider));
SMW_W(m, (WORD)(riot_context->r_divider));
SMW_W(m, (BYTE)((*(riot_context->clk_ptr) - riot_context->r_write_clk)
% riot_context->r_divider));
SMW_B(m, (BYTE)(riot_context->r_irqen ? 1 : 0));
snapshot_module_close(m);
return 0;
}
void mc146818_device::nvram_default()
{
// populate from a memory region if present
if (m_region != NULL)
{
UINT32 bytes = m_region->bytes();
if (bytes > data_size())
bytes = data_size();
memcpy(&m_data[0], m_region->base(), bytes);
}
else
{
memset(&m_data[0], 0, data_size());
}
if(m_binary)
m_data[REG_B] |= REG_B_DM;
if(m_hour)
m_data[REG_B] |= REG_B_24_12;
set_base_datetime();
update_timer();
update_irq();
}
/**
* uart_tty_receive() - Called by TTY low level driver when receive data is available.
* @tty: Pointer to TTY instance data
* @data: Pointer to received data
* @flags: Pointer to flags for data
* @count: Count of received data in bytes
*/
static void uart_tty_receive(struct tty_struct *tty, const u8 *data,
char *flags, int count)
{
CG2900_INFO("uart_tty_receive");
if (tty != uart_info->tty)
return;
CG2900_DBG_DATA("Received data with length = %d and first byte 0x%02X",
count, data[0]);
CG2900_DBG_DATA_CONTENT("uart_tty_receive", data, count);
#ifdef BAUD_RATE_FIX
del_timer(&uart_info->timer);
#endif /* BAUD_RATE_FIX */
/* Restart data ccd timer */
spin_lock(&uart_info->rx_lock);
#ifndef BAUD_RATE_FIX
update_timer();
#endif /* BAUD_RATE_FIX */
uart_receive_skb(data, count);
spin_unlock(&uart_info->rx_lock);
#ifndef BAUD_RATE_FIX
/* Open TTY for more data */
tty_unthrottle(tty);
#endif /* BAUD_RATE_FIX */
}
void check_timers(void)
{
readyqueues_t* readyqueue = &readyqueues[CORE_ID];
spinlock_irqsave_lock(&readyqueue->lock);
// since IRQs are disabled, get_clock_tick() won't increase here
const uint64_t current_tick = get_clock_tick();
// wakeup tasks whose deadline has expired
task_t* task;
while ((task = readyqueue->timers.first) && (task->timeout <= current_tick))
{
// pops task from timer queue, so next iteration has new first element
wakeup_task(task->id);
}
#ifdef DYNAMIC_TICKS
task = readyqueue->timers.first;
if (task) {
update_timer(task);
}
#endif
spinlock_irqsave_unlock(&readyqueue->lock);
}
int on_write(int epoll_fd, int sockfd)
{
char* str;
socket_buf sb;
int total_to_write, len;
sb = find_socket_buf(sockfd);
assert(sb != NULL);
total_to_write = sb->wb_size;
str = sb->write_buf;
while(total_to_write > 0){
if ((len = write(sockfd, str,
(total_to_write >= MAX_LINE) ? MAX_LINE : total_to_write)) < 0) {
if(errno == EINTR)
continue;
else {
perror("write failed:");
return L_HTTP_FAIL;
}
}
else if(len == 0) {
return L_HTTP_FAIL;
}
str += len;
total_to_write -= len;
}
sb->wb_size = 0;
update_timer(sb->timer);
return epoll_modify_mod(epoll_fd, EPOLLIN, sockfd);
}
int setup_timer(t_player *p, t_init *data)
{
char *cmd;
int x;
x = -1;
cmd = p->buf.get(&(p->buf));
if (cmd == NULL)
return (1);
update_timer(p);
p->end = 0;
while (data->cmd[++x])
if ((strncmp(data->cmd[x], cmd, strlen(data->cmd[x]))) == 0)
p->end = time(NULL) + (data->time[x] / data->speed);
if (p->end == 0)
{
cmd = p->buf.read_buffer(&(p->buf));
cmd[strlen(cmd) - 1] = '\0';
write(1, STR_IGNORED, strlen(STR_IGNORED));
write(1, cmd, strlen(cmd));
write(1, STR_COMMAND, strlen(STR_COMMAND));
free(cmd);
}
return (0);
}
int CHelperUnit::HangupNotify (void)
{
log_debug("CHelperUnit object hangup notify: fd[%d]", netfd);
update_timer();
process_pkg();
reset_helper();
return POLLER_COMPLETE;
}
void mc146818_device::nvram_read(emu_file &file)
{
file.read(m_data, data_size());
set_base_datetime();
update_timer();
update_irq();
}
static TIMER_CALLBACK( display_enable_changed_timer_cb )
{
crtc6845_state *chip = ptr;
/* call the callback function -- we know it exists */
chip->intf->display_enable_changed(is_display_enabled(chip));
update_timer(chip);
}
int CHelperUnit::InputNotify (void)
{
update_timer();
int ret = recv_from_cgi();
if (ret < 0)
{
log_error("call recv failed, helper client netfd[%d]", netfd);
reset_helper();
return POLLER_COMPLETE;
}
return POLLER_SUCC;
}
static bool network_update_next_timeout(network_t * network)
{
probe_t * probe;
double next_timeout;
if ((probe = network_get_oldest_probe(network))) {
next_timeout = network_get_probe_timeout(network, probe);
} else {
// The timer will be disarmed since there is no more flying probes
next_timeout = 0;
}
return update_timer(network->timerfd, next_timeout);
}
void UpdateElement::start(Host *host)
{
h = host ;
thread = new updatethread(this) ;
thread->setHosts(hosts);
thread->setServerIndex(index) ;
thread->start();
QTimer *timer = host->getTimer() ;
//if (timer != NULL) timer->stop(); delete timer ;
timer = new QTimer() ;
h->setTimer(timer);
QObject::connect(timer, SIGNAL(timeout()), this, SLOT(update_timer())) ;
timer->start(50000);
}
inline void Gbs_Core::write_io_inline( int offset, int data, int base )
{
if ( (unsigned) (offset - (apu_.io_addr - base)) < apu_.io_size )
apu_.write_register( time(), offset + base, data & 0xFF );
else if ( (unsigned) (offset - (0xFF06 - base)) < 2 )
update_timer();
else if ( offset == io_base - base )
ram [base - ram_addr + offset] = 0; // keep joypad return value 0
else
ram [base - ram_addr + offset] = 0xFF;
//if ( offset == 0xFFFF - base )
// dprintf( "Wrote interrupt mask\n" );
}
static int testmod_sysctl_handler(ctl_table *ctl, int write,
void __user *buffer, size_t *lenp, loff_t *ppos)
{
int ret = 0;
ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
printk(KERN_INFO "Updating\n");
update_timer();
return ret;
}
static void configure_screen(crtc6845_state *chip, int postload)
{
if (chip->intf)
{
/* compute the screen sizes */
UINT16 horiz_total = (chip->horiz_total + 1) * chip->intf->hpixels_per_column;
UINT16 vert_total = (chip->vert_total + 1) * (chip->max_ras_addr + 1) + chip->vert_total_adj;
/* determine the visible area, avoid division by 0 */
UINT16 max_x = chip->horiz_disp * chip->intf->hpixels_per_column - 1;
UINT16 max_y = chip->vert_disp * (chip->max_ras_addr + 1) - 1;
/* update only if screen parameters changed, unless we are coming here after loading the saved state */
if (postload ||
(horiz_total != chip->last_horiz_total) || (vert_total != chip->last_vert_total) ||
(max_x != chip->last_max_x) || (max_y != chip->last_max_y))
{
/* update the screen only if we have valid data */
if ((chip->horiz_total > 0) && (max_x < horiz_total) && (chip->vert_total > 0) && (max_y < vert_total))
{
rectangle visarea;
attoseconds_t refresh = HZ_TO_ATTOSECONDS(chip->intf->clock) * (chip->horiz_total + 1) * vert_total;
visarea.min_x = 0;
visarea.min_y = 0;
visarea.max_x = max_x;
visarea.max_y = max_y;
if (LOG) logerror("CRTC6845 config screen: HTOTAL: %x VTOTAL: %x MAX_X: %x MAX_Y: %x FPS: %f\n",
horiz_total, vert_total, max_x, max_y, 1 / ATTOSECONDS_TO_DOUBLE(refresh));
video_screen_configure(chip->intf->scrnum, horiz_total, vert_total, &visarea, refresh);
chip->has_valid_parameters = TRUE;
}
else
chip->has_valid_parameters = FALSE;
chip->last_horiz_total = horiz_total;
chip->last_vert_total = vert_total;
chip->last_max_x = max_x;
chip->last_max_y = max_y;
update_timer(chip);
}
}
}
void stop_elev(){
update_timer();
if (current_state == UP) {
elev_set_speed(-300);
usleep(5000);
elev_set_speed(0);
}
if (current_state == DOWN) {
elev_set_speed(300);
usleep(5000);
elev_set_speed(0);
}
}
int on_read(int epoll_fd, int sockfd)
{
int total, len;
socket_buf sb;
sb = find_socket_buf(sockfd);
assert(sb != NULL);
if(ioctl(sockfd, FIONREAD, &total) < 0) {
printf("ioctl fail");
return L_HTTP_FAIL;
}
if(total <= 0)
return L_HTTP_FAIL;
if(socket_read_buf_alloc(sb, total) == L_HTTP_FAIL)
return L_HTTP_FAIL;
while(total > 0) {
if((len = read(sockfd, sb->read_buf, (total > MAX_LINE)? MAX_LINE : total)) < 0) {
if(errno == EINTR) {
continue;
}
else {
perror("read fail");
return L_HTTP_FAIL;
}
}
else if(len == 0) {
return L_HTTP_FAIL;
}
total -= len;
sb->rb_size += len;
}
printf("read_buf:%s\n", sb->read_buf);
sb->state = STATE_HTTP_WRITE;
if(handle_connection(sb) == L_HTTP_FAIL) {
return L_HTTP_FAIL;
}
update_timer(sb->timer);
return epoll_modify_mod(epoll_fd, EPOLLOUT, sockfd);
}
static void timer_queue_remove(uint32_t core_id, task_t* task)
{
if(BUILTIN_EXPECT(!task, 0)) {
return;
}
task_list_t* timer_queue = &readyqueues[core_id].timers;
#ifdef DYNAMIC_TICKS
// if task is first in timer queue, we need to update the oneshot
// timer for the next task
if(timer_queue->first == task) {
update_timer(task->next);
}
#endif
task_list_remove_task(timer_queue, task);
}
magnetic::magnetic(QWidget *parent) :
MainWindow(parent),
ui(new Ui::magnetic)
{
ui->setupUi(this);
createActions();
createMenus();
timer = new QTimer(this);
connect(timer, SIGNAL(timeout()), this, SLOT(update_timer()));
fd = open(devname, O_RDWR);
if (fd < 0)
printf("open error\n");
timer->start(5000);
printf("##################\n");
get_decode("下");
printf("##################\n");
}
static void riotcore_clk_overflow_callback(CLOCK sub, void *data)
{
riot_context_t *riot_context;
riot_context = (riot_context_t *)data;
if (riot_context->enabled == 0)
return;
update_timer(riot_context);
riot_context->r_write_clk -= sub;
if (riot_context->read_clk > sub)
riot_context->read_clk -= sub;
else
riot_context->read_clk = 0;
}
/* This can only be called with packet-buf filled with a packet and
it's attributes */
int
transmit_buffer_add_packet(clock_time_t time, uint8_t id)
{
int i;
for(i = 0; i < MAX_TX_BUF; i++) {
if(buffers[i].len == 0) {
/* copy the packet data into the buffer */
/* what more needs to be stored? */
buffers[i].len = packetbuf_datalen();
buffers[i].id = id;
memcpy(buffers[i].packet, packetbuf_dataptr(), packetbuf_datalen());
buffers[i].time = time;
buffers[i].txmits = packetbuf_attr(PACKETBUF_ATTR_MAX_MAC_TRANSMISSIONS);
update_timer();
return 1;
}
}
return 0;
}
TimeLineWidget::TimeLineWidget(QWidget* parent)
: QGraphicsView(parent),
offset_(0.),
scale_(1.),
current_(10.),
length_(100.),
cursor_(nullptr),
time_lbl_(nullptr),
preview_time_(0),
playing_(false),
preview_(nullptr)
{
instance_ = this;
setScene(&scene_);
scene_.setSceneRect(QRectF(0, 0, 4000, 150));
scene_.setItemIndexMethod(QGraphicsScene::NoIndex);
setMinimumSize(640, 250);
setRenderHint(QPainter::Antialiasing);
cursor_ = new TimeLineCursorWidget(this);
cursor_->setCursor(QCursor(Qt::SizeHorCursor));
cursor_->setPos(0, 0);
cursor_->setZValue(1.);
cursor_->sync();
scene_.addItem(cursor_);
time_lbl_ = new QLabel;
update_time_label();
timer_ = new QTimer(this);
connect(timer_, SIGNAL(timeout()), this, SLOT(update_timer()));
set_playing(false);
connect(this, SIGNAL(set_playing(bool)), this, SLOT(setup_timer(bool)));
/*QGraphicsProxyWidget* proxy = scene_.addWidget(time_lbl_);
proxy->setPos(100, 50);
proxy->setZValue(0.5);*/
}
void mc146818_device::nvram_default()
{
// populate from a memory region if present
if (m_region != NULL)
{
UINT32 bytes = m_region->bytes();
if (bytes > data_size())
bytes = data_size();
memcpy(m_data, m_region->base(), bytes);
}
else
{
memset(m_data, 0, data_size());
}
set_base_datetime();
update_timer();
update_irq();
}
/*---------------------------------------------------------------------------*/
static void
handle_send_timer(void *ptr)
{
struct tx_buffer *buf;
buf = (struct tx_buffer *) ptr;
if(buf != NULL) {
/* Here is when the packets needs to be transmitted!!! */
/* Prepare packetbuf */
packetbuf_copyfrom(buf->packet, buf->len);
packetbuf_set_attr(PACKETBUF_ATTR_MAX_MAC_TRANSMISSIONS, buf->txmits);
/* time to send the packet. */
serial_radio_send_packet(buf->id);
PRINTF("TRB: timed packet sent at: tgt:%lu time:%lu %u bytes id:%u\n",
(unsigned long)buf->time, (unsigned long)clock_time(), buf->len, buf->id);
/* done - set length to zero to avoid using this again */
buf->len = 0;
}
update_timer();
}
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow)
{
ui->setupUi(this);
setImgPaths();
QPixmap bg(path+"/images/dsknight.png");
QPalette p(palette());
p.setBrush(QPalette::Background, bg);
setAutoFillBackground(true);
setPalette(p);
mines_left = MINES;
QWidget::setWindowIcon(QIcon(QString(path+"/images/skull.png")));
QWidget::setFixedSize(this->size());
//initialize the high scores
for(unsigned int i=0; i<10; i++) {
scores.push_back(9999);
names.push_back("noname");
}
//read in the high scores from the files
read_in_highscores();
//construct and display the grid
prepare_grid(50, 100, GRID_SIZE, this);
//initialize counter for number of tiles uncovered
numUncovered = 0;
//initialize timer
elapsed_time = 0;
timer = new QTimer(this);
timer->start(1000);
connect (timer, SIGNAL(timeout()), this, SLOT(update_timer()));
//set the reset button icon
ui->reset_button->setIcon(QIcon(okay));
ui->reset_button->setStyleSheet( "background-color: rgba( 50, 50, 50, 60% ); color: white;" );
ui->label_2->setStyleSheet("color: white;");
ui->mine_left_label->setStyleSheet("color: white;");
ui->mines_left_display->setStyleSheet("color: white;");
ui->timer_label->setStyleSheet("color: white;");
}
/**
* uart_write() - Transmit data to CG2900 over UART.
* @dev: Transport device information.
* @skb: SK buffer to transmit.
*
* Returns:
* 0 if there is no error.
* Errors from create_work_item.
*/
static int uart_write(struct cg2900_trans_dev *dev, struct sk_buff *skb)
{
int err;
#ifdef BAUD_RATE_FIX
/* Delete sleep timer. */
(void)del_timer(&uart_info->timer);
#else /* BAUD_RATE_FIX */
update_timer();
#endif /* BAUD_RATE_FIX */
/* Queue the sk_buffer... */
skb_queue_tail(&uart_info->tx_queue, skb);
CG2900_DBG_DATA_CONTENT("uart_write", skb->data, skb->len);
/* ...and start TX operation */
err = create_work_item(uart_info->wq, work_do_transmit, NULL);
if (err)
CG2900_ERR("Failed to create work item (%d) uart_tty_wakeup",
err);
return err;
}
void ixx_event_loop_update(IxxEventLoop* self)
{
int timeout = calc_timeout(self);
FD_ZERO(&self->read_fds);
FD_ZERO(&self->write_fds);
int nfd = 0;
for (IxxEvent* event = self->events.first;
event;
event = event->node.next)
{
int fd = 0;
switch (event->type) {
case IXX_EVENT_UNDEFINED:
break;
case IXX_EVENT_TIMER:
break;
case IXX_EVENT_THREAD:
break;
case IXX_EVENT_SOCKET_CONNECT:
fd = event->socket_connect.socket;
FD_SET(fd, &self->write_fds);
break;
case IXX_EVENT_SOCKET_ACCEPT:
fd = event->socket_accept.socket;
FD_SET(fd, &self->read_fds);
break;
case IXX_EVENT_SOCKET_READ:
fd = event->socket_read.socket;
FD_SET(fd, &self->read_fds);
break;
case IXX_EVENT_SOCKET_WRITE:
fd = event->socket_write.socket;
FD_SET(fd, &self->write_fds);
break;
default:
break;
}
if (fd > nfd) {
nfd = fd;
}
}
int err;
unsigned long long before_tick = ixx_time_tick();
if (timeout < 0) {
if (0 == nfd) {
ixx_sleep(timeout);
err = IXX_OK;
}
else {
err = select(nfd, &self->read_fds, &self->write_fds, NULL, NULL);
}
}
else {
if (0 == nfd) {
ixx_sleep(timeout);
err = IXX_OK;
}
else {
struct timeval tv;
tv.tv_sec = timeout / 1000;
tv.tv_usec = (timeout % 1000) * 1000;
err = select(nfd, &self->read_fds, &self->write_fds, NULL, &tv);
}
}
unsigned long long after_tick = ixx_time_tick();
IxxEvent* next_event = NULL;
for (IxxEvent* event = self->events.first;
event;
event = next_event)
{
next_event = event->node.next;
event->elapsed = after_tick - event->start_tick;
switch (event->type) {
case IXX_EVENT_UNDEFINED:
break;
case IXX_EVENT_TIMER:
update_timer(event, self);
break;
case IXX_EVENT_THREAD:
break;
case IXX_EVENT_SOCKET_CONNECT:
break;
case IXX_EVENT_SOCKET_ACCEPT:
break;
case IXX_EVENT_SOCKET_READ:
break;
case IXX_EVENT_SOCKET_WRITE:
break;
default:
break;
}
}
}
/* 游戏主循环。
* 在初始化工作结束后，main函数就跳转到主循环执行。
* 在主循环执行期间随时会插入异步的中断。时钟中断最终调用timer_event，
* 键盘中断最终调用keyboard_event。中断处理完成后将返回主循环原位置继续执行。
*
* tick是时钟中断中维护的信号，数值含义是“系统到当前时刻已经发生过的时钟中断数”
* HZ是时钟控制器硬件每秒产生的中断数，在include/device/timer.h中定义
* now是主循环已经正确处理的时钟中断数，即游戏已经处理到的物理时间点
*
* 由于qemu-kvm在访问内存映射IO区域时每次都会产生陷入，在30FPS时，
* 对显存区域每秒会产生30*320*200/4次陷入，从而消耗过多时间导致跳帧的产生(实际FPS<30)。
* 在CFLAGS中增加-DSLOW可以在此情况下提升FPS。如果FPS仍太小，可以尝试
* -DTOOSLOW，此时将会采用隔行扫描的方式更新屏幕(可能会降低显示效果)。
* 这些机制的实现在device/video.c中。
* */
void
maze_loop(void) {
int now = 0, target;
int num_draw = 0;
bool redraw;
Result res = LET;
while ( (res = winOrLose()) == LET) {
wait_for_interrupt();
disable_interrupt();
if (now == tick) {
enable_interrupt();
continue;
}
assert(now < tick);
target = tick; /* now总是小于tick，因此我们需要“追赶”当前的时间 */
enable_interrupt();
redraw = FALSE;
while (update_you())
;
/* 依次模拟已经错过的时钟中断。一次主循环如果执行时间长，期间可能到来多次时钟中断，
* 从而主循环中维护的时钟可能与实际时钟相差较多。为了维持游戏的正常运行，必须补上
* 期间错过的每一帧游戏逻辑。 */
while (now < target) {
/* 每隔一定时间更新屏幕上字符的位置 */
if (now % (HZ / UPDATE_PER_SECOND) == 0) {
update_monster();
}
// update timer every second
if ((now % HZ) == 0) {
update_timer();
}
/* 每隔一定时间需要刷新屏幕。注意到这里实现了“跳帧”的机制：假设
* HZ = 1000, FPS = 100, now = 10, target = 1000
* 即我们要模拟990个时钟中断之间发生的事件，其中包含了9次屏幕更新，
* 但redraw flag只被置一次。 */
if (now % (HZ / FPS) == 0) {
redraw = TRUE;
}
/* 更新fps统计信息 */
if (now % (HZ / 2) == 0) {
int now_fps = num_draw * 2 + 1;
if (now_fps > FPS) now_fps = FPS;
set_mfps(now_fps);
num_draw = 0;
}
now ++;
}
if (redraw) { /* 当需要重新绘图时重绘 */
num_draw ++;
redraw_timerMonsterAndYou();
}
}
draw_end(res);
printk("ending\n");
//release_enter();
}
