order++;
    }
    cf_write('E');
    cf_write('N');
    cf_write('D');
  }
  output_high(BIM_TX);
  ad_on=FALSE;
  purge_adc_buffer();
}

#separate
void send_data_Tim()
{
  unsigned int temp;
  unsigned int bits;
  unsigned int i;
  boolean OldButton, NewButton;
  unsigned int ButtonCount; 
  if (!init_file_write()) return;
  ad_on=TRUE;
  OldButton=Button;
  while (!input(RCIF) && next_file_sector_write()) {
  	ButtonCount=0;
    cf_write('E');
    cf_write('S');
    cf_write('L');
    rtc_read_time();
    cf_write(time[0]);
    cf_write(time[1]);
    cf_write(time[2]);
    cf_write(time[3]);
    cf_write(time[4]);
    cf_write(time[6]);
    for (i=0; i<100; i++) {	  	
      for (temp=0; temp<4; temp++) {
      	do {
      		NewButton=input(BUTTON);
      	  if (!NewButton && OldButton) ButtonCount++;
      	  OldButton=NewButton; 	
        } while (buf_count==0);
        if (buffer[buf_head]>voltage+100) { 
         if (voltage<559) led_green(); else led_red();
        };
        cf_write(buffer[buf_head]);
        bits=(bits<<2)|((buffer[buf_head]>>8)&0x03);
        disable_interrupts(GLOBAL);
        buf_head=(buf_head+1)%buf_size;
        buf_count--;
        enable_interrupts(GLOBAL);
        led_off();
      }
      cf_write(bits);
    }
    cf_write(ButtonCount);
    cf_write(0);
    cf_write(0);
  }
  ad_on=FALSE;
  purge_adc_buffer();
}

#separate
void send_player_info()
{
  unsigned int temp;
  unsigned int bits;
  unsigned long order;
  unsigned int i;
  ad_on=TRUE;
  order=0;
  output_low(BIM_TX);
  while (!input(RCIF)) {
    for (temp=0; temp<5; temp++) putc(0x5A); //total packet length 15 @ 38400; 22 @ 57600
    crc16=0;
    put_crc(0xA5);
    put_crc(order);	
    put_crc(order>>8);	
    for (temp=0; temp<4; temp++) { 	
      while (buf_count==0);
      put_crc(buffer[buf_head]);
      bits=(bits<<2)|((buffer[buf_head]>>8)&0x03);
			//if (temp==1) if (buffer[buf_head]<15) output_low(BIM_TX); else output_high(BIM_TX);
      disable_interrupts(GLOBAL);
      buf_head=(buf_head+1)%buf_size;
      buf_count--;
      enable_interrupts(GLOBAL);
    }
    put_crc(bits);
    putc(crc16);     
    putc(crc16>>8);
    order++;
  }
  output_high(BIM_TX);
  ad_on=FALSE;
  purge_adc_buffer();
}

// Print RTC time
#separate
void print_time()
{
  rtc_read_time();
  printf("%2X/%2X/%2X %2X:%2X:%2X", time[4], time[3], time[6], time[2], time[1], time[0]);
}

// Enable RTC oscillator and counter
#separate
void reset_time()
{
  printf("Time reset");
  rtc_write(7,0);
  rtc_write(0,0);
}

// Print CF information
#separate
void check_cf()
{
  if (!enable_cf()) {
    printf("Invalid disk\n");
  } else {
    printf("Dir 0x%2X%2X%2X%2X\n", dir_start[3], dir_start[2], dir_start[1], dir_start[0]);
    printf("Data sectors 0x%2X%2X%2X%2X\n", data_sectors[3], data_sectors[2], data_sectors[1], data_sectors[0]);
    if (file_valid) {
      printf("File start 0x%2X%2X%2X%2X\n", data_start[3], data_start[2], data_start[1], data_start[0]);
      printf("File size 0x%2X%2X%2X%2X\n", data_file_size[3], data_file_size[2], data_file_size[1], data_file_size[0]);
    } else printf("File not found");
  }  
}

