Subversion Repositories floppyif

/* Floppy drive data separator and CRC checker simulation in C.

   This C program performs clock/data separation, address mark

   recognition and CRC checking of logic analyzer trace of floppy

   drive read data line.

   Compile: cc -o f f.c

   Run: ./f <example_data.txt >output.txt

*/

/* x^16 + x^12 + x^5 + 1 CRC */

/* Append remainder (contents of fcs) to message: MSB of remainder goes first. */

/* Next time through, remainder will be zero. */

/* fcs is typically initialized to 0xFFFF */

/* Update FCS after one new byte (note that the MSB is taken first even though the LSB is transmitted first) */

unsigned short serial_crc(unsigned short fcs,unsigned char c)

  {

  int i;

  for(i=0;i!=8;++i)

    {

    fcs = ((fcs&0x8000)>>15)^(c>>7) ? (fcs<<1)^0x1021 : (fcs<<1);

    c = (c<<1);

    }

  return fcs;

  }

/* No. samples per bit cell (two bit cells store one data bit in MFM)

 * times 256 */

#define SAMPLE_RATE 5 /* MHz */

#define TIME (SAMPLE_RATE*256)

/* Timer */

int count;

/* Shift register for data and clock bits */

int shift_reg[16];

int shift_count;

int capture;

int lead;

int found=0;

/* Call this for each time step: rd is read data line */

int stepno;

unsigned short fcs;

step(rd)

  {

  ++stepno;

  /* printf("%d\n",rd); */

  /* Leading edge detector */

  if(rd==0 && lead==1)

    {

    /* Move counter toward TIME/2 */

    /* Adjust count */

    if(count>TIME/2)

      /* We're early: retard */

      {

      /* printf("diff=%d\n",count-TIME/2); */

      count -= (count-TIME/2)/2;

      }

    else if(count<TIME/2)

      {

      /* printf("diff=%d\n",TIME/2-count); */

      /* We're late: advance */

      count += (TIME/2-count)/2;

      }

    else

      {

      /* printf("no diff\n"); */

      }

    capture=1;

    }

  lead=rd;

  /* Timer */

  count = count + 256;

  if(count>=TIME)

    {

    int x;

    int clock;

    int data;

    count -= TIME;

    for(x=15;x!=0;--x)

      shift_reg[x] = shift_reg[x-1];

    shift_reg[0] = capture;

    capture = 0;

    shift_count = shift_count + 1;

    clock = (shift_reg[15]<<7) | (shift_reg[13]<<6) | (shift_reg[11]<<5) | (shift_reg[9]<<4) |

            (shift_reg[7]<<3) | (shift_reg[5]<<2) | (shift_reg[3]<<1) | (shift_reg[1]);

    data = (shift_reg[14]<<7) | (shift_reg[12]<<6) | (shift_reg[10]<<5) | (shift_reg[8]<<4) |

           (shift_reg[6]<<3) | (shift_reg[4]<<2) | (shift_reg[2]<<1) | (shift_reg[0]);

    /* Check for address mark */

    if(clock==0x0A && data==0xA1)

      {

      printf("Address mark A1 found\n");

      shift_count=16;

      if(!found)

        {

        /* Initialize CRC */

        /* Ignore next few bytes to prevent successive address marks

           from restarting us again */

        found=4;

        fcs=0xFFFF;

        }

      }

    if(shift_count==16)

      {

      if(found)

        --found;

      fcs = serial_crc(fcs,data);

      printf("clock=%2.2x data=%2.2x crc=%x\n",clock,data,fcs);

      shift_count=0;

      }

    }

  }

main()

  {

  char buf[1024];

  while(gets(buf))

    step(buf[0]=='1');

  }