static void pc98_inhibit_repeat(void)
{
    uint8_t code;

    while (serial_recv()) ;
RETRY:
    PC98_RDY_PORT |= (1<<PC98_RDY_BIT);
    _delay_ms(500);
    serial_send(0x9C);

    PC98_RDY_PORT &= ~(1<<PC98_RDY_BIT);
    _delay_ms(100);
    while (!(code = serial_recv())) ;
    print("PC98: send 9C: "); print_hex8(code); print("\n");
    if (code != 0xFA) goto RETRY;



    PC98_RDY_PORT |= (1<<PC98_RDY_BIT);
    _delay_ms(100);
    serial_send(0x70);

    PC98_RDY_PORT &= ~(1<<PC98_RDY_BIT);
    _delay_ms(100);
    //code = serial_recv();
    while (!(code = serial_recv())) ;
    print("PC98: send 70: "); print_hex8(code); print("\n");
    if (code != 0xFA) goto RETRY;
}

/**
 * Output a single char.
 * Note: We allow only to put a char on the last line.
 */
int
out_char(unsigned value)
{
#define BASE(ROW) ((unsigned short *) (0xb8000+ROW*160))
  static unsigned int col;
  if (value!='\n')
    {
      unsigned short *p = BASE(24)+col;
      *p = 0x0f00 | value;
      col++;
    }
  if (col>=80 || value == '\n')
    {
      col=0;
      unsigned short *p=BASE(0);
      memcpy(p, p+80, 24*160);
      memset(BASE(24), 0, 160);
    }


  serial_send(value);

  if (value == '\n')
    serial_send('\r');

  return value;
}

//------------------------------------------------------------------------
// This re-sends an ARP request if there was no response to
// the first one.	 It is called every 0.5 seconds.  If there
// is no response after 2 re-tries, the datagram that IP was 
// trying to send is deleted
//-----------------------------------------------------------------------
void arp_retransmit(void)
{
	static UCHAR idata retries = 0; 
	
	if ((waiting_for_arp) && (wait.timer))
	{
		wait.timer--;
		if (wait.timer == 0)
		{
			retries++;
			if (retries <= 2)
			{
				if (debug) serial_send("ARP: Re-sending ARP broadcast\r");
	 			arp_send(NULL, wait.ipaddr, ARP_REQUEST);
				wait.timer = ARP_TIMEOUT;
			}
			else
			{	
				if (debug) serial_send("ARP: Gave up waiting for response\r");
	 			wait.timer = 0;
				waiting_for_arp = 0;
				free(wait.buf);
			}
		}
	}
}

void main()
{
	uchar buf=0;
	uint i;
	Init_Device();
	serial_init();
//	delay05ms(1);
	buf = EEPROM_ByteRead(0);//读0字节
	serial_send(&buf);	 //串口发送

	EEPROM_ByteWrite(0, 0x64);  //写0字节为100

	buf = 0;//清0
	buf = EEPROM_ByteRead(0); //读0字节
	serial_send(&buf);	  //串口发送0字节
	led = 0;
//	clear_24cXX(32768);
	led = 1;
	for(i=0;i<32768;i++)
	{
		buf = EEPROM_ByteRead(i);//读0字节
		serial_send(&buf);	 //串口发送
	}
	while(1)
	{
		;		
	}
 }

static void send_consumer(uint16_t data)
{
    uint16_t bits = usage2bits(data);
    serial_send(0xFD);  // Raw report mode
    serial_send(3);     // length
    serial_send(3);     // descriptor type
    serial_send(bits&0xFF);
    serial_send((bits>>8)&0xFF);
}

int serial_sendv(int id, void* pdata1, unsigned int size1, void* pdata2, unsigned int size2)
{
  if(serial_send(id, pdata1, size1) != size1)
  {
    return -1;
  }
  if(serial_send(id, pdata2, size2) != size2)
  {
    return -1;
  }
  return 0;
}