// Set RTC time to 8 bytes received thru serial port
#separate
void set_time()
{
  int i;
  for (i=0; i<8; i++) time[i]=loadc();
  rtc_write(7,0);
  rtc_set_time();
}

// Well...
void print_help()
{
  return;
}

/*
| int fromHex(char hex)
| Preconditions: hex is 1-f
| Postconditions: returned int is 1-16
*/
int fromHex(char hex)
{
	if(hex >= '0' && hex <= '9')
	  return(hex - 48); // 0 --> 0
	
	if(hex >= 'a' && hex <= 'f')
	  return(hex - 87);  // a --> 10
	  
	if(hex >= 'A' && hex <= 'F')
	  return(hex - 55); // A --> 10

  // Still here?  Invalid
	return(20);
	
}

// Issues identify drive command (0xEC) and sends result to serial port
#separate
void identify_drive()
{
  unsigned int cnt;

  while ((cf_task_file_read(7)&0xC0)!=0x40);
  cf_task_file_write(6, 0xA0);   // drive 0
  cf_task_file_write(7, 0xEC);   // identify drive command
  while ((cf_read()&0x80)==0x80);
  cf_set_addr(0);

  for(cnt = 0; cnt < 0xFF; cnt++)
  {
    putc(cf_read());
  }

  for(cnt = 0; cnt < 0xFF; cnt++)
  {
    putc(cf_read());
  }
  putc(cf_read());
  putc(cf_read());
}

// reads sector and sends result to serial port
#separate
void read_sector()
{
  unsigned int cnt;

  sector[0]=loadc();
  sector[1]=loadc();
  sector[2]=loadc();
  sector[3]=loadc();
  cf_start_sector_read();

  for(cnt = 0; cnt < 0xFF; cnt++)
  {
    putc(cf_read());
  }

  for(cnt = 0; cnt < 0xFF; cnt++)
  {
    putc(cf_read());
  }

  putc(cf_read());
  putc(cf_read());
}

// CF debugging:
// read and print CF register
#separate
void read_register() {
  int temp;
  temp=cf_task_file_read(curAddr);
  printf("%d: 0x%2X(%u)\n", curAddr, temp, temp);
}

// CF debugging:
// write CF register
#separate
void write_register() {
  printf("Writing 0x%2X(%u) to addr %u\n", curData, curData, curAddr);
  cf_task_file_write(curAddr, curData);
}

// CF debugging:
// set data to write to CF register
#separate
void set_data() {
  int temp;
  printf("Data (hex): ");
  temp = loadc();
  putc(temp);
  if((temp = fromHex(temp)) > 16) return;
  curData = (temp << 4);
  temp = loadc();
  putc(temp);
  if ((temp = fromHex(temp)) > 16) return;
  curData |= temp;
  printf("\nData 0x%2X(%u)\n", curData, curData);
}

// CF debugging:
// set CF register address
#separate
void set_address() {
  int temp;
  printf("Addr (0-7): ");
  temp=loadc();
  putc(temp);
  temp = fromHex(temp);
  if (temp > 7) return;
  curAddr = temp;
  printf("\nAddr %u\n", curAddr);
}

// Find data file in root directory
// If found returns TRUE and first cluster in global var cluster	
#separate
boolean find_data_file_name() {
  int i, j, k, l;
  boolean match;
  move32(sector, dir_start);
  for (i=0; i<root_entries>>4; i++) {
    cf_start_sector_read();
    for (j=0; j<16; j++) {
      match=true;
      for (k=0; k<11; k++) if (cf_read()!=fname[k]) match=false;
      cf_read_skip(26-11);
      cluster=cf_read()|((long)cf_read()<<8);
      if (match) return true;
      cf_read_skip(32-28);
    }
    inc32(sector); 	
  }
  return false; 
}

