/*
* take ressources because pthread_cancel do not free the memory allocation
* but we have to cancel the thread because we can stay in accept wait event if we try to use a non blocked socket
*/
void *minstack_tcp_accept_thread(void *ptr) {
minstack_tcp *mt = (minstack_tcp *) ptr;
pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
printdebug("starting %s\n",__FUNCTION__);
while (!mt->pthread_accept_thread_stop) {
int tmp_clisockfd;
unsigned int cli_len;
struct sockaddr_in cli_addr;
memset((char *) &cli_addr, 0, sizeof(cli_addr));
cli_len = sizeof(cli_addr);
#ifdef WIN32
tmp_clisockfd = accept(mt->listen_socket_fd, (struct sockaddr *) &cli_addr,(int *) &cli_len);
#else
tmp_clisockfd = accept(mt->listen_socket_fd, (struct sockaddr *) &cli_addr, &cli_len);
#endif
if (tmp_clisockfd == -1) {
usleep(mt->receive_loop_usleep);
continue;
} else if (tmp_clisockfd <= 0) {
printerror("error :%d\n",tmp_clisockfd);
printmoreerror("ERROR on accept:");
break;
}
pthread_mutex_lock(&mt->mutex);
mt->sockets.client_socket_fd[mt->sockets.connected_client_nb]
= tmp_clisockfd;
mt->sockets.connected_client_nb++;
pthread_mutex_unlock(&mt->mutex);
mt->new_connection_callback(tmp_clisockfd, &cli_addr);
if (mt->pthread_reading_thread_stop && pthread_create(
&mt->pthread_reading_thread, NULL, minstack_tcp_reading_thread,
(void *) mt)) {
printwarning("pthread_create minstack_tcp_accept_thread error\n");
continue;
}
}
//TODO what is this ?!!!
//before was //if (mt->pthread_reading_thread && !mt->pthread_reading_thread) {
if (&mt->pthread_reading_thread && !mt->pthread_reading_thread_stop){
mt->pthread_reading_thread_stop = 1;
pthread_join(mt->pthread_reading_thread, NULL);
printmessage("The reading thread stopped\n");
}
printdebug("stopping %s\n",__FUNCTION__);
pthread_exit(NULL);
return NULL;
}
/**
* \brief Stop the minstack_tcp in parameter
* \param mt the minstack_tcp that have to be stopped
* \return 0 if the minstack_tcp stack stopped correctly
*/
int minstack_tcp_stop(minstack_tcp *mt) {
if (!mt || mt->status == IDLE) {
printerror("Cannot stop while not started\n");
return -1;
}
#ifdef NOT_CANCEL_THREAD_WHEN_STOPPING
if (&mt->pthread_accept_thread && !mt->pthread_accept_thread_stop) {
printdebug("The accepting thread is asked to stop\n");
mt->pthread_accept_thread_stop = 1;
pthread_join(mt->pthread_accept_thread, NULL);
printmessage("The accepting thread stopped\n");
}
if (&mt->pthread_reading_thread && !mt->pthread_reading_thread_stop) {
printdebug("The reading thread is asked to stop\n");
mt->pthread_reading_thread_stop = 1;
pthread_join(mt->pthread_reading_thread, NULL);
printmessage("The reading thread stopped\n");
}
#else
if (&mt->pthread_accept_thread && !mt->pthread_accept_thread_stop) {
printdebug("The accepting thread is asked to stop\n");
mt->pthread_accept_thread_stop = 1;
//Check if & or not after
if(&mt->pthread_accept_thread)
pthread_cancel(mt->pthread_accept_thread);
printmessage("The accepting thread stopped\n");
}
if (&mt->pthread_reading_thread && !mt->pthread_reading_thread_stop) {
printdebug("The reading thread is asked to stop\n");
mt->pthread_reading_thread_stop = 1;
//Check if & or not after
if(&mt->pthread_reading_thread)
pthread_cancel(mt->pthread_reading_thread);
printmessage("The reading thread stopped\n");
}
#endif
if (mt->listen_socket_fd)
minstack_close(mt->listen_socket_fd);
pthread_mutex_destroy(&mt->mutex);
mt->status = IDLE;
printmessage("%s is now stopped\n",mt->name);
return 0;
}
int minstack_tcp_delete_cid(sockets *mt, int cid) {
int i;
for (i = 0; i < mt->connected_client_nb; i++) {
printdebug("%s socket:%d\n",__FUNCTION__,cid);
if (mt->client_socket_fd[i] == cid) {
//we have found the cid
for (; i < (mt->connected_client_nb - 1); i++) {
mt->client_socket_fd[i] = mt->client_socket_fd[i + 1];
}
mt->connected_client_nb--;
return 0;
}
}
return -1;
}
/**
* \brief Uninitialized a minstack_tcp
* \param mt is the minstack_tcp stack
*/
void minstack_tcp_uninit(minstack_tcp *mt) {
if (!mt) {
printwarning("Trying to uninit a NULL minstack_tcp\n");
return;
}
if (mt->status == STARTED) {
minstack_tcp_stop(mt);
printdebug("%s minstack has TCP been stopped before uninit\n",mt->name);
}
printmessage("%s minstack TCP has been uninitialized\n",mt->name);
free(mt);
#ifdef WIN32
win32_uninit_socket_api();
#endif
}
/**
* \brief Boot the minstack_tcp in client mode
* \param mt the minstack_tcp that have to be boot
* \return 0 if the minstack_tcp stack boot correctly
*/
int minstack_tcp_boot_client(minstack_tcp *mt) {
struct sockaddr_in serv_addr;
struct hostent *server;
if (!mt)
return -1;
mt->listen_socket_fd = socket(AF_INET, SOCK_STREAM, 0);
if (mt->listen_socket_fd < 0) {
printmoreerror("ERROR opening socket:");
return -2;
}
server = gethostbyname(mt->address);
if (server == NULL) {
fprintf(stderr, "ERROR, no such host :%s\n",mt->address);
return -3;
}
memset((char *) &serv_addr, 0, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
#ifndef WIN32
bcopy((char *) server->h_addr, (char *) &serv_addr.sin_addr.s_addr,
server->h_length);
#else
memcpy( (char *) &serv_addr.sin_addr.s_addr,(char *) server->h_addr,
server->h_length);
#endif
serv_addr.sin_port = htons(mt->port);
if (connect(mt->listen_socket_fd, (const struct sockaddr *) &serv_addr,
(socklen_t) sizeof(serv_addr)) < 0) {
printmoreerror("ERROR connecting:");
return -4;
}
if (mt->external_read_socket == NULL) {
printdebug("We do not start the reading thread in client mode because no external interpretation is done\n");
mt->pthread_accept_thread_stop = 1;
mt->pthread_reading_thread_stop = 1;
return 0;
}
mt->sockets.client_socket_fd[0] = mt->listen_socket_fd;
mt->sockets.connected_client_nb = 1;
mt->pthread_accept_thread_stop = 1;//because it will not run
if (pthread_create(&mt->pthread_reading_thread, NULL,
minstack_tcp_reading_thread, (void *) mt)) {
printwarning("pthread_create minstack_tcp_accept_thread error\n");
return -5;
}
return 0;
}
/**
* \brief Boot the minstack_tcp in server mode
* \param mt the minstack_tcp that have to be boot
* \return 0 if the minstack_tcp stack boot correctly
*/
int minstack_tcp_boot_server(minstack_tcp *mt) {
struct sockaddr_in serv_addr;
if (!mt)
return -1;
pthread_mutex_lock(&mt->mutex);
mt->listen_socket_fd = socket(AF_INET, SOCK_STREAM, 0);
if (mt->listen_socket_fd < 0) {
printmoreerror("ERROR opening socket:");
return -2;
}
#ifndef WIN32
if (fcntl(mt->listen_socket_fd, F_SETFL, O_NONBLOCK) < 0) {
printmoreerror("Could not O_NONBLOCK:");
return -3;
}
#else
{
u_long imode = 1;
if(ioctlsocket(mt->listen_socket_fd,FIONBIO,&imode) < 0) {
printmoreerror("Could not O_NONBLOCK:");
return -3;
}
}
#endif
memset((char *) &serv_addr, 0, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = INADDR_ANY;
serv_addr.sin_port = htons(mt->port);
if (bind(mt->listen_socket_fd, (const struct sockaddr *) &serv_addr,
(socklen_t) sizeof(serv_addr)) < 0) {
printmoreerror("ERROR connecting");
pthread_mutex_unlock(&mt->mutex);
return -4;
}
listen(mt->listen_socket_fd, (int) mt->max_client_nb);
if (pthread_create(&mt->pthread_accept_thread, NULL, minstack_tcp_accept_thread, mt)) {
printwarning("pthread_create minstack_tcp_boot_server error\n");
pthread_mutex_unlock(&mt->mutex);
return -5;
}
pthread_mutex_unlock(&mt->mutex);
printdebug("%s started.\n",__FUNCTION__);
return 0;
}
char *minstack_tcp_default_read(int cid, unsigned int *buffer_size_returned) {
int retval, finished = 0;
char read_buffer[DEFAULT_READ_BUFFER_SIZE] = { 0 };
unsigned int buffer_size = DEFAULT_READ_BUFFER_SIZE;
char *buffer;
printdebug("There is something that is going to be read\n");
if (!buffer_size_returned) {
printerror("You have to give a pointer to buffer_size_returned\n");
return NULL;
}
buffer = (char *) calloc(1, buffer_size);
if (!buffer) {
printerror("We could not get enough memory to allocate %d octets to read\n",sizeof(read_buffer));
*buffer_size_returned = 0;
return NULL;
}
while (!finished) {
//retval = read(cid,read_buffer,DEFAULT_READ_BUFFER_SIZE);
retval = recv(cid, read_buffer, DEFAULT_READ_BUFFER_SIZE, MSG_DONTWAIT);
printdebug("recv returned %d\n",retval);
if (retval > 0 && retval < DEFAULT_READ_BUFFER_SIZE) {
memcpy(buffer + (buffer_size - DEFAULT_READ_BUFFER_SIZE),
read_buffer, DEFAULT_READ_BUFFER_SIZE);
finished = 1;
} else if (retval == DEFAULT_READ_BUFFER_SIZE) {
char *new_buffer;
memcpy(buffer + (buffer_size - DEFAULT_READ_BUFFER_SIZE),
read_buffer, DEFAULT_READ_BUFFER_SIZE);
new_buffer = (char *) calloc(1, buffer_size
+DEFAULT_READ_BUFFER_SIZE);
if (!new_buffer) {
printmoreerror("we had a problem to read when moving buffers");
free(buffer);
*buffer_size_returned = 0;
return NULL;
}
/*
new_buffer = strncpy(new_buffer,buffer,buffer_size);
char *p_next_char = new_buffer + buffer_size;
strncpy(p_next_char,read_buffer,DEFAULT_READ_BUFFER_SIZE);
*/
memcpy(new_buffer, buffer, buffer_size);
buffer_size += DEFAULT_READ_BUFFER_SIZE;
free(buffer);
buffer = new_buffer;
finished = 0;
} else if (retval < 0) {
//printmoreerror("we had a problem to read");
printdebug("we had a problem to read\n");
free(buffer);
*buffer_size_returned = 0;
return NULL;
} else if (retval == 0) {
//the client just disconnected
if (buffer)
free(buffer);
*buffer_size_returned = -1;
return NULL;
}
}
*buffer_size_returned = buffer_size;
return buffer;
}
void *minstack_tcp_reading_thread(void *ptr) {
minstack_tcp *mt = (minstack_tcp *) ptr;
fd_set fds_read;
int fdmax;
struct timeval tv;
printdebug("starting %s\n",__FUNCTION__);
pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
mt->pthread_reading_thread_stop = 0;
while (!mt->pthread_reading_thread_stop) {
int i, retval, socket_to_read = -1;
fdmax = 0;
tv.tv_sec = 0;
tv.tv_usec = (mt->receive_loop_usleep);
FD_ZERO(&fds_read);
pthread_mutex_lock(&mt->mutex);
if (mt->sockets.connected_client_nb == 0) {
pthread_mutex_unlock(&mt->mutex);
usleep(mt->receive_loop_usleep);
//printdebug("there is no client\n");
#ifdef STOP_READING_THREAD_WITHOUT_CLIENTS
break;
#else
continue;
#endif
}
for (i = 0; i < mt->sockets.connected_client_nb; i++) {
printdebug("Stay socket %d\n",mt->sockets.client_socket_fd[i]);
FD_SETMAX(mt->sockets.client_socket_fd[i],&fds_read,fdmax);
}
fdmax++;
pthread_mutex_unlock(&mt->mutex);
retval = select(fdmax, &fds_read, NULL, NULL, &tv);
pthread_mutex_lock(&mt->mutex);
if (retval == EBADF) {
printmoreerror("Select Bad FD\n");
continue;
}
if (retval < 0) {
printerror("Select: got an error %d\n",retval);
printmoreerror("Select:");
break;
}
if (retval) {
printdebug("there is something to read\n");
for (i = 0; i < mt->sockets.connected_client_nb; i++) {
if (FD_ISSET(mt->sockets.client_socket_fd[i],&fds_read)) {
socket_to_read = mt->sockets.client_socket_fd[i];
}
}
}
if (!retval) {
//printmoreerror("Nothing much from the select\n");
}
pthread_mutex_unlock(&mt->mutex);
if (socket_to_read > 0) {
char from[16];
char *buffer=NULL;
int buffer_size = 0;
pthread_mutex_lock(&mt->mutex);
pthread_mutex_unlock(&mt->mutex);
buffer_size = mt->read_socket(socket_to_read, from,&buffer);
if (buffer_size <= 0) {
pthread_mutex_lock(&mt->mutex);
if (mt && mt->connection_closed_callback
&& (mt->type == SERVER)) {
mt->connection_closed_callback(&mt->sockets, socket_to_read);
minstack_close(socket_to_read);
printdebug("Closing the socket %d\n",socket_to_read);
}
pthread_mutex_unlock(&mt->mutex);
if (mt && (mt->type == CLIENT)) {
printmessage("The server do not exists anymore we will close the connection\n");
minstack_close(socket_to_read);
minstack_tcp_stop(mt);
}
} else {
printmessage("%s received from %s(%d):(%u)=>%s\n",mt->name,from, socket_to_read,buffer_size,buffer);
if (mt->external_read_socket)
mt->external_read_socket(socket_to_read, from, buffer, buffer_size);
//else
free(buffer);
}
}
}
mt->pthread_reading_thread_stop = 1;
printdebug("stopping %s\n",__FUNCTION__);
pthread_exit(NULL);
return NULL;
}
int minstack_tcp_recvfrom_read(int cid, char *from, char **buffer) {
int buffer_size_returned=0;
int retval, finished = 0;
char read_buffer[DEFAULT_READ_BUFFER_SIZE] = { 0 };
unsigned int buffer_size = DEFAULT_READ_BUFFER_SIZE;
struct sockaddr_storage their_addr;
socklen_t addr_len;
printdebug("There is something that is going to be read\n");
if (*buffer != NULL) {
printerror("You have to give a NULL pointer for buffer\n");
return -1;
}
if (from == NULL) {
printerror("You have to give a char tab for from\n");
return -2;
}
*buffer = (char *) calloc(1, buffer_size);
if (!*buffer) {
printerror("We could not get enough memory to allocate %d octets to read\n",sizeof(read_buffer));
buffer_size_returned = 0;
return -4;
}
while (!finished) {
int ret_getpeername=0;
//retval = read(cid,read_buffer,DEFAULT_READ_BUFFER_SIZE);
retval = recv(cid, read_buffer, DEFAULT_READ_BUFFER_SIZE, MSG_DONTWAIT);
printdebug("recv returned %d\n",retval);
addr_len = sizeof(their_addr);
ret_getpeername = getpeername(cid, (struct sockaddr *)&their_addr, &addr_len);
printdebug("getpeername returned %d:%s\n",ret_getpeername,strerror(errno));
if (retval > 0 && retval < DEFAULT_READ_BUFFER_SIZE) {
memcpy(*buffer + (buffer_size - DEFAULT_READ_BUFFER_SIZE),
read_buffer, DEFAULT_READ_BUFFER_SIZE);
finished = 1;
} else if (retval == DEFAULT_READ_BUFFER_SIZE) {
char *new_buffer;
memcpy(*buffer + (buffer_size - DEFAULT_READ_BUFFER_SIZE),
read_buffer, DEFAULT_READ_BUFFER_SIZE);
new_buffer = (char *) calloc(1, buffer_size
+DEFAULT_READ_BUFFER_SIZE);
if (!new_buffer) {
printmoreerror("we had a problem to read when moving buffers");
free(*buffer);
buffer_size_returned = 0;
return -5;
}
/*
new_buffer = strncpy(new_buffer,buffer,buffer_size);
char *p_next_char = new_buffer + buffer_size;
strncpy(p_next_char,read_buffer,DEFAULT_READ_BUFFER_SIZE);
*/
memcpy(new_buffer, *buffer, buffer_size);
buffer_size += DEFAULT_READ_BUFFER_SIZE;
free(*buffer);
*buffer = new_buffer;
finished = 0;
} else if (retval < 0) {
//printmoreerror("we had a problem to read");
printdebug("we had a problem to read\n");
free(*buffer);
buffer_size_returned = 0;
return buffer_size_returned;
} else if (retval == 0) {
//the client just disconnected
if (*buffer)
free(*buffer);
buffer_size_returned = -1;
return buffer_size_returned;
}
if(retval > 0){
snprintf(from,16,"%s",get_in_addr_char(&their_addr));
printdebug("Get datas from %s\n",from);
}
}
buffer_size_returned = buffer_size;
return buffer_size_returned;
}
void bootmain(void)
{
/*进入30os的部分*/
struct boot_info *bootp=(struct boot_info *)ADDR_BOOT;
init_screen((struct boot_info * )bootp);
init_palette(); //color table from 0 to 15
//clear_screen(8); //red
//draw_window();
int mx,my;//mouse position
//display mouse logo
char mousepic[16*16]; //mouse logo buffer
//display_mouse(bootp->vram,bootp->xsize,16,16,mx,my,mousepic,16);
cli();
//set gdt idt
init_gdtidt();
//remap irq 0-15
//函数中： irq 1(keyboard)对应设置中断号int0x21, irq 12(mouse)对应的中断号是int0x2c 要写中断服务程序了。
init_pic();
//设置完了gdt,idt后再enable cpu interrupt才是安全的
unsigned char s[40]; //sprintf buffer
unsigned char keybuf[32]; //keyfifo
unsigned char mousebuf[128]; //mousefifo
unsigned char data; //temp variable to get fifo data
int count=0;
fifo8_init(&keyfifo ,32,keybuf);//keyfifo是一个global data defined in int.c
fifo8_init(&mousefifo,128,mousebuf);
//enable timer ,keyboard and mouse //1111 1000 后面的三个0代表 accept interrupt request, irq0=timer interrupt
outb(PIC0_IMR, 0xf8);//1111 1000 irq 1 2打开 因为keyboard是irq 1,irq2 enable 8259B 芯片发生的中断请求 // enable pic slave and keyboard interrupt
//enable mouse interrupt 1110 1111 irq 12 打开 mouse是irq 12 所以要把pic 1 pic 2的芯片中断响应位打开。
outb(PIC1_IMR, 0xef);
//初始化 鼠标按键控制电路
init_keyboard();
//enable cpu interrupt
unsigned int memtotal;
//get the total memory
memtotal=memtest(0x400000,0xffffffff);
//mem=mem>>20; //convert to MBytes
//sprintf(s,"memory:%dMbytes",mem);
//puts8((char *)bootp->vram ,bootp->xsize,0,100,0,s);
Memman * memman=(Memman *)0x3c0000;
memman_init(memman);
//memman_free(memman,0x1000,0x9e000);
memman_free(memman,0x400000,memtotal-0x400000);
//memman_free(memman,0x600000,0x400000);
//memman_free(memman,0xb00000,0x400000);
char *desktop=(unsigned char*)memman_alloc(memman,320*200);
printdebug(desktop,0);
//while(1);
char *win_buf=(unsigned char*)memman_alloc_4K(memman,160*65);
TIMERCTL *timerctl=(TIMERCTL *)memman_alloc_4K(memman,sizeof(TIMERCTL));
gtimerctl=timerctl;
init_pit(timerctl);//init timerctl
draw_win_buf(desktop);
make_window8(win_buf,160,68,"timer");
init_mouse(mousepic,99); //99 means background color
sprintf(s,"memory:%dMB,free:%dMB,%d",memtotal>>20
,memman_avail(memman)>>20,memman->cellnum);
puts8(desktop ,bootp->xsize,0,150,0,s);
SHTCTL *shtctl;
shtctl=shtctl_init(memman,bootp->vram,bootp->xsize,bootp->ysize);
SHEET *sht_back,*sht_mouse,*sht_win;
//allocate a sheet space from shtctl
sht_back=sheet_alloc(shtctl);
sht_mouse=sheet_alloc(shtctl);
sht_win=sheet_alloc(shtctl);
//write something inside the window
//puts8(win_buf ,160,24,28,0,"hello ,easy os");
//puts8(win_buf ,160,24,44,0,"second line");//y=28+16=44
//hoop the buffer with sheet
sheet_setbuf(sht_back,desktop,320,200,-1);
sheet_setbuf(sht_mouse,mousepic,16,16,99);
sheet_setbuf(sht_win,win_buf,160,65,-1);
mx=0;my=0;//set mouse initial position
sheet_move(sht_back,0,0);
sheet_move(sht_mouse,mx,my);
sheet_move(sht_win,80,72);
//set sht_back to layer0 ;set sht_mouse to layer1
sheet_updown(sht_back,0);
sheet_updown(sht_win,1);
sheet_updown(sht_mouse,2);
//refresh a specific rectangle
sheet_refresh(sht_back,0,0,bootp->xsize,bootp->ysize);
struct FIFO8 timerfifo,timerfifo2,timerfifo3;
char timerbuf[8],timerbuf2[8],timerbuf3[8];
TIMER *timer,*timer2,*timer3;
fifo8_init(&timerfifo,8,timerbuf);
fifo8_init(&timerfifo2,8,timerbuf2);
fifo8_init(&timerfifo3,8,timerbuf3);
timer=timer_alloc(timerctl,0);
timer2=timer_alloc(timerctl,1);
timer3=timer_alloc(timerctl,2);
timer_init(timer,&timerfifo,1);
timer_init(timer2,&timerfifo2,1);
timer_init(timer3,&timerfifo3,1);
//while(1);
timer_settime(timer,1000,timerctl);
timer_settime(timer2,100,timerctl);
timer_settime(timer3,30,timerctl);
sti();
struct MOUSE_DEC mdec;
enable_mouse(&mdec); //这里会产生一个mouse interrupt
while(1)
{
sprintf(s,"%d",timerctl->count);
boxfill8(win_buf,160,8,20,44,140,60);
puts8(win_buf ,160,20,44,0,s);//y=28+16=44
sheet_refresh(sht_win,20,28,140,60);
sti();
if(fifo8_status(&keyfifo) +
fifo8_status(&mousefifo) +
fifo8_status(&timerfifo) +
fifo8_status(&timerfifo2) +
fifo8_status(&timerfifo3)
== 0)//no data in keyfifo and mousefifo
{
//sti();
//hlt();//wait for interrupt
}
else
{
if(fifo8_status(&keyfifo) != 0)
{
data=fifo8_read(&keyfifo);
sti();
}//end of keyboard decoder
else if(fifo8_status(&mousefifo) != 0)//we have mouse interrupt data to process
{
data=fifo8_read(&mousefifo);
sti();
if(mouse_decode(&mdec,data))
{
//3个字节都得到了
switch (mdec.button)
{
case 1:s[1]='L';break;
case 2:s[3]='R';break;
case 4:s[2]='M';break;
}
sprintf(s,"[lmr:%d %d]",mdec.x,mdec.y);
boxfill8(desktop,320,0,32,16,32+15*8-1,33);//一个黑色的小box
puts8(desktop,bootp->xsize,32,16,7,s); //display e0
sheet_refresh(sht_back,32,16,32+20*8-1,31);
#define white 7
//because we use sheet layer ,so we do not need this any more
//boxfill8(p,320,white,mx,my,mx+15,my+15);//用背景色把鼠标原来的color填充，这样不会看到鼠标移动的path
mx +=mdec.x;//mx=mx+dx
my +=mdec.y;//my=my+dy
if(mx<0)
{
mx=0;
}
if(my<0)
{
my=0;
}
if(mx>bootp->xsize-1)
{
mx=bootp->xsize-1;
}
if(my>bootp->ysize-1)
{
my=bootp->ysize-1;
}
sprintf(s,"(%d, %d)",mx,my);
boxfill8(desktop,320,0,0,0,79,15);//坐标的背景色
puts8(desktop ,bootp->xsize,0,0,7,s);//显示坐标
sheet_refresh(sht_back,0,0,bootp->xsize,15);
sheet_move(sht_mouse,mx,my);
}
}//end of mouse decoder
else if(fifo8_status(&timerfifo)!=0)
{
data=fifo8_read(&timerfifo);
sti();
puts8(desktop ,bootp->xsize,0,64,0,"10[sec]");//显示坐标
sheet_refresh(sht_back,0,64,bootp->xsize,80);
//printdebug(99,80);
}//end of timer
else if(fifo8_status(&timerfifo2)!=0)
{
data=fifo8_read(&timerfifo2);
sti();
puts8(desktop ,bootp->xsize,0,80,0,"3[sec]");//显示坐标
sheet_refresh(sht_back,0,80,bootp->xsize,96);
// printdebug(16,150);
// while(1);
}//end of timer2
else if(fifo8_status(&timerfifo3)!=0)//cursor blink
{
data=fifo8_read(&timerfifo3);
sti();
//static unsigned a=0;a++;//因为你没有把里面的数据读走，所以一直会进来
//printdebug(a,0);
if(data!=0)
{
timer_init(timer3,&timerfifo3,0);
boxfill8(desktop,bootp->xsize,7,8,96,15,111);
}
else
{
timer_init(timer3,&timerfifo3,1);
boxfill8(desktop,bootp->xsize,0,8,96,15,111);
}
timer_settime(timer3,50,timerctl);
sheet_refresh(sht_back,8,96,15,111);
sheet_refresh(sht_back,250,100,320,108);
}//end of timer3
}
}
}