static void command_debounce(const char * command)
{
  if ( command[1] == '?' ) 
  {
    char buf[5];
    strcpy(buf, command);  
    setval(buf, board_config->debounce, 1,4);
    serial_send(buf);
  }
  else
  {
    board_config->debounce = getval(command, 1, 4);    
    serial_send(command);
  }  
}

void usart1_isr(void)
{
    unsigned char c;

	/* Check if we were called because of RXNE. */
	if (((USART_CR1(USART1) & USART_CR1_RXNEIE) != 0) &&
        ((USART_SR(USART1) & USART_SR_RXNE) != 0) &&
        (!serial_rb_full(&srx))) {
        c = serial_recv();
        serial_rb_write(&srx, c);
	}
	/* Check if we were called because of TXE. */
	else if (((USART_CR1(USART1) & USART_CR1_TXEIE) != 0) &&
             ((USART_SR(USART1) & USART_SR_TXE) != 0)) {

        if(!serial_rb_empty(&stx)) {
            serial_send(serial_rb_read(&stx));
        }
        else {
            /* Disable the TXE interrupt, it's no longer needed. */
            USART_CR1(USART1) &= ~USART_CR1_TXEIE;
        }
	}
	else {
        c = serial_recv();
	}
}

void matrix_init(void)
{
    DDRD |= (1<<6);
    PORTD |= (1<<6);
    //debug_enable = true;

    serial_init();

    // initialize matrix state: all keys off
    for (uint8_t i=0; i < MATRIX_ROWS; i++) matrix[i] = 0x00;

    // wait for keyboard coming up
    // otherwise LED status update fails
    print("Reseting ");
    while (1) {
        print(".");
        while (serial_recv());
        serial_send(0x01);
        _delay_ms(500);
        if (serial_recv() == 0xFF) {
            _delay_ms(500);
            if (serial_recv() == 0x04)
                break;
        }
    }
    print(" Done\n");
    return;
}

static void em_decode(struct gps_state *gps)
{
    if (packet_idx < 1) return;

#ifndef __arm__
    fprintf(stderr, "receiving %x\n", packet[0]);
#endif

    /* NMEA lines should start with a '$' */
    if (packet[0] == 'E') {
        /* recognize earthmate's 'EARTHA' message */
        if (packet_idx >= 6 && memcmp(packet, "EARTHA", 6) == 0)
            serial_send("EARTHA\r\n", 8);
        return;
    }

    draw_activity(0);

    /* verify checksum XXX */

    switch(INT16(&packet[0])) {
    case 1000: em_1000geodpos(gps); break;
    case 1002: em_1002chsum(gps); break;
    case 1003: em_1003sats(gps); break;
    }
}

void log_message(log_level_e lvl, char *msg) {
  int sent_bytes;
  int msg_len;
  if ((sent_bytes = serial_get_sent_bytes(USB_COMM)) > 0) {
    g_serial_state.bytes_buffered -= sent_bytes;
    if (g_serial_state.bytes_buffered > 0) {
      strncpy(&g_serial_state.serbuf[sent_bytes],
	      &g_serial_state.serbuf[0],
	      g_serial_state.bytes_buffered);
    }
  }

  // at this point everything there will be bytes_buffered
  // bytes sitting at the start of the buffer
  msg_len = strlen(msg);
  if ((msg_len + 2 + g_serial_state.bytes_buffered) > sizeof g_serial_state.serbuf) {
    g_serial_state.bytes_buffered = 0;
  }
  strncpy(&g_serial_state.serbuf[g_serial_state.bytes_buffered],
	  msg,
	  msg_len);
  g_serial_state.serbuf[g_serial_state.bytes_buffered + msg_len] = '\r';
  g_serial_state.serbuf[g_serial_state.bytes_buffered + msg_len + 1] = '\n';
  g_serial_state.bytes_buffered += (msg_len + 2);
  serial_send(USB_COMM, g_serial_state.serbuf, g_serial_state.bytes_buffered);
}