// Scan FAT to determine the length of first consecutive cluster chain in the data file
// Returns file chain length (number of clusters) in data_file_size
// Note: Current implementationonly works with consecutive cluster chains; 
//       if file is fragmented only first piece is used 
#separate
void scan_data_file_clusters() { 
  char tmp[4];
  long ptr;
  long c;
  zero32(tmp);
  move32(sector, fat_start);
  tmp[0]=cluster>>8;
  add32(sector, tmp);
  cf_start_sector_read();
  ptr=cluster&0xFF00;
  while (ptr++<cluster) cf_read_skip(2);
  zero32(data_file_size);
  do {
    c=cf_read()|((long)cf_read()<<8);
    inc32(data_file_size);
    if (ptr!=c) return;
    if (!(ptr&0xFF)) {
      inc32(sector);
      cf_start_sector_read();
    }
    ptr++;
  } while (true); 	
}

// Finds data file and determines its length
#separate
boolean find_data_file() { // Find the data file
  if (!find_data_file_name()) return false;
  scan_data_file_clusters();
  return true;
}

#separate
boolean get_disk_configuration() {
// Loads and verifies file system parameters
// Returns 
// TRUE if CF card has correct file system and data file           
// FALSE if something is not quite right
//	
// File system requirements:
// - Valid Master Boot Record
// - First partition formatted with FAT16
// - Data file with predetermined name on consecutive clusters 
// get_disk_configuration() checks file system records and 
// attempts to find the data file.
//
// To create file on CF card use PC program CF.EXE
  int tmp; // Yeah! This is an integer variable called tmp 
// Start with sector 0 -- Master Boot Record	
  zero32(sector);
  cf_start_sector_read();
// Skip to partition table and get partition 1 info  
  cf_read_skip(0);
  cf_read_skip(0xC2);
  tmp=cf_read(); // disk_system_id -- type of partition
  if (!((tmp==1)||(tmp==4)||(tmp==6)||(tmp==14))) return FALSE; // 1-FAT12, 2-FAT16, 6-BIGFAT16, 14-BIGFATLB  
// Load start sector number of partition 1 
  cf_read_skip(3);  
  sector[0]=cf_read();
  sector[1]=cf_read();
  sector[2]=cf_read();
  sector[3]=cf_read();
// Read Boot Record (start sector) of Partition 1  
  cf_start_sector_read();
  cf_read_skip(0x0B);
// Bytes/sector must be 0x200 (512)  
  if (cf_read()!=0) return FALSE;
  if (cf_read()!=2) return FALSE;
// And now let's do sectors_per_cluster=cf_read(). Ok?  
  sectors_per_cluster=cf_read();
// FAT (file allocation table) start  
  zero32(fat_start);
  fat_start[0]=cf_read();	
  fat_start[1]=cf_read();	
  add32(fat_start, sector);
// I get depressed when number of FATs is not 2  
  if (cf_read()!=2) return FALSE;
// Get number of entries in the root directory  
  *(&root_entries)=cf_read();
  *(&root_entries+1)=cf_read();
// Well. Reading number of data sectors.
  zero32(data_sectors);
  data_sectors[0]=cf_read();
  data_sectors[1]=cf_read();
  cf_read_skip(1);
// Where is root directory?  
  zero32(dir_start);
  dir_start[0]=cf_read();	
  dir_start[1]=cf_read();	
  add32(dir_start, dir_start);
  add32(dir_start, fat_start);
// Where are data clusters?  
  zero32(data_start);
  *data_start=root_entries>>4;
  add32(data_start, dir_start);
  if (is_zero32(data_sectors)) { 
  // If data_sectors is 0 we got it in a wrong place
    cf_read_skip(0x20-0x18);
    data_sectors[0]=cf_read();
    data_sectors[1]=cf_read();
    data_sectors[2]=cf_read();
    data_sectors[3]=cf_read();
    cf_read_skip(0x3A-0x24);
  } else cf_read_skip(0x3A-0x18);
  if (cf_read()!=0x36) return FALSE; // file system id must be FAT16
  sub32(data_sectors, data_start);
  add32(data_sectors, sector);
// Enable Microdrive write cache... Send me e-mail for more information  
  enable_microdrive_write_cache();
// File is valid if we can find valid file.  
  file_valid=find_data_file();  
  cf_idle(100);
  if (file_valid) { 
    // convert data file size from clusters to sectors
    // Note: sectors per cluster must be power of 2	
    tmp=sectors_per_cluster;
    while (!(tmp&1)) {
      shift_left(data_file_size,4,0);
      tmp>>=1;
    }
    // calculate first sector of data file
    zero32(sector);
    sector[0]=(cluster-2);
    sector[1]=(cluster-2)>>8;
    tmp=sectors_per_cluster;
    while (!(tmp&1)) {
      shift_left(sector,4,0);
      tmp>>=1;
    }
    // and now data_start points to first sector of data file
    add32(data_start, sector);
    return true;
  } else {
    // File not found: let's get idle and depressed	
    return false;
  } 
}