static int fetch_nodelist(struct motefs_node *nodes)
{
    int n, i, k, op, result, res = 0;
    uint8_t buf[MFS_DATA_SIZE];

    serial_lock();

    if (serial_send(0, MFS_OP_NODELIST, NULL, 0))
    {
        res = -EIO;
        goto ret;
    }

    /* the mote should send exactly `node_count` packets */
    for (i = 0; i < node_count; i++)
    {
        res = serial_receive(&n, &op, &result, buf, sizeof buf);
        if (res == -1 || !result || !(op & MFS_OP_NODELIST))
        {
            res = -1;
            goto ret;
        }

        nodes[n].type = result;
        for (k = 0; k < MFS_DATA_SIZE; k++)
            nodes[n].name[k] = buf[k];
    }

ret:
    serial_unlock();
    if (res < 0)
        return -1;
    return 0;
}

static void taip_init(void)
{
    char *cmd;
    
    /* Report position every second */
    cmd = ">FPV00010000<";
    serial_send(cmd, sizeof(cmd));

    /* Report time every 15 seconds */
    cmd = ">FTM00150000<";
    serial_send(cmd, sizeof(cmd));

    /* Get current time */
    cmd = ">QTM<";
    serial_send(cmd, sizeof(cmd));
}

void serial_print_char( const char myChar )
{
	wait_for_sending_to_finish();
	memset( send_buffer, 0, sizeof(send_buffer) );
	send_buffer[0] = myChar;
	serial_send( USB_COMM, send_buffer, 1 );
}

static void show_temperature(int16_t t)
{
	const char *tstring;

	SERIALSTR("t: ");
	serial_send_int(t);
	if (INVALIDTI == t) {
		tstring = "  ???  ";
	} else if (LOWTI == t) {
		tstring = "  ?" "?-  ";
	} else if (MINTI == t) {
		tstring = "  ?--  ";
	} else if (HIGHTI == t) {
		tstring = "  ?" "?+  ";
	} else if (MAXTI == t) {
		tstring = "  ?++  ";
	} else {
		SERIALSTR(":");
		t -= MINTI;	    /* Move the scale up to zero-based. */
		Q_ASSERT( t >= 0 ); /* Range checking. */
		Q_ASSERT( t < NCONVERSIONS );
		t /= 2;		/* Scale to whole degrees. */
		serial_send_int(t);
		tstring = tstrings[t];
	}
	SERIALSTR("\"");
	serial_send(tstring);
	SERIALSTR("\"\r\n");
	lcd_showstring(tstring);
}

void command_parse(uint32_t current_timestamp, const char * command, int len)
{
  if ( len != 5 )
  {
    serial_send_error(3);
    return;
  }
  
  switch (command[0])
  {
  case 'V':
    serial_send("V0100"); 
    break;
  case 'D':
    command_ddr(command);
    break;
  case 'B':
    command_debounce(command);
    break;
  case 'P':
    command_pin(command);    
    break;    
  case 'R':
    command_factory_reset(command);
    break;  
    
  default:
    serial_send_error(4);
    
  }  
}

void print_normal_time(struct NormalTime nt)
{
	char buf[10];

	snprintf(buf, 10, "%02d:%02d:%02d", nt.h, nt.m, nt.s);
	serial_send(buf);
}

void print_usb( char *buffer )
{
    int length;
    length = strlen( buffer );
    serial_send( USB_COMM, buffer, length );
    wait_for_sending_to_finish();
}

static void pc98_send(uint8_t data)
{
    PC98_RDY_PORT |= (1<<PC98_RDY_BIT);
    _delay_ms(1);
    serial_send(data);
    _delay_ms(1);
    PC98_RDY_PORT &= ~(1<<PC98_RDY_BIT);
}

void serial_sendstr(char* str)
{
	while (1)
	{
		switch (*str)
		{
			case '\0':
				return;
			case '\n':
				serial_send('\r');
			default:
				serial_send(*str);
		}
		str++;
	}
	return;
}