// Tests IR tag reader from Borg lab 
#separate
void tag_test()
{
  char tag[4];
  long tagtime;
  putI2C(0xA0, 2);
  I2C_start();
  I2C_write(0xA0 | I2CREAD);
  tag[0]=i2c_read();
  tag[1]=i2c_read();
  tag[2]=i2c_read();
  tag[3]=i2c_read();
  tagtime=i2c_read();
  tagtime=tagtime<<8|i2c_read();
  i2c_read(0);
  I2C_stop();
  printf("%2X%2X%2X%2X ", tag[0], tag[1], tag[2], tag[3]); 
  putI2C(0xA0, 3);
  I2C_start();
  I2C_write(0xA0 | I2CREAD);
  tag[0]=i2c_read();
  tag[1]=i2c_read();
  tag[2]=i2c_read();
  tag[3]=i2c_read();
  tagtime=i2c_read();
  tagtime=tagtime<<8|i2c_read();
  i2c_read(0);
  I2C_stop();
  printf("%2X%2X%2X%2X\n", tag[0], tag[1], tag[2], tag[3]); 
}

// reads ADC channel and sends result
#separate
void send_adc_sample(int channel)
{
  long sample;
  set_adc_channel(channel);
  sample=read_adc();
  putc(sample);
  putc(sample>>8);
}

// I2C command processor
// ib - I2C start
// ie - I2C stop
// ir - I2C read with ACK
// i0 - I2C read without ACK
// iw - I2C write
// ip - I2C poll
#separate
void access_i2c()
{
  switch (loadc()) {
    case 'b': i2c_start(); break;
    case 'e': i2c_stop(); break;
    case 'r': putc(i2c_read()); break;
    case '0': putc(i2c_read(0)); break;
    case 'w': i2c_write(loadc()); break;
    case 'p': putc(i2c_poll()); break;
  }
}

#separate
void read_mithril_sensor()
{
  byte addr;
  addr=loadc();
  putI2C(addr, loadc());
  I2C_start();
  I2C_write(addr | I2CREAD);
  putc(i2c_read());
  putc(i2c_read());
  putc(i2c_read());
  putc(i2c_read(0));
  I2C_stop();
}

// Command processor
#separate
boolean process_command()
{
  if (!input(RCIF)) return FALSE;
  cmd = loadc();

  /* Echo the character */
  if ((cmd>='0')&&(cmd<='7')) {
    send_adc_sample(cmd-'0');
  } else
  if (cmd=='i') access_i2c(); else
  if (cmd=='m') read_mithril_sensor();
  else {
    putc(cmd);
    puts("");
    switch (cmd) {
      case 0xA5: reprogram(); break;
      case '+': print_time(); break;
      case '-': reset_time(); break;
      case '=': check_cf(); break;
      case '*': identify_drive(); break;
      case '$': read_sector(); break;
      case '@': cf_idle(100); break;
      case '.': cf_sleep(); break;
      case ',': cf_standby(); break;
      case 't': set_time(); break;
      case '(': putc(rtc_read(loadc())); break;
      case '!': cf_reset(); break;
      case 'd': set_data(); break;
      case 'a': set_address(); break;
      case 'r': read_register(); break;
      case 'w': write_register(); break;
      #ifdef Rochester
      case '?': tag_test(); break;
      #endif
      case '#':
        #ifdef GAME
        send_player_info();
        #endif
        #ifdef Rochester
        save_audio();
        #endif
        #ifdef ESL
        send_data_bim();
        #endif
        #ifdef Tim
        send_data_Tim();
        #endif
        break;
    }
    print_prompt();
  }  
  return TRUE;
}