Merge branch 'master' of https://github.com/Proxmark/proxmark3
authoriceman1001 <iceman@iuse.se>
Thu, 8 Jan 2015 21:23:45 +0000 (22:23 +0100)
committericeman1001 <iceman@iuse.se>
Thu, 8 Jan 2015 21:23:45 +0000 (22:23 +0100)
Conflicts:
armsrc/lfops.c
client/cmddata.c
client/graph.c

1  2 
armsrc/lfops.c
client/cmddata.c
client/cmdlfem4x.c
client/graph.c

diff --cc armsrc/lfops.c
index fe2a7121ad857663d7b35e715195188411b34268,b9dbb8e27cdc386692cd58ad8923ae3d64d93f38..f5040850c50cd2b1f93dfdf979bdbd74b463cfe2
  */
  void DoAcquisition125k_internal(int trigger_threshold,bool silent)
  {
 -      uint8_t *dest = (uint8_t *)BigBuf;
 -      int n = sizeof(BigBuf);
 -      int i;
 -
 -      memset(dest, 0, n);
 -      i = 0;
 -      for(;;) {
 -              if (AT91C_BASE_SSC->SSC_SR & AT91C_SSC_TXRDY) {
 -                      AT91C_BASE_SSC->SSC_THR = 0x43;
 -                      LED_D_ON();
 -              }
 -              if (AT91C_BASE_SSC->SSC_SR & AT91C_SSC_RXRDY) {
 -                      dest[i] = (uint8_t)AT91C_BASE_SSC->SSC_RHR;
 -                      LED_D_OFF();
 -                      if (trigger_threshold != -1 && dest[i] < trigger_threshold)
 -                              continue;
 -                      else
 -                              trigger_threshold = -1;
 -                      if (++i >= n) break;
 -              }
 -      }
 -      if(!silent)
 -      {
 -              Dbprintf("buffer samples: %02x %02x %02x %02x %02x %02x %02x %02x ...",
 -                  dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
 -
 -      }
 +    uint8_t *dest = (uint8_t *)BigBuf;
 +    int n = sizeof(BigBuf);
 +    int i;
 +
 +    memset(dest, 0, n);
 +    i = 0;
 +    for(;;) {
 +        if (AT91C_BASE_SSC->SSC_SR & AT91C_SSC_TXRDY) {
 +            AT91C_BASE_SSC->SSC_THR = 0x43;
 +            LED_D_ON();
 +        }
 +        if (AT91C_BASE_SSC->SSC_SR & AT91C_SSC_RXRDY) {
 +            dest[i] = (uint8_t)AT91C_BASE_SSC->SSC_RHR;
 +            LED_D_OFF();
 +            if (trigger_threshold != -1 && dest[i] < trigger_threshold)
 +                continue;
 +            else
 +                trigger_threshold = -1;
 +            if (++i >= n) break;
 +        }
 +    }
 +    if(!silent)
 +    {
 +        Dbprintf("buffer samples: %02x %02x %02x %02x %02x %02x %02x %02x ...",
 +                 dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
 +
 +    }
  }
  /**
- * Perform sample aquisition. 
+ * Perform sample aquisition.
  */
  void DoAcquisition125k(int trigger_threshold)
  {
  **/
  void LFSetupFPGAForADC(int divisor, bool lf_field)
  {
 -      FpgaDownloadAndGo(FPGA_BITSTREAM_LF);
 -      if ( (divisor == 1) || (divisor < 0) || (divisor > 255) )
 -              FpgaSendCommand(FPGA_CMD_SET_DIVISOR, 88); //134.8Khz
 -      else if (divisor == 0)
 -              FpgaSendCommand(FPGA_CMD_SET_DIVISOR, 95); //125Khz
 -      else
 -              FpgaSendCommand(FPGA_CMD_SET_DIVISOR, divisor);
 -
 -      FpgaWriteConfWord(FPGA_MAJOR_MODE_LF_ADC | (lf_field ? FPGA_LF_ADC_READER_FIELD : 0));
 -
 -      // Connect the A/D to the peak-detected low-frequency path.
 -      SetAdcMuxFor(GPIO_MUXSEL_LOPKD);
 -      // Give it a bit of time for the resonant antenna to settle.
 -      SpinDelay(50);
 -      // Now set up the SSC to get the ADC samples that are now streaming at us.
 -      FpgaSetupSsc();
 +    FpgaDownloadAndGo(FPGA_BITSTREAM_LF);
 +    if ( (divisor == 1) || (divisor < 0) || (divisor > 255) )
 +        FpgaSendCommand(FPGA_CMD_SET_DIVISOR, 88); //134.8Khz
 +    else if (divisor == 0)
 +        FpgaSendCommand(FPGA_CMD_SET_DIVISOR, 95); //125Khz
 +    else
 +        FpgaSendCommand(FPGA_CMD_SET_DIVISOR, divisor);
 +
 +    FpgaWriteConfWord(FPGA_MAJOR_MODE_LF_ADC | (lf_field ? FPGA_LF_ADC_READER_FIELD : 0));
 +
 +    // Connect the A/D to the peak-detected low-frequency path.
 +    SetAdcMuxFor(GPIO_MUXSEL_LOPKD);
 +    // Give it a bit of time for the resonant antenna to settle.
 +    SpinDelay(50);
 +    // Now set up the SSC to get the ADC samples that are now streaming at us.
 +    FpgaSetupSsc();
  }
  /**
- * Initializes the FPGA, and acquires the samples. 
+ * Initializes the FPGA, and acquires the samples.
  **/
  void AcquireRawAdcSamples125k(int divisor)
  {
 -      LFSetupFPGAForADC(divisor, true);
 -      // Now call the acquisition routine
 -      DoAcquisition125k_internal(-1,false);
 +    LFSetupFPGAForADC(divisor, true);
 +    // Now call the acquisition routine
 +    DoAcquisition125k_internal(-1,false);
  }
  /**
- * Initializes the FPGA for snoop-mode, and acquires the samples. 
+ * Initializes the FPGA for snoop-mode, and acquires the samples.
  **/
  
  void SnoopLFRawAdcSamples(int divisor, int trigger_threshold)
@@@ -169,133 -169,132 +169,132 @@@ void ModThenAcquireRawAdcSamples125k(in
  */
  void ReadTItag(void)
  {
 -      // some hardcoded initial params
 -      // when we read a TI tag we sample the zerocross line at 2Mhz
 -      // TI tags modulate a 1 as 16 cycles of 123.2Khz
 -      // TI tags modulate a 0 as 16 cycles of 134.2Khz
 +    // some hardcoded initial params
 +    // when we read a TI tag we sample the zerocross line at 2Mhz
 +    // TI tags modulate a 1 as 16 cycles of 123.2Khz
 +    // TI tags modulate a 0 as 16 cycles of 134.2Khz
- #define FSAMPLE 2000000
- #define FREQLO 123200
- #define FREQHI 134200
 #define FSAMPLE 2000000
 #define FREQLO 123200
 #define FREQHI 134200
  
 -      signed char *dest = (signed char *)BigBuf;
 -      int n = sizeof(BigBuf);
 -      // 128 bit shift register [shift3:shift2:shift1:shift0]
 -      uint32_t shift3 = 0, shift2 = 0, shift1 = 0, shift0 = 0;
 -
 -      int i, cycles=0, samples=0;
 -      // how many sample points fit in 16 cycles of each frequency
 -      uint32_t sampleslo = (FSAMPLE<<4)/FREQLO, sampleshi = (FSAMPLE<<4)/FREQHI;
 -      // when to tell if we're close enough to one freq or another
 -      uint32_t threshold = (sampleslo - sampleshi + 1)>>1;
 -
 -      // TI tags charge at 134.2Khz
 -      FpgaDownloadAndGo(FPGA_BITSTREAM_LF);
 -      FpgaSendCommand(FPGA_CMD_SET_DIVISOR, 88); //134.8Khz
 -
 -      // Place FPGA in passthrough mode, in this mode the CROSS_LO line
 -      // connects to SSP_DIN and the SSP_DOUT logic level controls
 -      // whether we're modulating the antenna (high)
 -      // or listening to the antenna (low)
 -      FpgaWriteConfWord(FPGA_MAJOR_MODE_LF_PASSTHRU);
 -
 -      // get TI tag data into the buffer
 -      AcquireTiType();
 -
 -      FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
 -
 -      for (i=0; i<n-1; i++) {
 -              // count cycles by looking for lo to hi zero crossings
 -              if ( (dest[i]<0) && (dest[i+1]>0) ) {
 -                      cycles++;
 -                      // after 16 cycles, measure the frequency
 -                      if (cycles>15) {
 -                              cycles=0;
 -                              samples=i-samples; // number of samples in these 16 cycles
 -
 -                              // TI bits are coming to us lsb first so shift them
 -                              // right through our 128 bit right shift register
 -                              shift0 = (shift0>>1) | (shift1 << 31);
 -                              shift1 = (shift1>>1) | (shift2 << 31);
 -                              shift2 = (shift2>>1) | (shift3 << 31);
 -                              shift3 >>= 1;
 -
 -                              // check if the cycles fall close to the number
 -                              // expected for either the low or high frequency
 -                              if ( (samples>(sampleslo-threshold)) && (samples<(sampleslo+threshold)) ) {
 -                                      // low frequency represents a 1
 -                                      shift3 |= (1<<31);
 -                              } else if ( (samples>(sampleshi-threshold)) && (samples<(sampleshi+threshold)) ) {
 -                                      // high frequency represents a 0
 -                              } else {
 -                                      // probably detected a gay waveform or noise
 -                                      // use this as gaydar or discard shift register and start again
 -                                      shift3 = shift2 = shift1 = shift0 = 0;
 -                              }
 -                              samples = i;
 -
 -                              // for each bit we receive, test if we've detected a valid tag
 -
 -                              // if we see 17 zeroes followed by 6 ones, we might have a tag
 -                              // remember the bits are backwards
 -                              if ( ((shift0 & 0x7fffff) == 0x7e0000) ) {
 -                                      // if start and end bytes match, we have a tag so break out of the loop
 -                                      if ( ((shift0>>16)&0xff) == ((shift3>>8)&0xff) ) {
 -                                              cycles = 0xF0B; //use this as a flag (ugly but whatever)
 -                                              break;
 -                                      }
 -                              }
 -                      }
 -              }
 -      }
 -
 -      // if flag is set we have a tag
 -      if (cycles!=0xF0B) {
 -              DbpString("Info: No valid tag detected.");
 -      } else {
 -              // put 64 bit data into shift1 and shift0
 -              shift0 = (shift0>>24) | (shift1 << 8);
 -              shift1 = (shift1>>24) | (shift2 << 8);
 -
 -              // align 16 bit crc into lower half of shift2
 -              shift2 = ((shift2>>24) | (shift3 << 8)) & 0x0ffff;
 -
 -              // if r/w tag, check ident match
 +    signed char *dest = (signed char *)BigBuf;
 +    int n = sizeof(BigBuf);
 +    // 128 bit shift register [shift3:shift2:shift1:shift0]
 +    uint32_t shift3 = 0, shift2 = 0, shift1 = 0, shift0 = 0;
 +
 +    int i, cycles=0, samples=0;
 +    // how many sample points fit in 16 cycles of each frequency
 +    uint32_t sampleslo = (FSAMPLE<<4)/FREQLO, sampleshi = (FSAMPLE<<4)/FREQHI;
 +    // when to tell if we're close enough to one freq or another
 +    uint32_t threshold = (sampleslo - sampleshi + 1)>>1;
 +
 +    // TI tags charge at 134.2Khz
 +    FpgaDownloadAndGo(FPGA_BITSTREAM_LF);
 +    FpgaSendCommand(FPGA_CMD_SET_DIVISOR, 88); //134.8Khz
 +
 +    // Place FPGA in passthrough mode, in this mode the CROSS_LO line
 +    // connects to SSP_DIN and the SSP_DOUT logic level controls
 +    // whether we're modulating the antenna (high)
 +    // or listening to the antenna (low)
 +    FpgaWriteConfWord(FPGA_MAJOR_MODE_LF_PASSTHRU);
 +
 +    // get TI tag data into the buffer
 +    AcquireTiType();
 +
 +    FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
 +
 +    for (i=0; i<n-1; i++) {
 +        // count cycles by looking for lo to hi zero crossings
 +        if ( (dest[i]<0) && (dest[i+1]>0) ) {
 +            cycles++;
 +            // after 16 cycles, measure the frequency
 +            if (cycles>15) {
 +                cycles=0;
 +                samples=i-samples; // number of samples in these 16 cycles
 +
 +                // TI bits are coming to us lsb first so shift them
 +                // right through our 128 bit right shift register
 +                shift0 = (shift0>>1) | (shift1 << 31);
 +                shift1 = (shift1>>1) | (shift2 << 31);
 +                shift2 = (shift2>>1) | (shift3 << 31);
 +                shift3 >>= 1;
 +
 +                // check if the cycles fall close to the number
 +                // expected for either the low or high frequency
 +                if ( (samples>(sampleslo-threshold)) && (samples<(sampleslo+threshold)) ) {
 +                    // low frequency represents a 1
 +                    shift3 |= (1<<31);
 +                } else if ( (samples>(sampleshi-threshold)) && (samples<(sampleshi+threshold)) ) {
 +                    // high frequency represents a 0
 +                } else {
 +                    // probably detected a gay waveform or noise
 +                    // use this as gaydar or discard shift register and start again
 +                    shift3 = shift2 = shift1 = shift0 = 0;
 +                }
 +                samples = i;
 +
 +                // for each bit we receive, test if we've detected a valid tag
 +
 +                // if we see 17 zeroes followed by 6 ones, we might have a tag
 +                // remember the bits are backwards
 +                if ( ((shift0 & 0x7fffff) == 0x7e0000) ) {
 +                    // if start and end bytes match, we have a tag so break out of the loop
 +                    if ( ((shift0>>16)&0xff) == ((shift3>>8)&0xff) ) {
 +                        cycles = 0xF0B; //use this as a flag (ugly but whatever)
 +                        break;
 +                    }
 +                }
 +            }
 +        }
 +    }
 +
 +    // if flag is set we have a tag
 +    if (cycles!=0xF0B) {
 +        DbpString("Info: No valid tag detected.");
 +    } else {
 +        // put 64 bit data into shift1 and shift0
 +        shift0 = (shift0>>24) | (shift1 << 8);
 +        shift1 = (shift1>>24) | (shift2 << 8);
 +
 +        // align 16 bit crc into lower half of shift2
 +        shift2 = ((shift2>>24) | (shift3 << 8)) & 0x0ffff;
 +
 +        // if r/w tag, check ident match
-         if ( shift3&(1<<15) ) {
+               if (shift3 & (1<<15) ) {
 -                      DbpString("Info: TI tag is rewriteable");
 -                      // only 15 bits compare, last bit of ident is not valid
 +            DbpString("Info: TI tag is rewriteable");
 +            // only 15 bits compare, last bit of ident is not valid
-             if ( ((shift3>>16)^shift0)&0x7fff ) {
+                       if (((shift3 >> 16) ^ shift0) & 0x7fff ) {
 -                              DbpString("Error: Ident mismatch!");
 -                      } else {
 -                              DbpString("Info: TI tag ident is valid");
 -                      }
 -              } else {
 -                      DbpString("Info: TI tag is readonly");
 -              }
 -
 -              // WARNING the order of the bytes in which we calc crc below needs checking
 -              // i'm 99% sure the crc algorithm is correct, but it may need to eat the
 -              // bytes in reverse or something
 -              // calculate CRC
 -              uint32_t crc=0;
 -
 -              crc = update_crc16(crc, (shift0)&0xff);
 -              crc = update_crc16(crc, (shift0>>8)&0xff);
 -              crc = update_crc16(crc, (shift0>>16)&0xff);
 -              crc = update_crc16(crc, (shift0>>24)&0xff);
 -              crc = update_crc16(crc, (shift1)&0xff);
 -              crc = update_crc16(crc, (shift1>>8)&0xff);
 -              crc = update_crc16(crc, (shift1>>16)&0xff);
 -              crc = update_crc16(crc, (shift1>>24)&0xff);
 -
 -              Dbprintf("Info: Tag data: %x%08x, crc=%x",
 -                  (unsigned int)shift1, (unsigned int)shift0, (unsigned int)shift2 & 0xFFFF);
 -              if (crc != (shift2&0xffff)) {
 -                      Dbprintf("Error: CRC mismatch, expected %x", (unsigned int)crc);
 -              } else {
 -                      DbpString("Info: CRC is good");
 -              }
 -      }
 +                DbpString("Error: Ident mismatch!");
 +            } else {
 +                DbpString("Info: TI tag ident is valid");
 +            }
 +        } else {
 +            DbpString("Info: TI tag is readonly");
 +        }
 +
 +        // WARNING the order of the bytes in which we calc crc below needs checking
 +        // i'm 99% sure the crc algorithm is correct, but it may need to eat the
 +        // bytes in reverse or something
 +        // calculate CRC
 +        uint32_t crc=0;
 +
 +        crc = update_crc16(crc, (shift0)&0xff);
 +        crc = update_crc16(crc, (shift0>>8)&0xff);
 +        crc = update_crc16(crc, (shift0>>16)&0xff);
 +        crc = update_crc16(crc, (shift0>>24)&0xff);
 +        crc = update_crc16(crc, (shift1)&0xff);
 +        crc = update_crc16(crc, (shift1>>8)&0xff);
 +        crc = update_crc16(crc, (shift1>>16)&0xff);
 +        crc = update_crc16(crc, (shift1>>24)&0xff);
 +
 +        Dbprintf("Info: Tag data: %x%08x, crc=%x",
 +                 (unsigned int)shift1, (unsigned int)shift0, (unsigned int)shift2 & 0xFFFF);
 +        if (crc != (shift2&0xffff)) {
 +            Dbprintf("Error: CRC mismatch, expected %x", (unsigned int)crc);
 +        } else {
 +            DbpString("Info: CRC is good");
 +        }
 +    }
  }
  
  void WriteTIbyte(uint8_t b)
  
  void AcquireTiType(void)
  {
 -      int i, j, n;
 -      // tag transmission is <20ms, sampling at 2M gives us 40K samples max
 -      // each sample is 1 bit stuffed into a uint32_t so we need 1250 uint32_t
 +    int i, j, n;
 +    // tag transmission is <20ms, sampling at 2M gives us 40K samples max
 +    // each sample is 1 bit stuffed into a uint32_t so we need 1250 uint32_t
- #define TIBUFLEN 1250
 #define TIBUFLEN 1250
  
 -      // clear buffer
 -      memset(BigBuf,0,sizeof(BigBuf));
 -
 -      // Set up the synchronous serial port
 -      AT91C_BASE_PIOA->PIO_PDR = GPIO_SSC_DIN;
 -      AT91C_BASE_PIOA->PIO_ASR = GPIO_SSC_DIN;
 -
 -      // steal this pin from the SSP and use it to control the modulation
 -      AT91C_BASE_PIOA->PIO_PER = GPIO_SSC_DOUT;
 -      AT91C_BASE_PIOA->PIO_OER = GPIO_SSC_DOUT;
 -
 -      AT91C_BASE_SSC->SSC_CR = AT91C_SSC_SWRST;
 -      AT91C_BASE_SSC->SSC_CR = AT91C_SSC_RXEN | AT91C_SSC_TXEN;
 -
 -      // Sample at 2 Mbit/s, so TI tags are 16.2 vs. 14.9 clocks long
 -      // 48/2 = 24 MHz clock must be divided by 12
 -      AT91C_BASE_SSC->SSC_CMR = 12;
 -
 -      AT91C_BASE_SSC->SSC_RCMR = SSC_CLOCK_MODE_SELECT(0);
 -      AT91C_BASE_SSC->SSC_RFMR = SSC_FRAME_MODE_BITS_IN_WORD(32) | AT91C_SSC_MSBF;
 -      AT91C_BASE_SSC->SSC_TCMR = 0;
 -      AT91C_BASE_SSC->SSC_TFMR = 0;
 -
 -      LED_D_ON();
 -
 -      // modulate antenna
 -      HIGH(GPIO_SSC_DOUT);
 -
 -      // Charge TI tag for 50ms.
 -      SpinDelay(50);
 -
 -      // stop modulating antenna and listen
 -      LOW(GPIO_SSC_DOUT);
 -
 -      LED_D_OFF();
 -
 -      i = 0;
 -      for(;;) {
 -              if(AT91C_BASE_SSC->SSC_SR & AT91C_SSC_RXRDY) {
 -                      BigBuf[i] = AT91C_BASE_SSC->SSC_RHR;    // store 32 bit values in buffer
 -                      i++; if(i >= TIBUFLEN) break;
 -              }
 -              WDT_HIT();
 -      }
 -
 -      // return stolen pin to SSP
 -      AT91C_BASE_PIOA->PIO_PDR = GPIO_SSC_DOUT;
 -      AT91C_BASE_PIOA->PIO_ASR = GPIO_SSC_DIN | GPIO_SSC_DOUT;
 -
 -      char *dest = (char *)BigBuf;
 -      n = TIBUFLEN*32;
 -      // unpack buffer
 -      for (i=TIBUFLEN-1; i>=0; i--) {
 -              for (j=0; j<32; j++) {
 -                      if(BigBuf[i] & (1 << j)) {
 -                              dest[--n] = 1;
 -                      } else {
 -                              dest[--n] = -1;
 -                      }
 -              }
 -      }
 +    // clear buffer
 +    memset(BigBuf,0,sizeof(BigBuf));
 +
 +    // Set up the synchronous serial port
 +    AT91C_BASE_PIOA->PIO_PDR = GPIO_SSC_DIN;
 +    AT91C_BASE_PIOA->PIO_ASR = GPIO_SSC_DIN;
 +
 +    // steal this pin from the SSP and use it to control the modulation
 +    AT91C_BASE_PIOA->PIO_PER = GPIO_SSC_DOUT;
 +    AT91C_BASE_PIOA->PIO_OER = GPIO_SSC_DOUT;
 +
 +    AT91C_BASE_SSC->SSC_CR = AT91C_SSC_SWRST;
 +    AT91C_BASE_SSC->SSC_CR = AT91C_SSC_RXEN | AT91C_SSC_TXEN;
 +
 +    // Sample at 2 Mbit/s, so TI tags are 16.2 vs. 14.9 clocks long
 +    // 48/2 = 24 MHz clock must be divided by 12
 +    AT91C_BASE_SSC->SSC_CMR = 12;
 +
 +    AT91C_BASE_SSC->SSC_RCMR = SSC_CLOCK_MODE_SELECT(0);
 +    AT91C_BASE_SSC->SSC_RFMR = SSC_FRAME_MODE_BITS_IN_WORD(32) | AT91C_SSC_MSBF;
 +    AT91C_BASE_SSC->SSC_TCMR = 0;
 +    AT91C_BASE_SSC->SSC_TFMR = 0;
 +
 +    LED_D_ON();
 +
 +    // modulate antenna
 +    HIGH(GPIO_SSC_DOUT);
 +
 +    // Charge TI tag for 50ms.
 +    SpinDelay(50);
 +
 +    // stop modulating antenna and listen
 +    LOW(GPIO_SSC_DOUT);
 +
 +    LED_D_OFF();
 +
 +    i = 0;
 +    for(;;) {
 +        if(AT91C_BASE_SSC->SSC_SR & AT91C_SSC_RXRDY) {
 +            BigBuf[i] = AT91C_BASE_SSC->SSC_RHR;      // store 32 bit values in buffer
 +            i++; if(i >= TIBUFLEN) break;
 +        }
 +        WDT_HIT();
 +    }
 +
 +    // return stolen pin to SSP
 +    AT91C_BASE_PIOA->PIO_PDR = GPIO_SSC_DOUT;
 +    AT91C_BASE_PIOA->PIO_ASR = GPIO_SSC_DIN | GPIO_SSC_DOUT;
 +
 +    char *dest = (char *)BigBuf;
 +    n = TIBUFLEN*32;
 +    // unpack buffer
 +    for (i=TIBUFLEN-1; i>=0; i--) {
 +        for (j=0; j<32; j++) {
 +            if(BigBuf[i] & (1 << j)) {
 +                dest[--n] = 1;
 +            } else {
 +                dest[--n] = -1;
 +            }
 +        }
 +    }
  }
  
  // arguments: 64bit data split into 32bit idhi:idlo and optional 16bit crc
@@@ -467,58 -466,58 +466,58 @@@ void WriteTItag(uint32_t idhi, uint32_
  
  void SimulateTagLowFrequency(int period, int gap, int ledcontrol)
  {
 -      int i;
 -      uint8_t *tab = (uint8_t *)BigBuf;
 +    int i;
 +    uint8_t *tab = (uint8_t *)BigBuf;
-     
 -      FpgaDownloadAndGo(FPGA_BITSTREAM_LF);
 -      FpgaWriteConfWord(FPGA_MAJOR_MODE_LF_EDGE_DETECT);
 +    FpgaDownloadAndGo(FPGA_BITSTREAM_LF);
 +    FpgaWriteConfWord(FPGA_MAJOR_MODE_LF_EDGE_DETECT);
-     
 -      AT91C_BASE_PIOA->PIO_PER = GPIO_SSC_DOUT | GPIO_SSC_CLK;
 +    AT91C_BASE_PIOA->PIO_PER = GPIO_SSC_DOUT | GPIO_SSC_CLK;
-     
 -      AT91C_BASE_PIOA->PIO_OER = GPIO_SSC_DOUT;
 -      AT91C_BASE_PIOA->PIO_ODR = GPIO_SSC_CLK;
 +    AT91C_BASE_PIOA->PIO_OER = GPIO_SSC_DOUT;
 +    AT91C_BASE_PIOA->PIO_ODR = GPIO_SSC_CLK;
-     
  #define SHORT_COIL()  LOW(GPIO_SSC_DOUT)
  #define OPEN_COIL()           HIGH(GPIO_SSC_DOUT)
-     
 -      i = 0;
 -      for(;;) {
 -              while(!(AT91C_BASE_PIOA->PIO_PDSR & GPIO_SSC_CLK)) {
 -                      if(BUTTON_PRESS()) {
 -                              DbpString("Stopped");
 -                              return;
 -                      }
 -                      WDT_HIT();
 -              }
 -
 -              if (ledcontrol)
 -                      LED_D_ON();
 -
 -              if(tab[i])
 -                      OPEN_COIL();
 -              else
 -                      SHORT_COIL();
 -
 -              if (ledcontrol)
 -                      LED_D_OFF();
 -
 -              while(AT91C_BASE_PIOA->PIO_PDSR & GPIO_SSC_CLK) {
 -                      if(BUTTON_PRESS()) {
 -                              DbpString("Stopped");
 -                              return;
 -                      }
 -                      WDT_HIT();
 -              }
 -
 -              i++;
 -              if(i == period) {
 -                      i = 0;
 -                      if (gap) {
 -                              SHORT_COIL();
 -                              SpinDelayUs(gap);
 -                      }
 -              }
 -      }
 +    i = 0;
 +    for(;;) {
 +        while(!(AT91C_BASE_PIOA->PIO_PDSR & GPIO_SSC_CLK)) {
 +            if(BUTTON_PRESS()) {
 +                DbpString("Stopped");
 +                return;
 +            }
 +            WDT_HIT();
 +        }
-         
++
 +        if (ledcontrol)
 +            LED_D_ON();
-         
++
 +        if(tab[i])
 +            OPEN_COIL();
 +        else
 +            SHORT_COIL();
-         
++
 +        if (ledcontrol)
 +            LED_D_OFF();
-         
++
 +        while(AT91C_BASE_PIOA->PIO_PDSR & GPIO_SSC_CLK) {
 +            if(BUTTON_PRESS()) {
 +                DbpString("Stopped");
 +                return;
 +            }
 +            WDT_HIT();
 +        }
-         
++
 +        i++;
 +        if(i == period) {
 +            i = 0;
 +            if (gap) {
 +                SHORT_COIL();
 +                SpinDelayUs(gap);
 +            }
 +        }
 +    }
  }
  
  #define DEBUG_FRAME_CONTENTS 1
@@@ -577,146 -576,145 +576,145 @@@ static void fc(int c, int *n) 
  // simulate a HID tag until the button is pressed
  void CmdHIDsimTAG(int hi, int lo, int ledcontrol)
  {
 -      int n=0, i=0;
 -      /*
 -       HID tag bitstream format
 -       The tag contains a 44bit unique code. This is sent out MSB first in sets of 4 bits
 -       A 1 bit is represented as 6 fc8 and 5 fc10 patterns
 -       A 0 bit is represented as 5 fc10 and 6 fc8 patterns
 -       A fc8 is inserted before every 4 bits
 -       A special start of frame pattern is used consisting a0b0 where a and b are neither 0
 -       nor 1 bits, they are special patterns (a = set of 12 fc8 and b = set of 10 fc10)
 -      */
 -
 -      if (hi>0xFFF) {
 -              DbpString("Tags can only have 44 bits.");
 -              return;
 -      }
 -      fc(0,&n);
 -      // special start of frame marker containing invalid bit sequences
 -      fc(8,  &n);     fc(8,  &n);     // invalid
 -      fc(8,  &n);     fc(10, &n); // logical 0
 -      fc(10, &n);     fc(10, &n); // invalid
 -      fc(8,  &n);     fc(10, &n); // logical 0
 -
 -      WDT_HIT();
 -      // manchester encode bits 43 to 32
 -      for (i=11; i>=0; i--) {
 -              if ((i%4)==3) fc(0,&n);
 -              if ((hi>>i)&1) {
 -                      fc(10, &n);     fc(8,  &n);             // low-high transition
 -              } else {
 -                      fc(8,  &n);     fc(10, &n);             // high-low transition
 -              }
 -      }
 -
 -      WDT_HIT();
 -      // manchester encode bits 31 to 0
 -      for (i=31; i>=0; i--) {
 -              if ((i%4)==3) fc(0,&n);
 -              if ((lo>>i)&1) {
 -                      fc(10, &n);     fc(8,  &n);             // low-high transition
 -              } else {
 -                      fc(8,  &n);     fc(10, &n);             // high-low transition
 -              }
 -      }
 -
 -      if (ledcontrol)
 -              LED_A_ON();
 -      SimulateTagLowFrequency(n, 0, ledcontrol);
 -
 -      if (ledcontrol)
 -              LED_A_OFF();
 +    int n=0, i=0;
 +    /*
 +     HID tag bitstream format
 +     The tag contains a 44bit unique code. This is sent out MSB first in sets of 4 bits
 +     A 1 bit is represented as 6 fc8 and 5 fc10 patterns
 +     A 0 bit is represented as 5 fc10 and 6 fc8 patterns
 +     A fc8 is inserted before every 4 bits
 +     A special start of frame pattern is used consisting a0b0 where a and b are neither 0
 +     nor 1 bits, they are special patterns (a = set of 12 fc8 and b = set of 10 fc10)
 +    */
 +
 +    if (hi>0xFFF) {
 +        DbpString("Tags can only have 44 bits.");
 +        return;
 +    }
 +    fc(0,&n);
 +    // special start of frame marker containing invalid bit sequences
 +    fc(8,  &n);       fc(8,  &n);     // invalid
 +    fc(8,  &n);       fc(10, &n); // logical 0
 +    fc(10, &n);       fc(10, &n); // invalid
 +    fc(8,  &n);       fc(10, &n); // logical 0
 +
 +    WDT_HIT();
 +    // manchester encode bits 43 to 32
 +    for (i=11; i>=0; i--) {
 +        if ((i%4)==3) fc(0,&n);
 +        if ((hi>>i)&1) {
 +            fc(10, &n);       fc(8,  &n);             // low-high transition
 +        } else {
 +            fc(8,  &n);       fc(10, &n);             // high-low transition
 +        }
 +    }
 +
 +    WDT_HIT();
 +    // manchester encode bits 31 to 0
 +    for (i=31; i>=0; i--) {
 +        if ((i%4)==3) fc(0,&n);
 +        if ((lo>>i)&1) {
 +            fc(10, &n);       fc(8,  &n);             // low-high transition
 +        } else {
 +            fc(8,  &n);       fc(10, &n);             // high-low transition
 +        }
 +    }
 +
 +    if (ledcontrol)
 +        LED_A_ON();
-       
 +    SimulateTagLowFrequency(n, 0, ledcontrol);
 +
 +    if (ledcontrol)
 +        LED_A_OFF();
  }
  
  // loop to get raw HID waveform then FSK demodulate the TAG ID from it
  void CmdHIDdemodFSK(int findone, int *high, int *low, int ledcontrol)
  {
 -      uint8_t *dest = (uint8_t *)BigBuf;
 +    uint8_t *dest = (uint8_t *)BigBuf;
  
 -      size_t size=0; //, found=0;
 -      uint32_t hi2=0, hi=0, lo=0;
 +    size_t size=0; //, found=0;
 +    uint32_t hi2=0, hi=0, lo=0;
  
 -      // Configure to go in 125Khz listen mode
 -      LFSetupFPGAForADC(95, true);
 +    // Configure to go in 125Khz listen mode
 +    LFSetupFPGAForADC(95, true);
  
 -      while(!BUTTON_PRESS()) {
 +    while(!BUTTON_PRESS()) {
  
 -              WDT_HIT();
 -              if (ledcontrol) LED_A_ON();
 +        WDT_HIT();
 +        if (ledcontrol) LED_A_ON();
  
 -              DoAcquisition125k_internal(-1,true);
 -              // FSK demodulator
 +        DoAcquisition125k_internal(-1,true);
 +        // FSK demodulator
                size = HIDdemodFSK(dest, sizeof(BigBuf), &hi2, &hi, &lo);
  
 -              WDT_HIT();
 +        WDT_HIT();
  
                if (size>0 && lo>0){
 -                      // final loop, go over previously decoded manchester data and decode into usable tag ID
 -                      // 111000 bit pattern represent start of frame, 01 pattern represents a 1 and 10 represents a 0
 -                      if (hi2 != 0){ //extra large HID tags
 -                              Dbprintf("TAG ID: %x%08x%08x (%d)",
 -                                  (unsigned int) hi2, (unsigned int) hi, (unsigned int) lo, (unsigned int) (lo>>1) & 0xFFFF);
 -                      }else {  //standard HID tags <38 bits
 -                              //Dbprintf("TAG ID: %x%08x (%d)",(unsigned int) hi, (unsigned int) lo, (unsigned int) (lo>>1) & 0xFFFF); //old print cmd
 -                              uint8_t bitlen = 0;
 -                              uint32_t fc = 0;
 -                              uint32_t cardnum = 0;
 +            // final loop, go over previously decoded manchester data and decode into usable tag ID
 +            // 111000 bit pattern represent start of frame, 01 pattern represents a 1 and 10 represents a 0
 +            if (hi2 != 0){ //extra large HID tags
 +                Dbprintf("TAG ID: %x%08x%08x (%d)",
 +                         (unsigned int) hi2, (unsigned int) hi, (unsigned int) lo, (unsigned int) (lo>>1) & 0xFFFF);
 +            }else {  //standard HID tags <38 bits
 +                //Dbprintf("TAG ID: %x%08x (%d)",(unsigned int) hi, (unsigned int) lo, (unsigned int) (lo>>1) & 0xFFFF); //old print cmd
 +                uint8_t bitlen = 0;
 +                uint32_t fc = 0;
 +                uint32_t cardnum = 0;
-                 if (((hi>>5)&1)==1){//if bit 38 is set then < 37 bit format is used
+                               if (((hi>>5)&1) == 1){//if bit 38 is set then < 37 bit format is used
 -                                      uint32_t lo2=0;
 -                                      lo2=(((hi & 31) << 12) | (lo>>20)); //get bits 21-37 to check for format len bit
 -                                      uint8_t idx3 = 1;
 +                    uint32_t lo2=0;
 +                    lo2=(((hi & 31) << 12) | (lo>>20)); //get bits 21-37 to check for format len bit
 +                    uint8_t idx3 = 1;
-                     while(lo2>1){ //find last bit set to 1 (format len bit)
-                         lo2=lo2>>1;
+                                       while(lo2 > 1){ //find last bit set to 1 (format len bit)
+                                               lo2=lo2 >> 1;
 -                                              idx3++;
 -                                      }
 +                        idx3++;
 +                    }
-                     bitlen =idx3+19;
+                                       bitlen = idx3+19;
 -                                      fc =0;
 -                                      cardnum=0;
 +                    fc =0;
 +                    cardnum=0;
-                     if(bitlen==26){
+                                       if(bitlen == 26){
 -                                              cardnum = (lo>>1)&0xFFFF;
 -                                              fc = (lo>>17)&0xFF;
 -                                      }
 +                        cardnum = (lo>>1)&0xFFFF;
 +                        fc = (lo>>17)&0xFF;
 +                    }
-                     if(bitlen==37){
+                                       if(bitlen == 37){
 -                                              cardnum = (lo>>1)&0x7FFFF;
 -                                              fc = ((hi&0xF)<<12)|(lo>>20);
 -                                      }
 +                        cardnum = (lo>>1)&0x7FFFF;
 +                        fc = ((hi&0xF)<<12)|(lo>>20);
 +                    }
-                     if(bitlen==34){
+                                       if(bitlen == 34){
 -                                              cardnum = (lo>>1)&0xFFFF;
 -                                              fc= ((hi&1)<<15)|(lo>>17);
 -                                      }
 +                        cardnum = (lo>>1)&0xFFFF;
 +                        fc= ((hi&1)<<15)|(lo>>17);
 +                    }
-                     if(bitlen==35){
+                                       if(bitlen == 35){
 -                                              cardnum = (lo>>1)&0xFFFFF;
 -                                              fc = ((hi&1)<<11)|(lo>>21);
 -                                      }
 -                              }
 -                              else { //if bit 38 is not set then 37 bit format is used
 -                                      bitlen= 37;
 -                                      fc =0;
 -                                      cardnum=0;
 -                                      if(bitlen==37){
 -                                              cardnum = (lo>>1)&0x7FFFF;
 -                                              fc = ((hi&0xF)<<12)|(lo>>20);
 -                                      }
 -                              }
 -                              //Dbprintf("TAG ID: %x%08x (%d)",
 -                              // (unsigned int) hi, (unsigned int) lo, (unsigned int) (lo>>1) & 0xFFFF);
 -                              Dbprintf("TAG ID: %x%08x (%d) - Format Len: %dbit - FC: %d - Card: %d",
 -                                  (unsigned int) hi, (unsigned int) lo, (unsigned int) (lo>>1) & 0xFFFF,
 -                                  (unsigned int) bitlen, (unsigned int) fc, (unsigned int) cardnum);
 -                      }
 -                      if (findone){
 -                              if (ledcontrol) LED_A_OFF();
 -                              return;
 -                      }
 -                      // reset
 -                      hi2 = hi = lo = 0;
 -              }
 -              WDT_HIT();
 -      }
 -      DbpString("Stopped");
 -      if (ledcontrol) LED_A_OFF();
 +                        cardnum = (lo>>1)&0xFFFFF;
 +                        fc = ((hi&1)<<11)|(lo>>21);
 +                    }
 +                }
 +                else { //if bit 38 is not set then 37 bit format is used
 +                    bitlen= 37;
 +                    fc =0;
 +                    cardnum=0;
 +                    if(bitlen==37){
 +                        cardnum = (lo>>1)&0x7FFFF;
 +                        fc = ((hi&0xF)<<12)|(lo>>20);
 +                    }
 +                }
 +                //Dbprintf("TAG ID: %x%08x (%d)",
 +                // (unsigned int) hi, (unsigned int) lo, (unsigned int) (lo>>1) & 0xFFFF);
 +                Dbprintf("TAG ID: %x%08x (%d) - Format Len: %dbit - FC: %d - Card: %d",
 +                         (unsigned int) hi, (unsigned int) lo, (unsigned int) (lo>>1) & 0xFFFF,
 +                         (unsigned int) bitlen, (unsigned int) fc, (unsigned int) cardnum);
 +            }
 +            if (findone){
 +                if (ledcontrol)       LED_A_OFF();
 +                return;
 +            }
 +            // reset
 +            hi2 = hi = lo = 0;
 +        }
 +        WDT_HIT();
 +    }
 +    DbpString("Stopped");
 +    if (ledcontrol) LED_A_OFF();
  }
  
  void CmdEM410xdemod(int findone, int *high, int *low, int ledcontrol)
@@@ -1200,22 -1198,22 +1198,22 @@@ void CopyHIDtoT55x7(uint32_t hi2, uint3
  
  void CopyIOtoT55x7(uint32_t hi, uint32_t lo, uint8_t longFMT)
  {
 -      int data1=0, data2=0; //up to six blocks for long format
 +    int data1=0, data2=0; //up to six blocks for long format
  
 -      data1 = hi;  // load preamble
 -      data2 = lo;
 +    data1 = hi;  // load preamble
 +    data2 = lo;
-     
 -      LED_D_ON();
 -      // Program the data blocks for supplied ID
 -      // and the block 0 for HID format
 -      T55xxWriteBlock(data1,1,0,0);
 -      T55xxWriteBlock(data2,2,0,0);
 +    LED_D_ON();
 +    // Program the data blocks for supplied ID
 +    // and the block 0 for HID format
 +    T55xxWriteBlock(data1,1,0,0);
 +    T55xxWriteBlock(data2,2,0,0);
  
 -      //Config Block
 -      T55xxWriteBlock(0x00147040,0,0,0);
 -      LED_D_OFF();
 +    //Config Block
 +    T55xxWriteBlock(0x00147040,0,0,0);
 +    LED_D_OFF();
  
 -      DbpString("DONE!");
 +    DbpString("DONE!");
  }
  
  // Define 9bit header for EM410x tags
@@@ -1331,41 -1329,45 +1329,45 @@@ void WriteEM410x(uint32_t card, uint32_
  // Clone Indala 64-bit tag by UID to T55x7
  void CopyIndala64toT55x7(int hi, int lo)
  {
 -      //Program the 2 data blocks for supplied 64bit UID
 -      // and the block 0 for Indala64 format
 -      T55xxWriteBlock(hi,1,0,0);
 -      T55xxWriteBlock(lo,2,0,0);
 -      //Config for Indala (RF/32;PSK1 with RF/2;Maxblock=2)
 -      T55xxWriteBlock(T55x7_BITRATE_RF_32    |
 -          T55x7_MODULATION_PSK1 |
 -          2 << T55x7_MAXBLOCK_SHIFT,
 -          0, 0, 0);
 -      //Alternative config for Indala (Extended mode;RF/32;PSK1 with RF/2;Maxblock=2;Inverse data)
 -      //      T5567WriteBlock(0x603E1042,0);
 +    //Program the 2 data blocks for supplied 64bit UID
 +    // and the block 0 for Indala64 format
 +    T55xxWriteBlock(hi,1,0,0);
 +    T55xxWriteBlock(lo,2,0,0);
 +    //Config for Indala (RF/32;PSK1 with RF/2;Maxblock=2)
 +    T55xxWriteBlock(T55x7_BITRATE_RF_32    |
 +                    T55x7_MODULATION_PSK1 |
 +                    2 << T55x7_MAXBLOCK_SHIFT,
 +                    0, 0, 0);
 +    //Alternative config for Indala (Extended mode;RF/32;PSK1 with RF/2;Maxblock=2;Inverse data)
 +    //        T5567WriteBlock(0x603E1042,0);
  
 -      DbpString("DONE!");
 +    DbpString("DONE!");
- }     
+ }
  
  void CopyIndala224toT55x7(int uid1, int uid2, int uid3, int uid4, int uid5, int uid6, int uid7)
  {
 -      //Program the 7 data blocks for supplied 224bit UID
 -      // and the block 0 for Indala224 format
 -      T55xxWriteBlock(uid1,1,0,0);
 -      T55xxWriteBlock(uid2,2,0,0);
 -      T55xxWriteBlock(uid3,3,0,0);
 -      T55xxWriteBlock(uid4,4,0,0);
 -      T55xxWriteBlock(uid5,5,0,0);
 -      T55xxWriteBlock(uid6,6,0,0);
 -      T55xxWriteBlock(uid7,7,0,0);
 -      //Config for Indala (RF/32;PSK1 with RF/2;Maxblock=7)
 -      T55xxWriteBlock(T55x7_BITRATE_RF_32    |
 -          T55x7_MODULATION_PSK1 |
 -          7 << T55x7_MAXBLOCK_SHIFT,
 -          0,0,0);
 -      //Alternative config for Indala (Extended mode;RF/32;PSK1 with RF/2;Maxblock=7;Inverse data)
 -      //      T5567WriteBlock(0x603E10E2,0);
 -
 -      DbpString("DONE!");
 +    //Program the 7 data blocks for supplied 224bit UID
 +    // and the block 0 for Indala224 format
 +    T55xxWriteBlock(uid1,1,0,0);
 +    T55xxWriteBlock(uid2,2,0,0);
 +    T55xxWriteBlock(uid3,3,0,0);
 +    T55xxWriteBlock(uid4,4,0,0);
 +    T55xxWriteBlock(uid5,5,0,0);
 +    T55xxWriteBlock(uid6,6,0,0);
 +    T55xxWriteBlock(uid7,7,0,0);
 +    //Config for Indala (RF/32;PSK1 with RF/2;Maxblock=7)
 +    T55xxWriteBlock(T55x7_BITRATE_RF_32    |
 +                    T55x7_MODULATION_PSK1 |
 +                    7 << T55x7_MAXBLOCK_SHIFT,
 +                    0,0,0);
 +    //Alternative config for Indala (Extended mode;RF/32;PSK1 with RF/2;Maxblock=7;Inverse data)
 +    //        T5567WriteBlock(0x603E10E2,0);
 +
 +    DbpString("DONE!");
  }
  
  
index d05f3fa1572e95b16e797b049d93630a858f90d5,53a3ce5f410e1d17a5e3e2cbc51b06210e7e873d..6bc66f06a7cb43ed2c28b92bd210e00dbd95e678
  #include "cmdmain.h"
  #include "cmddata.h"
  #include "lfdemod.h"
+ uint8_t DemodBuffer[MAX_DEMOD_BUF_LEN];
+ int DemodBufferLen;
  static int CmdHelp(const char *Cmd);
  
+ //set the demod buffer with given array of binary (one bit per byte)
+ //by marshmellow
+ void setDemodBuf(uint8_t *buff,int size)
+ {
+       int i=0;
+       for (; i < size; ++i){
+               DemodBuffer[i]=buff[i];
+       }
+       DemodBufferLen=size;
+       return;
+ }
+ //by marshmellow
+ void printDemodBuff()
+ {
+       uint32_t i = 0;
+       int bitLen = DemodBufferLen;
+       if (bitLen<16) {
+               PrintAndLog("no bits found in demod buffer");
+               return;
+       }
+       if (bitLen>512) bitLen=512; //max output to 512 bits if we have more - should be plenty
+       for (i = 0; i <= (bitLen-16); i+=16) {
+               PrintAndLog("%i%i%i%i%i%i%i%i%i%i%i%i%i%i%i%i",
+                       DemodBuffer[i],
+                       DemodBuffer[i+1],
+                       DemodBuffer[i+2],
+                       DemodBuffer[i+3],
+                       DemodBuffer[i+4],
+                       DemodBuffer[i+5],
+                       DemodBuffer[i+6],
+                       DemodBuffer[i+7],
+                       DemodBuffer[i+8],
+                       DemodBuffer[i+9],
+                       DemodBuffer[i+10],
+                       DemodBuffer[i+11],
+                       DemodBuffer[i+12],
+                       DemodBuffer[i+13],
+                       DemodBuffer[i+14],
+                       DemodBuffer[i+15]);
+       }
+       return;
+ }
  int CmdAmp(const char *Cmd)
  {
 -      int i, rising, falling;
 -      int max = INT_MIN, min = INT_MAX;
 -
 -      for (i = 10; i < GraphTraceLen; ++i) {
 -              if (GraphBuffer[i] > max)
 -                      max = GraphBuffer[i];
 -              if (GraphBuffer[i] < min)
 -                      min = GraphBuffer[i];
 -      }
 -
 -      if (max != min) {
 -              rising = falling= 0;
 -              for (i = 0; i < GraphTraceLen; ++i) {
 -                      if (GraphBuffer[i + 1] < GraphBuffer[i]) {
 -                              if (rising) {
 -                                      GraphBuffer[i] = max;
 -                                      rising = 0;
 -                              }
 -                              falling = 1;
 -                      }
 -                      if (GraphBuffer[i + 1] > GraphBuffer[i]) {
 -                              if (falling) {
 -                                      GraphBuffer[i] = min;
 -                                      falling = 0;
 -                              }
 -                              rising= 1;
 -                      }
 -              }
 -      }
 -      RepaintGraphWindow();
 -      return 0;
 +  int i, rising, falling;
 +  int max = INT_MIN, min = INT_MAX;
 +
 +  for (i = 10; i < GraphTraceLen; ++i) {
 +    if (GraphBuffer[i] > max)
 +      max = GraphBuffer[i];
 +    if (GraphBuffer[i] < min)
 +      min = GraphBuffer[i];
 +  }
 +
 +  if (max != min) {
 +    rising = falling= 0;
 +    for (i = 0; i < GraphTraceLen; ++i) {
 +      if (GraphBuffer[i + 1] < GraphBuffer[i]) {
 +        if (rising) {
 +          GraphBuffer[i] = max;
 +          rising = 0;
 +        }
 +        falling = 1;
 +      }
 +      if (GraphBuffer[i + 1] > GraphBuffer[i]) {
 +        if (falling) {
 +          GraphBuffer[i] = min;
 +          falling = 0;
 +        }
 +        rising= 1;
 +      }
 +    }
 +  }
 +  RepaintGraphWindow();
 +  return 0;
  }
  
  /*
   //this method is dependant on all highs and lows to be the same(or clipped)  this creates issues[marshmellow] it also ignores the clock
  int Cmdaskdemod(const char *Cmd)
  {
 -      int i;
 -      int c, high = 0, low = 0;
 +  int i;
 +  int c, high = 0, low = 0;
  
 -      // TODO: complain if we do not give 2 arguments here !
 -      // (AL - this doesn't make sense! we're only using one argument!!!)
 -      sscanf(Cmd, "%i", &c);
 +  // TODO: complain if we do not give 2 arguments here !
 +  // (AL - this doesn't make sense! we're only using one argument!!!)
 +  sscanf(Cmd, "%i", &c);
  
 -      /* Detect high and lows and clock */
 +  /* Detect high and lows and clock */
-   // (AL - clock???) 
+       // (AL - clock???)
 -      for (i = 0; i < GraphTraceLen; ++i)
 -      {
 -              if (GraphBuffer[i] > high)
 -                      high = GraphBuffer[i];
 -              else if (GraphBuffer[i] < low)
 -                      low = GraphBuffer[i];
 -      }
 -      high=abs(high*.75);
 -      low=abs(low*.75);
 -      if (c != 0 && c != 1) {
 -              PrintAndLog("Invalid argument: %s", Cmd);
 -              return 0;
 -      }
 -      //prime loop
 -      if (GraphBuffer[0] > 0) {
 -              GraphBuffer[0] = 1-c;
 -      } else {
 -              GraphBuffer[0] = c;
 -      }
 -      for (i = 1; i < GraphTraceLen; ++i) {
 -              /* Transitions are detected at each peak
 -               * Transitions are either:
 -               * - we're low: transition if we hit a high
 -               * - we're high: transition if we hit a low
 -               * (we need to do it this way because some tags keep high or
 -               * low for long periods, others just reach the peak and go
 -               * down)
 -               */
 -              //[marhsmellow] change == to >= for high and <= for low for fuzz
 -              if ((GraphBuffer[i] == high) && (GraphBuffer[i - 1] == c)) {
 -                      GraphBuffer[i] = 1 - c;
 -              } else if ((GraphBuffer[i] == low) && (GraphBuffer[i - 1] == (1 - c))){
 -                      GraphBuffer[i] = c;
 -              } else {
 -                      /* No transition */
 -                      GraphBuffer[i] = GraphBuffer[i - 1];
 -              }
 -      }
 -      RepaintGraphWindow();
 -      return 0;
 +  for (i = 0; i < GraphTraceLen; ++i)
 +  {
 +    if (GraphBuffer[i] > high)
 +      high = GraphBuffer[i];
 +    else if (GraphBuffer[i] < low)
 +      low = GraphBuffer[i];
 +  }
 +  high=abs(high*.75);
 +  low=abs(low*.75);
 +  if (c != 0 && c != 1) {
 +    PrintAndLog("Invalid argument: %s", Cmd);
 +    return 0;
 +  }
 +  //prime loop
 +  if (GraphBuffer[0] > 0) {
 +    GraphBuffer[0] = 1-c;
 +  } else {
 +    GraphBuffer[0] = c;
 +  }
 +  for (i = 1; i < GraphTraceLen; ++i) {
 +    /* Transitions are detected at each peak
 +     * Transitions are either:
 +     * - we're low: transition if we hit a high
 +     * - we're high: transition if we hit a low
 +     * (we need to do it this way because some tags keep high or
 +     * low for long periods, others just reach the peak and go
 +     * down)
 +     */
 +    //[marhsmellow] change == to >= for high and <= for low for fuzz
 +    if ((GraphBuffer[i] == high) && (GraphBuffer[i - 1] == c)) {
 +      GraphBuffer[i] = 1 - c;
 +    } else if ((GraphBuffer[i] == low) && (GraphBuffer[i - 1] == (1 - c))){
 +      GraphBuffer[i] = c;
 +    } else {
 +      /* No transition */
 +      GraphBuffer[i] = GraphBuffer[i - 1];
 +    }
 +  }
 +  RepaintGraphWindow();
 +  return 0;
  }
  
  //by marshmellow
  void printBitStream(uint8_t BitStream[], uint32_t bitLen)
  {
 -      uint32_t i = 0;
 -      if (bitLen<16) {
 -              PrintAndLog("Too few bits found: %d",bitLen);
 -              return;
 -      }
 -      if (bitLen>512) bitLen=512;
 -       for (i = 0; i <= (bitLen-16); i+=16) {
 -              PrintAndLog("%i%i%i%i%i%i%i%i%i%i%i%i%i%i%i%i",
 -                      BitStream[i],
 -                      BitStream[i+1],
 -                      BitStream[i+2],
 -                      BitStream[i+3],
 -                      BitStream[i+4],
 -                      BitStream[i+5],
 -                      BitStream[i+6],
 -                      BitStream[i+7],
 -                      BitStream[i+8],
 -                      BitStream[i+9],
 -                      BitStream[i+10],
 -                      BitStream[i+11],
 -                      BitStream[i+12],
 -                      BitStream[i+13],
 -                      BitStream[i+14],
 -                      BitStream[i+15]);
 -      }
 +  uint32_t i = 0;
 +  if (bitLen<16) {
 +    PrintAndLog("Too few bits found: %d",bitLen);
 +    return;
 +  }
 +  if (bitLen>512) bitLen=512;
 +   for (i = 0; i <= (bitLen-16); i+=16) {
 +    PrintAndLog("%i%i%i%i%i%i%i%i%i%i%i%i%i%i%i%i",
 +      BitStream[i],
 +      BitStream[i+1],
 +      BitStream[i+2],
 +      BitStream[i+3],
 +      BitStream[i+4],
 +      BitStream[i+5],
 +      BitStream[i+6],
 +      BitStream[i+7],
 +      BitStream[i+8],
 +      BitStream[i+9],
 +      BitStream[i+10],
 +      BitStream[i+11],
 +      BitStream[i+12],
 +      BitStream[i+13],
 +      BitStream[i+14],
 +      BitStream[i+15]);
 +  }
-   return; 
+       return;
  }
  //by marshmellow
+ //print EM410x ID in multiple formats
  void printEM410x(uint64_t id)
  {
 -      if (id !=0){
 -                      uint64_t iii=1;
 -                      uint64_t id2lo=0; //id2hi=0,
 -                      uint32_t ii=0;
 -                      uint32_t i=0;
 -                      for (ii=5; ii>0;ii--){
 -                              for (i=0;i<8;i++){
 +  if (id !=0){
 +      uint64_t iii=1;
 +      uint64_t id2lo=0; //id2hi=0,
 +      uint32_t ii=0;
 +      uint32_t i=0;
 +      for (ii=5; ii>0;ii--){
 +        for (i=0;i<8;i++){
-           id2lo=(id2lo<<1LL)|((id & (iii<<(i+((ii-1)*8))))>>(i+((ii-1)*8)));
+                                       id2lo=(id2lo<<1LL) | ((id & (iii << (i+((ii-1)*8)))) >> (i+((ii-1)*8)));
 -                              }
 -                      }
 -                      //output em id
 -                      PrintAndLog("EM TAG ID    : %010llx", id);
 -                      PrintAndLog("Unique TAG ID: %010llx",  id2lo); //id2hi,
 -                      PrintAndLog("DEZ 8        : %08lld",id & 0xFFFFFF);
 -                      PrintAndLog("DEZ 10       : %010lld",id & 0xFFFFFF);
 -                      PrintAndLog("DEZ 5.5      : %05lld.%05lld",(id>>16LL) & 0xFFFF,(id & 0xFFFF));
 -                      PrintAndLog("DEZ 3.5A     : %03lld.%05lld",(id>>32ll),(id & 0xFFFF));
 -                      PrintAndLog("DEZ 14/IK2   : %014lld",id);
 -                      PrintAndLog("DEZ 15/IK3   : %015lld",id2lo);
 -                      PrintAndLog("Other        : %05lld_%03lld_%08lld",(id&0xFFFF),((id>>16LL) & 0xFF),(id & 0xFFFFFF));
 +        }
 +      }
 +      //output em id
 +      PrintAndLog("EM TAG ID    : %010llx", id);
 +      PrintAndLog("Unique TAG ID: %010llx",  id2lo); //id2hi,
 +      PrintAndLog("DEZ 8        : %08lld",id & 0xFFFFFF);
 +      PrintAndLog("DEZ 10       : %010lld",id & 0xFFFFFF);
 +      PrintAndLog("DEZ 5.5      : %05lld.%05lld",(id>>16LL) & 0xFFFF,(id & 0xFFFF));
 +      PrintAndLog("DEZ 3.5A     : %03lld.%05lld",(id>>32ll),(id & 0xFFFF));
 +      PrintAndLog("DEZ 14/IK2   : %014lld",id);
 +      PrintAndLog("DEZ 15/IK3   : %015lld",id2lo);
 +      PrintAndLog("Other        : %05lld_%03lld_%08lld",(id&0xFFFF),((id>>16LL) & 0xFF),(id & 0xFFFFFF));
-     }  
+               }
 -              return;
 +    return;
  }
  
  //by marshmellow
+ //take binary from demod buffer and see if we can find an EM410x ID
  int CmdEm410xDecode(const char *Cmd)
  {
 -      uint64_t id=0;
 +  uint64_t id=0;
-   uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
-   uint32_t i=0;
-   i=getFromGraphBuf(BitStream);
-   id = Em410xDecode(BitStream,i);
+  // uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
+  // uint32_t i=0;
+  // i=getFromGraphBuf(BitStream);
+       id = Em410xDecode(DemodBuffer,DemodBufferLen);
 -      printEM410x(id);
 -      if (id>0) return 1;
 -      return 0;
 +  printEM410x(id);
 +  if (id>0) return 1;
 +  return 0;
  }
  
  
  //prints binary found and saves in graphbuffer for further commands
  int Cmdaskmandemod(const char *Cmd)
  {
-   int invert=0; 
-   int clk=0; 
+       int invert=0;
+       int clk=0;
 -      uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
 +  uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
-   sscanf(Cmd, "%i %i", &clk, &invert);    
+       sscanf(Cmd, "%i %i", &clk, &invert);
 -      if (invert != 0 && invert != 1) {
 -              PrintAndLog("Invalid argument: %s", Cmd);
 -              return 0;
 -      }
 +  if (invert != 0 && invert != 1) {
 +    PrintAndLog("Invalid argument: %s", Cmd);
 +    return 0;
 +  }
-   uint32_t BitLen = getFromGraphBuf(BitStream);
+       size_t BitLen = getFromGraphBuf(BitStream);
 -      //  PrintAndLog("DEBUG: Bitlen from grphbuff: %d",BitLen);
 -      int errCnt=0;
 -       errCnt = askmandemod(BitStream, &BitLen,&clk,&invert);
 +  //  PrintAndLog("DEBUG: Bitlen from grphbuff: %d",BitLen);
 +  int errCnt=0;
 +   errCnt = askmandemod(BitStream, &BitLen,&clk,&invert);
-   if (errCnt<0){  //if fatal error (or -1)
-     // PrintAndLog("no data found %d, errors:%d, bitlen:%d, clock:%d",errCnt,invert,BitLen,clk); 
+       if (errCnt<0||BitLen<16){  //if fatal error (or -1)
+               // PrintAndLog("no data found %d, errors:%d, bitlen:%d, clock:%d",errCnt,invert,BitLen,clk);
 -              return 0;
 +    return 0;
-   } 
-   if (BitLen<16) return 0;
+       }
 -      PrintAndLog("\nUsing Clock: %d - Invert: %d - Bits Found: %d",clk,invert,BitLen);
 +  PrintAndLog("\nUsing Clock: %d - Invert: %d - Bits Found: %d",clk,invert,BitLen);
-   
 -      //output
 -      if (errCnt>0){
 -              PrintAndLog("# Errors during Demoding (shown as 77 in bit stream): %d",errCnt);
 -      }
 -      PrintAndLog("ASK/Manchester decoded bitstream:");
 -      // Now output the bitstream to the scrollback by line of 16 bits
 +  //output
 +  if (errCnt>0){
 +    PrintAndLog("# Errors during Demoding (shown as 77 in bit stream): %d",errCnt);
 +  }
 +  PrintAndLog("ASK/Manchester decoded bitstream:");
 +  // Now output the bitstream to the scrollback by line of 16 bits
-   printBitStream(BitStream,BitLen);
+       setDemodBuf(BitStream,BitLen);
+       printDemodBuff();
 -      uint64_t lo =0;
 -      lo = Em410xDecode(BitStream,BitLen);
 -      if (lo>0){
 -              //set GraphBuffer for clone or sim command
 -              PrintAndLog("EM410x pattern found: ");
 -              printEM410x(lo);
 -              return 1;
 -      }
 -      //if (BitLen>16) return 1;
 -      return 0;
 +  uint64_t lo =0;
 +  lo = Em410xDecode(BitStream,BitLen);
 +  if (lo>0){
 +    //set GraphBuffer for clone or sim command
-     setGraphBuf(BitStream,BitLen); 
 +    PrintAndLog("EM410x pattern found: ");
 +    printEM410x(lo);
 +    return 1;
 +  }
 +  //if (BitLen>16) return 1;
 +  return 0;
  }
  
  //by marshmellow
  //stricktly take 10 and 01 and convert to 0 and 1
  int Cmdmandecoderaw(const char *Cmd)
  {
 -      int i =0;
 -      int errCnt=0;
 +  int i =0;
 +  int errCnt=0;
-   int bitnum=0;
+       size_t size=0;
 -      uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
 -      int high=0,low=0;
 +  uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
 +  int high=0,low=0;
-   for (;i<GraphTraceLen;++i){
-     if (GraphBuffer[i]>high) high=GraphBuffer[i];
-     else if(GraphBuffer[i]<low) low=GraphBuffer[i];
-     BitStream[i]=GraphBuffer[i];
+       for (;i<DemodBufferLen;++i){
+               if (DemodBuffer[i]>high) high=DemodBuffer[i];
+               else if(DemodBuffer[i]<low) low=DemodBuffer[i];
+               BitStream[i]=DemodBuffer[i];
 -      }
 -      if (high>1 || low <0 ){
 -              PrintAndLog("Error: please raw demod the wave first then mancheseter raw decode");
 -              return 0;
 -      }
 +  }
 +  if (high>1 || low <0 ){
 +    PrintAndLog("Error: please raw demod the wave first then mancheseter raw decode");
 +    return 0;
 +  }
-   bitnum=i;
-   errCnt=manrawdecode(BitStream,&bitnum);
+       size=i;
+       errCnt=manrawdecode(BitStream, &size);
 -      if (errCnt>=20){
 -              PrintAndLog("Too many errors: %d",errCnt);
 -              return 0;
 -      }
 -      PrintAndLog("Manchester Decoded - # errors:%d - data:",errCnt);
 +  if (errCnt>=20){
 +    PrintAndLog("Too many errors: %d",errCnt);
 +    return 0;
 +  }
 +  PrintAndLog("Manchester Decoded - # errors:%d - data:",errCnt);
-   printBitStream(BitStream,bitnum);
+       printBitStream(BitStream, size);
 -      if (errCnt==0){
 +  if (errCnt==0){
-     //put back in graphbuffer
-     ClearGraph(0);
-     for (i=0; i<bitnum;++i){
-       GraphBuffer[i]=BitStream[i];
-     }  
-     GraphTraceLen=bitnum;
-     RepaintGraphWindow();
-     uint64_t id = 0; 
-     id = Em410xDecode(BitStream,i);
-     printEM410x(id);     
+               uint64_t id = 0;
+               id = Em410xDecode(BitStream, size);
+               if (id>0) setDemodBuf(BitStream, size);
+               printEM410x(id);
 -      }
 -      return 1;
 +  }
 +  return 1;
  }
  
  //by marshmellow
  //    width waves vs small width waves to help the decode positioning) or askbiphdemod
  int CmdBiphaseDecodeRaw(const char *Cmd)
  {
 -      int i = 0;
 -      int errCnt=0;
 +  int i = 0;
 +  int errCnt=0;
-   int bitnum=0;
+       size_t size=0;
 -      int offset=0;
 -      int high=0, low=0;
 +  int offset=0;
 +  int high=0, low=0;
-   sscanf(Cmd, "%i", &offset);    
+       sscanf(Cmd, "%i", &offset);
 -      uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
 -      //get graphbuffer & high and low
 +  uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
 +  //get graphbuffer & high and low
-   for (;i<GraphTraceLen;++i){
-     if(GraphBuffer[i]>high)high=GraphBuffer[i];
-     else if(GraphBuffer[i]<low)low=GraphBuffer[i];
-     BitStream[i]=GraphBuffer[i];
+       for (;i<DemodBufferLen;++i){
+               if(DemodBuffer[i]>high)high=DemodBuffer[i];
+               else if(DemodBuffer[i]<low)low=DemodBuffer[i];
+               BitStream[i]=DemodBuffer[i];
 -      }
 -      if (high>1 || low <0){
 -              PrintAndLog("Error: please raw demod the wave first then decode");
 -              return 0;
 -      }
 +  }
 +  if (high>1 || low <0){
 +    PrintAndLog("Error: please raw demod the wave first then decode");
 +    return 0;
 +  }
-   bitnum=i;
-   errCnt=BiphaseRawDecode(BitStream,&bitnum, offset);
+       size=i;
+       errCnt=BiphaseRawDecode(BitStream, &size, offset);
 -      if (errCnt>=20){
 -              PrintAndLog("Too many errors attempting to decode: %d",errCnt);
 -              return 0;
 -      }
 -      PrintAndLog("Biphase Decoded using offset: %d - # errors:%d - data:",offset,errCnt);
 +  if (errCnt>=20){
 +    PrintAndLog("Too many errors attempting to decode: %d",errCnt);
 +    return 0;
 +  }
 +  PrintAndLog("Biphase Decoded using offset: %d - # errors:%d - data:",offset,errCnt);
-   printBitStream(BitStream,bitnum);
+       printBitStream(BitStream, size);
 -      PrintAndLog("\nif bitstream does not look right try offset=1");
 -      return 1;
 +  PrintAndLog("\nif bitstream does not look right try offset=1");
 +  return 1;
  }
  
  
  //prints binary found and saves in graphbuffer for further commands
  int Cmdaskrawdemod(const char *Cmd)
  {
-   
-   int invert=0; 
-   int clk=0; 
+       int invert=0;
+       int clk=0;
 -      uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
 +  uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
-   sscanf(Cmd, "%i %i", &clk, &invert);    
+       sscanf(Cmd, "%i %i", &clk, &invert);
 -      if (invert != 0 && invert != 1) {
 -              PrintAndLog("Invalid argument: %s", Cmd);
 -              return 0;
 -      }
 +  if (invert != 0 && invert != 1) {
 +    PrintAndLog("Invalid argument: %s", Cmd);
 +    return 0;
 +  }
-   int BitLen = getFromGraphBuf(BitStream);
+       size_t BitLen = getFromGraphBuf(BitStream);
 -      int errCnt=0;
 +  int errCnt=0;
-   errCnt = askrawdemod(BitStream, &BitLen, &clk, &invert);
-   if (errCnt==-1){  //throw away static - allow 1 and -1 (in case of threshold command first)
-     PrintAndLog("no data found"); 
+       errCnt = askrawdemod(BitStream, &BitLen,&clk,&invert);
+       if (errCnt==-1||BitLen<16){  //throw away static - allow 1 and -1 (in case of threshold command first)
+               PrintAndLog("no data found");
 -              return 0;
 +    return 0;
-   } 
-   if (BitLen<16) return 0;
+       }
 -      PrintAndLog("Using Clock: %d - invert: %d - Bits Found: %d",clk,invert,BitLen);
 -              //PrintAndLog("Data start pos:%d, lastBit:%d, stop pos:%d, numBits:%d",iii,lastBit,i,bitnum);
 +  PrintAndLog("Using Clock: %d - invert: %d - Bits Found: %d",clk,invert,BitLen);
 +    //PrintAndLog("Data start pos:%d, lastBit:%d, stop pos:%d, numBits:%d",iii,lastBit,i,bitnum);
-     //move BitStream back to GraphBuffer
-       setGraphBuf(BitStream, BitLen);
-       
+               //move BitStream back to DemodBuffer
+       setDemodBuf(BitStream,BitLen);
+               //output
 -      if (errCnt>0){
 -              PrintAndLog("# Errors during Demoding (shown as 77 in bit stream): %d",errCnt);
 -      }
 -      PrintAndLog("ASK demoded bitstream:");
 -      // Now output the bitstream to the scrollback by line of 16 bits
 -      printBitStream(BitStream,BitLen);
 -
 -      return 1;
 +  if (errCnt>0){
 +    PrintAndLog("# Errors during Demoding (shown as 77 in bit stream): %d",errCnt);
 +  }
 +  PrintAndLog("ASK demoded bitstream:");
-       
 +  // Now output the bitstream to the scrollback by line of 16 bits
 +  printBitStream(BitStream,BitLen);
-   
++
 +  return 1;
  }
  
  int CmdAutoCorr(const char *Cmd)
  
  int CmdBitsamples(const char *Cmd)
  {
 -      int cnt = 0;
 -      uint8_t got[12288];
 -
 -      GetFromBigBuf(got,sizeof(got),0);
 -      WaitForResponse(CMD_ACK,NULL);
 -
 -              for (int j = 0; j < sizeof(got); j++) {
 -                      for (int k = 0; k < 8; k++) {
 -                              if(got[j] & (1 << (7 - k))) {
 -                                      GraphBuffer[cnt++] = 1;
 -                              } else {
 -                                      GraphBuffer[cnt++] = 0;
 -                              }
 -                      }
 -      }
 -      GraphTraceLen = cnt;
 -      RepaintGraphWindow();
 -      return 0;
 +  int cnt = 0;
 +  uint8_t got[12288];
-   
++
 +  GetFromBigBuf(got,sizeof(got),0);
 +  WaitForResponse(CMD_ACK,NULL);
 +
 +    for (int j = 0; j < sizeof(got); j++) {
 +      for (int k = 0; k < 8; k++) {
 +        if(got[j] & (1 << (7 - k))) {
 +          GraphBuffer[cnt++] = 1;
 +        } else {
 +          GraphBuffer[cnt++] = 0;
 +        }
 +      }
 +  }
 +  GraphTraceLen = cnt;
 +  RepaintGraphWindow();
 +  return 0;
  }
  
  /*
   */
  int CmdBitstream(const char *Cmd)
  {
 -      int i, j;
 -      int bit;
 -      int gtl;
 -      int clock;
 -      int low = 0;
 -      int high = 0;
 -      int hithigh, hitlow, first;
 -
 -      /* Detect high and lows and clock */
 -      for (i = 0; i < GraphTraceLen; ++i)
 -      {
 -              if (GraphBuffer[i] > high)
 -                      high = GraphBuffer[i];
 -              else if (GraphBuffer[i] < low)
 -                      low = GraphBuffer[i];
 -      }
 -
 -      /* Get our clock */
 -      clock = GetClock(Cmd, high, 1);
 -      gtl = ClearGraph(0);
 -
 -      bit = 0;
 -      for (i = 0; i < (int)(gtl / clock); ++i)
 -      {
 -              hithigh = 0;
 -              hitlow = 0;
 -              first = 1;
 -              /* Find out if we hit both high and low peaks */
 -              for (j = 0; j < clock; ++j)
 -              {
 -                      if (GraphBuffer[(i * clock) + j] == high)
 -                              hithigh = 1;
 -                      else if (GraphBuffer[(i * clock) + j] == low)
 -                              hitlow = 1;
 -                      /* it doesn't count if it's the first part of our read
 -                               because it's really just trailing from the last sequence */
 -                      if (first && (hithigh || hitlow))
 -                              hithigh = hitlow = 0;
 -                      else
 -                              first = 0;
 -
 -                      if (hithigh && hitlow)
 -                              break;
 -              }
 -
 -              /* If we didn't hit both high and low peaks, we had a bit transition */
 -              if (!hithigh || !hitlow)
 -                      bit ^= 1;
 -
 -              AppendGraph(0, clock, bit);
 +  int i, j;
 +  int bit;
 +  int gtl;
 +  int clock;
 +  int low = 0;
 +  int high = 0;
 +  int hithigh, hitlow, first;
 +
 +  /* Detect high and lows and clock */
 +  for (i = 0; i < GraphTraceLen; ++i)
 +  {
 +    if (GraphBuffer[i] > high)
 +      high = GraphBuffer[i];
 +    else if (GraphBuffer[i] < low)
 +      low = GraphBuffer[i];
 +  }
 +
 +  /* Get our clock */
 +  clock = GetClock(Cmd, high, 1);
 +  gtl = ClearGraph(0);
 +
 +  bit = 0;
 +  for (i = 0; i < (int)(gtl / clock); ++i)
 +  {
 +    hithigh = 0;
 +    hitlow = 0;
 +    first = 1;
 +    /* Find out if we hit both high and low peaks */
 +    for (j = 0; j < clock; ++j)
 +    {
 +      if (GraphBuffer[(i * clock) + j] == high)
 +        hithigh = 1;
 +      else if (GraphBuffer[(i * clock) + j] == low)
 +        hitlow = 1;
 +      /* it doesn't count if it's the first part of our read
 +         because it's really just trailing from the last sequence */
 +      if (first && (hithigh || hitlow))
 +        hithigh = hitlow = 0;
 +      else
 +        first = 0;
 +
 +      if (hithigh && hitlow)
 +        break;
 +    }
 +
 +    /* If we didn't hit both high and low peaks, we had a bit transition */
 +    if (!hithigh || !hitlow)
 +      bit ^= 1;
 +
 +    AppendGraph(0, clock, bit);
+       //    for (j = 0; j < (int)(clock/2); j++)
+       //      GraphBuffer[(i * clock) + j] = bit ^ 1;
+       //    for (j = (int)(clock/2); j < clock; j++)
+       //      GraphBuffer[(i * clock) + j] = bit;
 -      }
 +  }
  
 -      RepaintGraphWindow();
 -      return 0;
 +  RepaintGraphWindow();
 +  return 0;
  }
  
  int CmdBuffClear(const char *Cmd)
@@@ -497,11 -540,13 +540,13 @@@ int CmdDec(const char *Cmd
  }
  
  /* Print our clock rate */
- // uses data from graphbuffer 
+ // uses data from graphbuffer
  int CmdDetectClockRate(const char *Cmd)
  {
 -      GetClock("",0,0);
 +  GetClock("",0,0);
+       //int clock = DetectASKClock(0);
+       //PrintAndLog("Auto-detected clock rate: %d", clock);
 -      return 0;
 +  return 0;
  }
  
  //by marshmellow
  //defaults: clock = 50, invert=0, rchigh=10, rclow=8 (RF/10 RF/8 (fsk2a))
  int CmdFSKrawdemod(const char *Cmd)
  {
 -      //raw fsk demod  no manchester decoding no start bit finding just get binary from wave
 -      //set defaults
 -      int rfLen = 50;
 -      int invert=0;
 -      int fchigh=10;
 -      int fclow=8;
 -      //set options from parameters entered with the command
 +  //raw fsk demod  no manchester decoding no start bit finding just get binary from wave
 +  //set defaults
 +  int rfLen = 50;
 +  int invert=0;
 +  int fchigh=10;
 +  int fclow=8;
 +  //set options from parameters entered with the command
-   sscanf(Cmd, "%i %i %i %i", &rfLen, &invert, &fchigh, &fclow);    
-   
+       sscanf(Cmd, "%i %i %i %i", &rfLen, &invert, &fchigh, &fclow);
 -      if (strlen(Cmd)>0 && strlen(Cmd)<=2) {
 -               //rfLen=param_get8(Cmd, 0); //if rfLen option only is used
 -               if (rfLen==1){
 -                      invert=1;   //if invert option only is used
 -                      rfLen = 50;
 -               } else if(rfLen==0) rfLen=50;
 +  if (strlen(Cmd)>0 && strlen(Cmd)<=2) {
 +     //rfLen=param_get8(Cmd, 0); //if rfLen option only is used
 +     if (rfLen==1){
 +      invert=1;   //if invert option only is used
 +      rfLen = 50;
 +     } else if(rfLen==0) rfLen=50;
-   } 
+       }
 -      PrintAndLog("Args invert: %d - Clock:%d - fchigh:%d - fclow: %d",invert,rfLen,fchigh, fclow);
 -      uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
 +  PrintAndLog("Args invert: %d - Clock:%d - fchigh:%d - fclow: %d",invert,rfLen,fchigh, fclow);
-   uint32_t i=0;
 +  uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
-   uint32_t BitLen = getFromGraphBuf(BitStream);
-   int size  = fskdemod(BitStream,BitLen,(uint8_t)rfLen,(uint8_t)invert,(uint8_t)fchigh,(uint8_t)fclow); 
+       size_t BitLen = getFromGraphBuf(BitStream);
+       int size  = fskdemod(BitStream,BitLen,(uint8_t)rfLen,(uint8_t)invert,(uint8_t)fchigh,(uint8_t)fclow);
 -      if (size>0){
 -              PrintAndLog("FSK decoded bitstream:");
 +  if (size>0){
 +    PrintAndLog("FSK decoded bitstream:");
-     ClearGraph(0);
-     for (i=0;i<size;++i){
-       GraphBuffer[i]=BitStream[i];
-     }
-     GraphTraceLen=size;
-     RepaintGraphWindow();
-     
+               setDemodBuf(BitStream,size);
 -              // Now output the bitstream to the scrollback by line of 16 bits
 -              if(size > (8*32)+2) size = (8*32)+2; //only output a max of 8 blocks of 32 bits  most tags will have full bit stream inside that sample size
 -              printBitStream(BitStream,size);
 -      } else{
 -              PrintAndLog("no FSK data found");
 -      }
 -      return 0;
 +    // Now output the bitstream to the scrollback by line of 16 bits
 +    if(size > (8*32)+2) size = (8*32)+2; //only output a max of 8 blocks of 32 bits  most tags will have full bit stream inside that sample size
 +    printBitStream(BitStream,size);
 +  } else{
 +    PrintAndLog("no FSK data found");
 +  }
 +  return 0;
  }
  
  //by marshmellow (based on existing demod + holiman's refactor)
  //print full HID Prox ID and some bit format details if found
  int CmdFSKdemodHID(const char *Cmd)
  {
 -      //raw fsk demod no manchester decoding no start bit finding just get binary from wave
 -      uint32_t hi2=0, hi=0, lo=0;
 +  //raw fsk demod no manchester decoding no start bit finding just get binary from wave
 +  uint32_t hi2=0, hi=0, lo=0;
  
 -      uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
 +  uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
-   uint32_t BitLen = getFromGraphBuf(BitStream);
+       size_t BitLen = getFromGraphBuf(BitStream);
 -      //get binary from fsk wave
 +  //get binary from fsk wave
-   size_t size  = HIDdemodFSK(BitStream,BitLen,&hi2,&hi,&lo); 
+       size_t size  = HIDdemodFSK(BitStream,BitLen,&hi2,&hi,&lo);
 -      if (size<0){
 -              PrintAndLog("Error demoding fsk");
 -              return 0;
 -      }
 -      if (hi2==0 && hi==0 && lo==0) return 0;
 -      if (hi2 != 0){ //extra large HID tags
 +  if (size<0){
 +    PrintAndLog("Error demoding fsk");
 +    return 0;
 +  }
 +  if (hi2==0 && hi==0 && lo==0) return 0;
 +  if (hi2 != 0){ //extra large HID tags
-     PrintAndLog("TAG ID: %x%08x%08x (%d)",
+               PrintAndLog("HID Prox TAG ID: %x%08x%08x (%d)",
 -                       (unsigned int) hi2, (unsigned int) hi, (unsigned int) lo, (unsigned int) (lo>>1) & 0xFFFF);
 +       (unsigned int) hi2, (unsigned int) hi, (unsigned int) lo, (unsigned int) (lo>>1) & 0xFFFF);
-     setGraphBuf(BitStream,BitLen);
+               setDemodBuf(BitStream,BitLen);
 -              return 1;
 -      }
 -      else {  //standard HID tags <38 bits
 -              //Dbprintf("TAG ID: %x%08x (%d)",(unsigned int) hi, (unsigned int) lo, (unsigned int) (lo>>1) & 0xFFFF); //old print cmd
 -              uint8_t fmtLen = 0;
 -              uint32_t fc = 0;
 -              uint32_t cardnum = 0;
 -              if (((hi>>5)&1)==1){//if bit 38 is set then < 37 bit format is used
 -                      uint32_t lo2=0;
 -                      lo2=(((hi & 15) << 12) | (lo>>20)); //get bits 21-37 to check for format len bit
 -                      uint8_t idx3 = 1;
 -                      while(lo2>1){ //find last bit set to 1 (format len bit)
 -                              lo2=lo2>>1;
 -                              idx3++;
 -                      }
 +    return 1;
 +  }
 +  else {  //standard HID tags <38 bits
 +    //Dbprintf("TAG ID: %x%08x (%d)",(unsigned int) hi, (unsigned int) lo, (unsigned int) (lo>>1) & 0xFFFF); //old print cmd
 +    uint8_t fmtLen = 0;
 +    uint32_t fc = 0;
 +    uint32_t cardnum = 0;
 +    if (((hi>>5)&1)==1){//if bit 38 is set then < 37 bit format is used
 +      uint32_t lo2=0;
 +      lo2=(((hi & 15) << 12) | (lo>>20)); //get bits 21-37 to check for format len bit
 +      uint8_t idx3 = 1;
 +      while(lo2>1){ //find last bit set to 1 (format len bit)
 +        lo2=lo2>>1;
 +        idx3++;
 +      }
-       fmtLen =idx3+19;  
+                       fmtLen =idx3+19;
 -                      fc =0;
 -                      cardnum=0;
 -                      if(fmtLen==26){
 -                              cardnum = (lo>>1)&0xFFFF;
 -                              fc = (lo>>17)&0xFF;
 -                      }
 -                      if(fmtLen==37){
 -                              cardnum = (lo>>1)&0x7FFFF;
 -                              fc = ((hi&0xF)<<12)|(lo>>20);
 -                      }
 -                      if(fmtLen==34){
 -                              cardnum = (lo>>1)&0xFFFF;
 -                              fc= ((hi&1)<<15)|(lo>>17);
 -                      }
 -                      if(fmtLen==35){
 -                              cardnum = (lo>>1)&0xFFFFF;
 -                              fc = ((hi&1)<<11)|(lo>>21);
 -                      }
 -              }
 -              else { //if bit 38 is not set then 37 bit format is used
 -                      fmtLen= 37;
 -                      fc =0;
 -                      cardnum=0;
 -                      if(fmtLen==37){
 -                              cardnum = (lo>>1)&0x7FFFF;
 -                              fc = ((hi&0xF)<<12)|(lo>>20);
 -                      }
 +      fc =0;
 +      cardnum=0;
 +      if(fmtLen==26){
 +        cardnum = (lo>>1)&0xFFFF;
 +        fc = (lo>>17)&0xFF;
 +      }
 +      if(fmtLen==37){
 +        cardnum = (lo>>1)&0x7FFFF;
 +        fc = ((hi&0xF)<<12)|(lo>>20);
 +      }
 +      if(fmtLen==34){
 +        cardnum = (lo>>1)&0xFFFF;
 +        fc= ((hi&1)<<15)|(lo>>17);
 +      }
 +      if(fmtLen==35){
 +        cardnum = (lo>>1)&0xFFFFF;
 +        fc = ((hi&1)<<11)|(lo>>21);
 +      }
 +    }
 +    else { //if bit 38 is not set then 37 bit format is used
 +      fmtLen= 37;
 +      fc =0;
 +      cardnum=0;
 +      if(fmtLen==37){
 +        cardnum = (lo>>1)&0x7FFFF;
 +        fc = ((hi&0xF)<<12)|(lo>>20);
 +      }
-     }    
-     PrintAndLog("TAG ID: %x%08x (%d) - Format Len: %dbit - FC: %d - Card: %d",
+               }
+               PrintAndLog("HID Prox TAG ID: %x%08x (%d) - Format Len: %dbit - FC: %d - Card: %d",
 -                      (unsigned int) hi, (unsigned int) lo, (unsigned int) (lo>>1) & 0xFFFF,
 -                      (unsigned int) fmtLen, (unsigned int) fc, (unsigned int) cardnum);
 +      (unsigned int) hi, (unsigned int) lo, (unsigned int) (lo>>1) & 0xFFFF,
 +      (unsigned int) fmtLen, (unsigned int) fc, (unsigned int) cardnum);
-     setGraphBuf(BitStream,BitLen);
+               setDemodBuf(BitStream,BitLen);
 -              return 1;
 -      }
 -      return 0;
 +    return 1;
 +  }
 +  return 0;
  }
  
  //by marshmellow
  //print ioprox ID and some format details
  int CmdFSKdemodIO(const char *Cmd)
  {
 -      //raw fsk demod no manchester decoding no start bit finding just get binary from wave
 -      //set defaults
 +  //raw fsk demod no manchester decoding no start bit finding just get binary from wave
 +  //set defaults
-   int idx=0; 
+       int idx=0;
 -      //something in graphbuffer
 -      if (GraphTraceLen < 65) return 0;
 -      uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
 +  //something in graphbuffer
 +  if (GraphTraceLen < 65) return 0;
 +  uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
-   uint32_t BitLen = getFromGraphBuf(BitStream);
+       size_t BitLen = getFromGraphBuf(BitStream);
 -      //get binary from fsk wave
 -      // PrintAndLog("DEBUG: got buff");
 +  //get binary from fsk wave
 + // PrintAndLog("DEBUG: got buff");
-   idx = IOdemodFSK(BitStream,BitLen); 
+       idx = IOdemodFSK(BitStream,BitLen);
 -      if (idx<0){
 -              //PrintAndLog("Error demoding fsk");
 -              return 0;
 -      }
 -      // PrintAndLog("DEBUG: Got IOdemodFSK");
 -      if (idx==0){
 -              //PrintAndLog("IO Prox Data not found - FSK Data:");
 -              //if (BitLen > 92) printBitStream(BitStream,92);
 -              return 0;
 -      }
 -              //Index map
 -              //0           10          20          30          40          50          60
 -              //|           |           |           |           |           |           |
 -              //01234567 8 90123456 7 89012345 6 78901234 5 67890123 4 56789012 3 45678901 23
 -              //-----------------------------------------------------------------------------
 -              //00000000 0 11110000 1 facility 1 version* 1 code*one 1 code*two 1 ???????? 11
 -              //
 -              //XSF(version)facility:codeone+codetwo (raw)
 -              //Handle the data
 -      if (idx+64>BitLen) return 0;
 -      PrintAndLog("%d%d%d%d%d%d%d%d %d",BitStream[idx],    BitStream[idx+1],  BitStream[idx+2], BitStream[idx+3], BitStream[idx+4], BitStream[idx+5], BitStream[idx+6], BitStream[idx+7], BitStream[idx+8]);
 +  if (idx<0){
 +    //PrintAndLog("Error demoding fsk");
 +    return 0;
 +  }
 + // PrintAndLog("DEBUG: Got IOdemodFSK");
 +  if (idx==0){
 +    //PrintAndLog("IO Prox Data not found - FSK Data:");
 +    //if (BitLen > 92) printBitStream(BitStream,92);
 +    return 0;
 +  }
 +    //Index map
 +    //0           10          20          30          40          50          60
 +    //|           |           |           |           |           |           |
 +    //01234567 8 90123456 7 89012345 6 78901234 5 67890123 4 56789012 3 45678901 23
 +    //-----------------------------------------------------------------------------
 +    //00000000 0 11110000 1 facility 1 version* 1 code*one 1 code*two 1 ???????? 11
 +    //
 +    //XSF(version)facility:codeone+codetwo (raw)
 +    //Handle the data
 +  if (idx+64>BitLen) return 0;
 +  PrintAndLog("%d%d%d%d%d%d%d%d %d",BitStream[idx],    BitStream[idx+1],  BitStream[idx+2], BitStream[idx+3], BitStream[idx+4], BitStream[idx+5], BitStream[idx+6], BitStream[idx+7], BitStream[idx+8]);
-   PrintAndLog("%d%d%d%d%d%d%d%d %d",BitStream[idx+9],  BitStream[idx+10], BitStream[idx+11],BitStream[idx+12],BitStream[idx+13],BitStream[idx+14],BitStream[idx+15],BitStream[idx+16],BitStream[idx+17]);       
+       PrintAndLog("%d%d%d%d%d%d%d%d %d",BitStream[idx+9],  BitStream[idx+10], BitStream[idx+11],BitStream[idx+12],BitStream[idx+13],BitStream[idx+14],BitStream[idx+15],BitStream[idx+16],BitStream[idx+17]);
 -      PrintAndLog("%d%d%d%d%d%d%d%d %d facility",BitStream[idx+18], BitStream[idx+19], BitStream[idx+20],BitStream[idx+21],BitStream[idx+22],BitStream[idx+23],BitStream[idx+24],BitStream[idx+25],BitStream[idx+26]);
 -      PrintAndLog("%d%d%d%d%d%d%d%d %d version",BitStream[idx+27], BitStream[idx+28], BitStream[idx+29],BitStream[idx+30],BitStream[idx+31],BitStream[idx+32],BitStream[idx+33],BitStream[idx+34],BitStream[idx+35]);
 -      PrintAndLog("%d%d%d%d%d%d%d%d %d code1",BitStream[idx+36], BitStream[idx+37], BitStream[idx+38],BitStream[idx+39],BitStream[idx+40],BitStream[idx+41],BitStream[idx+42],BitStream[idx+43],BitStream[idx+44]);
 -      PrintAndLog("%d%d%d%d%d%d%d%d %d code2",BitStream[idx+45], BitStream[idx+46], BitStream[idx+47],BitStream[idx+48],BitStream[idx+49],BitStream[idx+50],BitStream[idx+51],BitStream[idx+52],BitStream[idx+53]);
 -      PrintAndLog("%d%d%d%d%d%d%d%d %d%d checksum",BitStream[idx+54],BitStream[idx+55],BitStream[idx+56],BitStream[idx+57],BitStream[idx+58],BitStream[idx+59],BitStream[idx+60],BitStream[idx+61],BitStream[idx+62],BitStream[idx+63]);
 +  PrintAndLog("%d%d%d%d%d%d%d%d %d facility",BitStream[idx+18], BitStream[idx+19], BitStream[idx+20],BitStream[idx+21],BitStream[idx+22],BitStream[idx+23],BitStream[idx+24],BitStream[idx+25],BitStream[idx+26]);
 +  PrintAndLog("%d%d%d%d%d%d%d%d %d version",BitStream[idx+27], BitStream[idx+28], BitStream[idx+29],BitStream[idx+30],BitStream[idx+31],BitStream[idx+32],BitStream[idx+33],BitStream[idx+34],BitStream[idx+35]);
 +  PrintAndLog("%d%d%d%d%d%d%d%d %d code1",BitStream[idx+36], BitStream[idx+37], BitStream[idx+38],BitStream[idx+39],BitStream[idx+40],BitStream[idx+41],BitStream[idx+42],BitStream[idx+43],BitStream[idx+44]);
 +  PrintAndLog("%d%d%d%d%d%d%d%d %d code2",BitStream[idx+45], BitStream[idx+46], BitStream[idx+47],BitStream[idx+48],BitStream[idx+49],BitStream[idx+50],BitStream[idx+51],BitStream[idx+52],BitStream[idx+53]);
 +  PrintAndLog("%d%d%d%d%d%d%d%d %d%d checksum",BitStream[idx+54],BitStream[idx+55],BitStream[idx+56],BitStream[idx+57],BitStream[idx+58],BitStream[idx+59],BitStream[idx+60],BitStream[idx+61],BitStream[idx+62],BitStream[idx+63]);
  
 -      uint32_t code = bytebits_to_byte(BitStream+idx,32);
 +  uint32_t code = bytebits_to_byte(BitStream+idx,32);
-   uint32_t code2 = bytebits_to_byte(BitStream+idx+32,32); 
+       uint32_t code2 = bytebits_to_byte(BitStream+idx+32,32);
 -      uint8_t version = bytebits_to_byte(BitStream+idx+27,8); //14,4
 -      uint8_t facilitycode = bytebits_to_byte(BitStream+idx+18,8) ;
 -      uint16_t number = (bytebits_to_byte(BitStream+idx+36,8)<<8)|(bytebits_to_byte(BitStream+idx+45,8)); //36,9
 +  uint8_t version = bytebits_to_byte(BitStream+idx+27,8); //14,4
 +  uint8_t facilitycode = bytebits_to_byte(BitStream+idx+18,8) ;
 +  uint16_t number = (bytebits_to_byte(BitStream+idx+36,8)<<8)|(bytebits_to_byte(BitStream+idx+45,8)); //36,9
-   
-   PrintAndLog("XSF(%02d)%02x:%05d (%08x%08x)",version,facilitycode,number,code,code2);    
-   setGraphBuf(BitStream,BitLen);
+       PrintAndLog("IO Prox XSF(%02d)%02x:%05d (%08x%08x)",version,facilitycode,number,code,code2);
+       int i;
+       for (i=0;i<64;++i)
+               DemodBuffer[i]=BitStream[idx++];
+       DemodBufferLen=64;
 -      return 1;
 +  return 1;
  }
  int CmdFSKdemod(const char *Cmd) //old CmdFSKdemod needs updating
  {
 -      static const int LowTone[]  = {
 -              1,  1,  1,  1,  1, -1, -1, -1, -1, -1,
 -              1,  1,  1,  1,  1, -1, -1, -1, -1, -1,
 -              1,  1,  1,  1,  1, -1, -1, -1, -1, -1,
 -              1,  1,  1,  1,  1, -1, -1, -1, -1, -1,
 -              1,  1,  1,  1,  1, -1, -1, -1, -1, -1
 -      };
 -      static const int HighTone[] = {
 -              1,  1,  1,  1,  1,     -1, -1, -1, -1,
 -              1,  1,  1,  1,         -1, -1, -1, -1,
 -              1,  1,  1,  1,         -1, -1, -1, -1,
 -              1,  1,  1,  1,         -1, -1, -1, -1,
 -              1,  1,  1,  1,         -1, -1, -1, -1,
 -              1,  1,  1,  1,     -1, -1, -1, -1, -1,
 -      };
 -
 -      int lowLen = sizeof (LowTone) / sizeof (int);
 -      int highLen = sizeof (HighTone) / sizeof (int);
 -      int convLen = (highLen > lowLen) ? highLen : lowLen; //if highlen > lowLen then highlen else lowlen
 -      uint32_t hi = 0, lo = 0;
 -
 -      int i, j;
 -      int minMark = 0, maxMark = 0;
 -
 -      for (i = 0; i < GraphTraceLen - convLen; ++i) {
 -              int lowSum = 0, highSum = 0;
 -
 -              for (j = 0; j < lowLen; ++j) {
 -                      lowSum += LowTone[j]*GraphBuffer[i+j];
 -              }
 -              for (j = 0; j < highLen; ++j) {
 -                      highSum += HighTone[j] * GraphBuffer[i + j];
 -              }
 -              lowSum = abs(100 * lowSum / lowLen);
 -              highSum = abs(100 * highSum / highLen);
 -              GraphBuffer[i] = (highSum << 16) | lowSum;
 -      }
 -
 -      for(i = 0; i < GraphTraceLen - convLen - 16; ++i) {
 -              int lowTot = 0, highTot = 0;
 -              // 10 and 8 are f_s divided by f_l and f_h, rounded
 -              for (j = 0; j < 10; ++j) {
 -                      lowTot += (GraphBuffer[i+j] & 0xffff);
 -              }
 -              for (j = 0; j < 8; j++) {
 -                      highTot += (GraphBuffer[i + j] >> 16);
 -              }
 -              GraphBuffer[i] = lowTot - highTot;
 -              if (GraphBuffer[i] > maxMark) maxMark = GraphBuffer[i];
 -              if (GraphBuffer[i] < minMark) minMark = GraphBuffer[i];
 -      }
 -
 -      GraphTraceLen -= (convLen + 16);
 -      RepaintGraphWindow();
 -
 -      // Find bit-sync (3 lo followed by 3 high) (HID ONLY)
 -      int max = 0, maxPos = 0;
 -      for (i = 0; i < 6000; ++i) {
 -              int dec = 0;
 -              for (j = 0; j < 3 * lowLen; ++j) {
 -                      dec -= GraphBuffer[i + j];
 -              }
 -              for (; j < 3 * (lowLen + highLen ); ++j) {
 -                      dec += GraphBuffer[i + j];
 -              }
 -              if (dec > max) {
 -                      max = dec;
 -                      maxPos = i;
 -              }
 -      }
 -
 -      // place start of bit sync marker in graph
 -      GraphBuffer[maxPos] = maxMark;
 -      GraphBuffer[maxPos + 1] = minMark;
 -
 -      maxPos += j;
 -
 -      // place end of bit sync marker in graph
 -      GraphBuffer[maxPos] = maxMark;
 -      GraphBuffer[maxPos+1] = minMark;
 -
 -      PrintAndLog("actual data bits start at sample %d", maxPos);
 -      PrintAndLog("length %d/%d", highLen, lowLen);
 +  static const int LowTone[]  = {
 +    1,  1,  1,  1,  1, -1, -1, -1, -1, -1,
 +    1,  1,  1,  1,  1, -1, -1, -1, -1, -1,
 +    1,  1,  1,  1,  1, -1, -1, -1, -1, -1,
 +    1,  1,  1,  1,  1, -1, -1, -1, -1, -1,
 +    1,  1,  1,  1,  1, -1, -1, -1, -1, -1
 +  };
 +  static const int HighTone[] = {
 +    1,  1,  1,  1,  1,     -1, -1, -1, -1,
 +    1,  1,  1,  1,         -1, -1, -1, -1,
 +    1,  1,  1,  1,         -1, -1, -1, -1,
 +    1,  1,  1,  1,         -1, -1, -1, -1,
 +    1,  1,  1,  1,         -1, -1, -1, -1,
 +    1,  1,  1,  1,     -1, -1, -1, -1, -1,
 +  };
 +
 +  int lowLen = sizeof (LowTone) / sizeof (int);
 +  int highLen = sizeof (HighTone) / sizeof (int);
 +  int convLen = (highLen > lowLen) ? highLen : lowLen;
 +  uint32_t hi = 0, lo = 0;
 +
 +  int i, j;
 +  int minMark = 0, maxMark = 0;
-   
++
 +  for (i = 0; i < GraphTraceLen - convLen; ++i) {
 +    int lowSum = 0, highSum = 0;
 +
 +    for (j = 0; j < lowLen; ++j) {
 +      lowSum += LowTone[j]*GraphBuffer[i+j];
 +    }
 +    for (j = 0; j < highLen; ++j) {
 +      highSum += HighTone[j] * GraphBuffer[i + j];
 +    }
 +    lowSum = abs(100 * lowSum / lowLen);
 +    highSum = abs(100 * highSum / highLen);
 +    GraphBuffer[i] = (highSum << 16) | lowSum;
 +  }
 +
 +  for(i = 0; i < GraphTraceLen - convLen - 16; ++i) {
 +    int lowTot = 0, highTot = 0;
 +    // 10 and 8 are f_s divided by f_l and f_h, rounded
 +    for (j = 0; j < 10; ++j) {
 +      lowTot += (GraphBuffer[i+j] & 0xffff);
 +    }
 +    for (j = 0; j < 8; j++) {
 +      highTot += (GraphBuffer[i + j] >> 16);
 +    }
 +    GraphBuffer[i] = lowTot - highTot;
 +    if (GraphBuffer[i] > maxMark) maxMark = GraphBuffer[i];
 +    if (GraphBuffer[i] < minMark) minMark = GraphBuffer[i];
 +  }
 +
 +  GraphTraceLen -= (convLen + 16);
 +  RepaintGraphWindow();
 +
 +  // Find bit-sync (3 lo followed by 3 high) (HID ONLY)
 +  int max = 0, maxPos = 0;
 +  for (i = 0; i < 6000; ++i) {
 +    int dec = 0;
 +    for (j = 0; j < 3 * lowLen; ++j) {
 +      dec -= GraphBuffer[i + j];
 +    }
 +    for (; j < 3 * (lowLen + highLen ); ++j) {
 +      dec += GraphBuffer[i + j];
 +    }
 +    if (dec > max) {
 +      max = dec;
 +      maxPos = i;
 +    }
 +  }
 +
 +  // place start of bit sync marker in graph
 +  GraphBuffer[maxPos] = maxMark;
 +  GraphBuffer[maxPos + 1] = minMark;
 +
 +  maxPos += j;
 +
 +  // place end of bit sync marker in graph
 +  GraphBuffer[maxPos] = maxMark;
 +  GraphBuffer[maxPos+1] = minMark;
 +
 +  PrintAndLog("actual data bits start at sample %d", maxPos);
 +  PrintAndLog("length %d/%d", highLen, lowLen);
  
-   uint8_t bits[46] = {0x00};
+       uint8_t bits[46];
+       bits[sizeof(bits)-1] = '\0';
  
 -      // find bit pairs and manchester decode them
 -      for (i = 0; i < arraylen(bits) - 1; ++i) {
 -              int dec = 0;
 -              for (j = 0; j < lowLen; ++j) {
 -                      dec -= GraphBuffer[maxPos + j];
 -              }
 -              for (; j < lowLen + highLen; ++j) {
 -                      dec += GraphBuffer[maxPos + j];
 -              }
 -              maxPos += j;
 -              // place inter bit marker in graph
 -              GraphBuffer[maxPos] = maxMark;
 -              GraphBuffer[maxPos + 1] = minMark;
 -
 -              // hi and lo form a 64 bit pair
 -              hi = (hi << 1) | (lo >> 31);
 -              lo = (lo << 1);
 -              // store decoded bit as binary (in hi/lo) and text (in bits[])
 -              if(dec < 0) {
 -                      bits[i] = '1';
 -                      lo |= 1;
 -              } else {
 -                      bits[i] = '0';
 -              }
 -      }
 -      PrintAndLog("bits: '%s'", bits);
 -      PrintAndLog("hex: %08x %08x", hi, lo);
 -      return 0;
 +  // find bit pairs and manchester decode them
 +  for (i = 0; i < arraylen(bits) - 1; ++i) {
 +    int dec = 0;
 +    for (j = 0; j < lowLen; ++j) {
 +      dec -= GraphBuffer[maxPos + j];
 +    }
 +    for (; j < lowLen + highLen; ++j) {
 +      dec += GraphBuffer[maxPos + j];
 +    }
 +    maxPos += j;
 +    // place inter bit marker in graph
 +    GraphBuffer[maxPos] = maxMark;
 +    GraphBuffer[maxPos + 1] = minMark;
 +
 +    // hi and lo form a 64 bit pair
 +    hi = (hi << 1) | (lo >> 31);
 +    lo = (lo << 1);
 +    // store decoded bit as binary (in hi/lo) and text (in bits[])
 +    if(dec < 0) {
 +      bits[i] = '1';
 +      lo |= 1;
 +    } else {
 +      bits[i] = '0';
 +    }
 +  }
 +  PrintAndLog("bits: '%s'", bits);
 +  PrintAndLog("hex: %08x %08x", hi, lo);
 +  return 0;
  }
  
+ int CmdDetectNRZpskClockRate(const char *Cmd)
+ {
+       GetNRZpskClock("",0,0);
+       return 0;
+ }
+ int PSKnrzDemod(const char *Cmd){
+       int invert=0;
+       int clk=0;
+       sscanf(Cmd, "%i %i", &clk, &invert);
+       if (invert != 0 && invert != 1) {
+               PrintAndLog("Invalid argument: %s", Cmd);
+               return -1;
+       }
+       uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
+       size_t BitLen = getFromGraphBuf(BitStream);
+       int errCnt=0;
+       errCnt = pskNRZrawDemod(BitStream, &BitLen,&clk,&invert);
+       if (errCnt<0|| BitLen<16){  //throw away static - allow 1 and -1 (in case of threshold command first)
+               //PrintAndLog("no data found, clk: %d, invert: %d, numbits: %d, errCnt: %d",clk,invert,BitLen,errCnt);
+               return -1;
+       }
+       PrintAndLog("Tried PSK/NRZ Demod using Clock: %d - invert: %d - Bits Found: %d",clk,invert,BitLen);
+       //prime demod buffer for output
+       setDemodBuf(BitStream,BitLen);
+       return errCnt;
+ }
+ // Indala 26 bit decode
+ // by marshmellow
+ // optional arguments - same as CmdpskNRZrawDemod (clock & invert)
+ int CmdIndalaDecode(const char *Cmd)
+ {
+       int ans=PSKnrzDemod(Cmd);
+       if (ans < 0){
+               PrintAndLog("Error1: %d",ans);
+               return 0;
+       }
+       uint8_t invert=0;
+       ans = indala26decode(DemodBuffer,(size_t *) &DemodBufferLen, &invert);
+       if (ans < 1) {
+               PrintAndLog("Error2: %d",ans);
+               return -1;
+       }
+       char showbits[251];
+       if(invert==1) PrintAndLog("Had to invert bits");
+       //convert UID to HEX
+       uint32_t uid1, uid2, uid3, uid4, uid5, uid6, uid7;
+       int idx;
+       uid1=0;
+       uid2=0;
+       PrintAndLog("BitLen: %d",DemodBufferLen);
+       if (DemodBufferLen==64){
+               for( idx=0; idx<64; idx++) {
+                       uid1=(uid1<<1)|(uid2>>31);
+                       if (DemodBuffer[idx] == 0) {
+                               uid2=(uid2<<1)|0;
+                               showbits[idx]='0';
+                       } else {
+                               uid2=(uid2<<1)|1;
+                               showbits[idx]='1';
+                       }
+               }
+               showbits[idx]='\0';
+               PrintAndLog("Indala UID=%s (%x%08x)", showbits, uid1, uid2);
+       }
+       else {
+               uid3=0;
+               uid4=0;
+               uid5=0;
+               uid6=0;
+               uid7=0;
+               for( idx=0; idx<DemodBufferLen; idx++) {
+                       uid1=(uid1<<1)|(uid2>>31);
+                       uid2=(uid2<<1)|(uid3>>31);
+                       uid3=(uid3<<1)|(uid4>>31);
+                       uid4=(uid4<<1)|(uid5>>31);
+                       uid5=(uid5<<1)|(uid6>>31);
+                       uid6=(uid6<<1)|(uid7>>31);
+                       if (DemodBuffer[idx] == 0) {
+                               uid7=(uid7<<1)|0;
+                               showbits[idx]='0';
+                       }
+                       else {
+                               uid7=(uid7<<1)|1;
+                               showbits[idx]='1';
+                       }
+               }
+               showbits[idx]='\0';
+               PrintAndLog("Indala UID=%s (%x%08x%08x%08x%08x%08x%08x)", showbits, uid1, uid2, uid3, uid4, uid5, uid6, uid7);
+       }
+       return 1;
+ }
+ int CmdPskClean(const char *Cmd)
+ {
+       uint8_t bitStream[MAX_GRAPH_TRACE_LEN]={0};
+       size_t bitLen = getFromGraphBuf(bitStream);
+       pskCleanWave(bitStream, bitLen);
+       setGraphBuf(bitStream, bitLen);
+       return 0;
+ }
+ //by marshmellow
+ //takes 2 arguments - clock and invert both as integers
+ //attempts to demodulate ask only
+ //prints binary found and saves in graphbuffer for further commands
+ int CmdpskNRZrawDemod(const char *Cmd)
+ {
+       int errCnt= PSKnrzDemod(Cmd);
+       //output
+       if (errCnt<0) return 0;
+       if (errCnt>0){
+               PrintAndLog("# Errors during Demoding (shown as 77 in bit stream): %d",errCnt);
+       }
+       PrintAndLog("PSK or NRZ demoded bitstream:");
+       // Now output the bitstream to the scrollback by line of 16 bits
+       printDemodBuff();
+       return 1;
+ }
  int CmdGrid(const char *Cmd)
  {
 -      sscanf(Cmd, "%i %i", &PlotGridX, &PlotGridY);
 -      PlotGridXdefault= PlotGridX;
 -      PlotGridYdefault= PlotGridY;
 -      RepaintGraphWindow();
 -      return 0;
 +  sscanf(Cmd, "%i %i", &PlotGridX, &PlotGridY);
 +  PlotGridXdefault= PlotGridX;
 +  PlotGridYdefault= PlotGridY;
 +  RepaintGraphWindow();
 +  return 0;
  }
  
  int CmdHexsamples(const char *Cmd)
  {
 -      int i, j;
 -      int requested = 0;
 -      int offset = 0;
 -      char string_buf[25];
 -      char* string_ptr = string_buf;
 -      uint8_t got[40000];
 -
 -      sscanf(Cmd, "%i %i", &requested, &offset);
 -
 -      /* if no args send something */
 -      if (requested == 0) {
 -              requested = 8;
 -      }
 -      if (offset + requested > sizeof(got)) {
 -              PrintAndLog("Tried to read past end of buffer, <bytes> + <offset> > 40000");
 -              return 0;
 +  int i, j;
 +  int requested = 0;
 +  int offset = 0;
 +  char string_buf[25];
 +  char* string_ptr = string_buf;
 +  uint8_t got[40000];
-  
++
 +  sscanf(Cmd, "%i %i", &requested, &offset);
 +
 +  /* if no args send something */
 +  if (requested == 0) {
 +    requested = 8;
 +  }
 +  if (offset + requested > sizeof(got)) {
 +    PrintAndLog("Tried to read past end of buffer, <bytes> + <offset> > 40000");
 +    return 0;
-   } 
++      }
 +
 +  GetFromBigBuf(got,requested,offset);
 +  WaitForResponse(CMD_ACK,NULL);
 +
 +  i = 0;
 +  for (j = 0; j < requested; j++) {
 +    i++;
 +    string_ptr += sprintf(string_ptr, "%02x ", got[j]);
 +    if (i == 8) {
 +      *(string_ptr - 1) = '\0';    // remove the trailing space
 +      PrintAndLog("%s", string_buf);
 +      string_buf[0] = '\0';
 +      string_ptr = string_buf;
 +      i = 0;
 +    }
 +    if (j == requested - 1 && string_buf[0] != '\0') { // print any remaining bytes
 +      *(string_ptr - 1) = '\0';
 +      PrintAndLog("%s", string_buf);
 +      string_buf[0] = '\0';
-     }  
 +  }
+       }
 -
 -      GetFromBigBuf(got,requested,offset);
 -      WaitForResponse(CMD_ACK,NULL);
 -
 -      i = 0;
 -      for (j = 0; j < requested; j++) {
 -              i++;
 -              string_ptr += sprintf(string_ptr, "%02x ", got[j]);
 -              if (i == 8) {
 -                      *(string_ptr - 1) = '\0';    // remove the trailing space
 -                      PrintAndLog("%s", string_buf);
 -                      string_buf[0] = '\0';
 -                      string_ptr = string_buf;
 -                      i = 0;
 -              }
 -              if (j == requested - 1 && string_buf[0] != '\0') { // print any remaining bytes
 -                      *(string_ptr - 1) = '\0';
 -                      PrintAndLog("%s", string_buf);
 -                      string_buf[0] = '\0';
 -              }
 -      }
 -      return 0;
 +  return 0;
  }
  
  int CmdHide(const char *Cmd)
@@@ -869,24 -1035,24 +1035,24 @@@ int CmdHpf(const char *Cmd
  
  int CmdSamples(const char *Cmd)
  {
-       uint8_t got[40000] = {0x00};
+       uint8_t got[40000];
  
        int n = strtol(Cmd, NULL, 0);
-       if (n == 0) 
+       if (n == 0)
                n = 20000;
-               
-       if (n > sizeof(got)) 
+       if (n > sizeof(got))
                n = sizeof(got);
-   
        PrintAndLog("Reading %d samples from device memory\n", n);
 -      GetFromBigBuf(got,n,0);
 -      WaitForResponse(CMD_ACK,NULL);
 +  GetFromBigBuf(got,n,0);
 +  WaitForResponse(CMD_ACK,NULL);
-       for (int j = 0; j < n; ++j) {
+       for (int j = 0; j < n; j++) {
                GraphBuffer[j] = ((int)got[j]) - 128;
 -      }
 -      GraphTraceLen = n;
 -      RepaintGraphWindow();
 -      return 0;
 +  }
 +  GraphTraceLen = n;
 +  RepaintGraphWindow();
 +  return 0;
  }
  
  int CmdTuneSamples(const char *Cmd)
  
        for (int i = 0; i < 256; i++) {
                GraphBuffer[i] = resp.d.asBytes[i] - 128;
-   }
-   
+       }
 -      PrintAndLog("Done! Divisor 89 is 134khz, 95 is 125khz.\n");
 -      PrintAndLog("\n");
 +  PrintAndLog("Done! Divisor 89 is 134khz, 95 is 125khz.\n");
 +  PrintAndLog("\n");
        GraphTraceLen = 256;
        ShowGraphWindow();
  
    return 0;
  }
  
  int CmdLoad(const char *Cmd)
  {
 -      FILE *f = fopen(Cmd, "r");
 -      if (!f) {
 -              PrintAndLog("couldn't open '%s'", Cmd);
 -              return 0;
 -      }
 -
 -      GraphTraceLen = 0;
 -      char line[80];
 -      while (fgets(line, sizeof (line), f)) {
 -              GraphBuffer[GraphTraceLen] = atoi(line);
 -              GraphTraceLen++;
 -      }
 -      fclose(f);
 -      PrintAndLog("loaded %d samples", GraphTraceLen);
 -      RepaintGraphWindow();
 -      return 0;
 +   char filename[FILE_PATH_SIZE] = {0x00};
 +   int len = 0;
 +
 +   len = strlen(Cmd);
 +   if (len > FILE_PATH_SIZE) len = FILE_PATH_SIZE;
 +   memcpy(filename, Cmd, len);
 +      
 +   FILE *f = fopen(filename, "r");
 +  if (!f) {
 +     PrintAndLog("couldn't open '%s'", filename);
 +    return 0;
 +  }
 +
 +  GraphTraceLen = 0;
 +  char line[80];
 +  while (fgets(line, sizeof (line), f)) {
 +    GraphBuffer[GraphTraceLen] = atoi(line);
 +    GraphTraceLen++;
 +  }
 +  fclose(f);
 +  PrintAndLog("loaded %d samples", GraphTraceLen);
 +  RepaintGraphWindow();
 +  return 0;
  }
  
  int CmdLtrim(const char *Cmd)
@@@ -1229,24 -1389,25 +1396,25 @@@ int CmdManchesterMod(const char *Cmd
  
  int CmdNorm(const char *Cmd)
  {
 -      int i;
 -      int max = INT_MIN, min = INT_MAX;
 -
 -      for (i = 10; i < GraphTraceLen; ++i) {
 -              if (GraphBuffer[i] > max)
 -                      max = GraphBuffer[i];
 -              if (GraphBuffer[i] < min)
 -                      min = GraphBuffer[i];
 -      }
 -
 -      if (max != min) {
 -              for (i = 0; i < GraphTraceLen; ++i) {
 +  int i;
 +  int max = INT_MIN, min = INT_MAX;
 +
 +  for (i = 10; i < GraphTraceLen; ++i) {
 +    if (GraphBuffer[i] > max)
 +      max = GraphBuffer[i];
 +    if (GraphBuffer[i] < min)
 +      min = GraphBuffer[i];
 +  }
 +
 +  if (max != min) {
 +    for (i = 0; i < GraphTraceLen; ++i) {
-       GraphBuffer[i] = (GraphBuffer[i] - ((max + min) / 2)) * 1000 /
+                       GraphBuffer[i] = (GraphBuffer[i] - ((max + min) / 2)) * 256 /
 -                              (max - min);
 +        (max - min);
+                               //marshmelow: adjusted *1000 to *256 to make +/- 128 so demod commands still work
 -              }
 -      }
 -      RepaintGraphWindow();
 -      return 0;
 +    }
 +  }
 +  RepaintGraphWindow();
 +  return 0;
  }
  
  int CmdPlot(const char *Cmd)
@@@ -1308,104 -1461,108 +1476,108 @@@ int CmdDirectionalThreshold(const char 
  {
        int8_t upThres = param_get8(Cmd, 0);
        int8_t downThres = param_get8(Cmd, 1);
-   
 -      printf("Applying Up Threshold: %d, Down Threshold: %d\n", upThres, downThres);
 -
 -      int lastValue = GraphBuffer[0];
 -      GraphBuffer[0] = 0; // Will be changed at the end, but init 0 as we adjust to last samples value if no threshold kicks in.
 -
 -      for (int i = 1; i < GraphTraceLen; ++i) {
 -              // Apply first threshold to samples heading up
 -              if (GraphBuffer[i] >= upThres && GraphBuffer[i] > lastValue)
 -              {
 -                      lastValue = GraphBuffer[i]; // Buffer last value as we overwrite it.
 -                      GraphBuffer[i] = 1;
 -              }
 -              // Apply second threshold to samples heading down
 -              else if (GraphBuffer[i] <= downThres && GraphBuffer[i] < lastValue)
 -              {
 -                      lastValue = GraphBuffer[i]; // Buffer last value as we overwrite it.
 -                      GraphBuffer[i] = -1;
 -              }
 -              else
 -              {
 -                      lastValue = GraphBuffer[i]; // Buffer last value as we overwrite it.
 -                      GraphBuffer[i] = GraphBuffer[i-1];
 -
 -              }
 -      }
 -      GraphBuffer[0] = GraphBuffer[1]; // Aline with first edited sample.
 -      RepaintGraphWindow();
 -      return 0;
 +  printf("Applying Up Threshold: %d, Down Threshold: %d\n", upThres, downThres);
-   
++
 +  int lastValue = GraphBuffer[0];
 +  GraphBuffer[0] = 0; // Will be changed at the end, but init 0 as we adjust to last samples value if no threshold kicks in.
-   
++
 +  for (int i = 1; i < GraphTraceLen; ++i) {
 +    // Apply first threshold to samples heading up
 +    if (GraphBuffer[i] >= upThres && GraphBuffer[i] > lastValue)
 +    {
 +      lastValue = GraphBuffer[i]; // Buffer last value as we overwrite it.
 +      GraphBuffer[i] = 1;
 +    }
 +    // Apply second threshold to samples heading down
 +    else if (GraphBuffer[i] <= downThres && GraphBuffer[i] < lastValue)
 +    {
 +      lastValue = GraphBuffer[i]; // Buffer last value as we overwrite it.
 +      GraphBuffer[i] = -1;
 +    }
 +    else
 +    {
 +      lastValue = GraphBuffer[i]; // Buffer last value as we overwrite it.
 +      GraphBuffer[i] = GraphBuffer[i-1];
 +
 +    }
 +  }
 +  GraphBuffer[0] = GraphBuffer[1]; // Aline with first edited sample.
 +  RepaintGraphWindow();
 +  return 0;
  }
  
  int CmdZerocrossings(const char *Cmd)
  {
 -      // Zero-crossings aren't meaningful unless the signal is zero-mean.
 -      CmdHpf("");
 -
 -      int sign = 1;
 -      int zc = 0;
 -      int lastZc = 0;
 -
 -      for (int i = 0; i < GraphTraceLen; ++i) {
 -              if (GraphBuffer[i] * sign >= 0) {
 -                      // No change in sign, reproduce the previous sample count.
 -                      zc++;
 -                      GraphBuffer[i] = lastZc;
 -              } else {
 -                      // Change in sign, reset the sample count.
 -                      sign = -sign;
 -                      GraphBuffer[i] = lastZc;
 -                      if (sign > 0) {
 -                              lastZc = zc;
 -                              zc = 0;
 -                      }
 -              }
 -      }
 -
 -      RepaintGraphWindow();
 -      return 0;
 +  // Zero-crossings aren't meaningful unless the signal is zero-mean.
 +  CmdHpf("");
 +
 +  int sign = 1;
 +  int zc = 0;
 +  int lastZc = 0;
 +
 +  for (int i = 0; i < GraphTraceLen; ++i) {
 +    if (GraphBuffer[i] * sign >= 0) {
 +      // No change in sign, reproduce the previous sample count.
 +      zc++;
 +      GraphBuffer[i] = lastZc;
 +    } else {
 +      // Change in sign, reset the sample count.
 +      sign = -sign;
 +      GraphBuffer[i] = lastZc;
 +      if (sign > 0) {
 +        lastZc = zc;
 +        zc = 0;
 +      }
 +    }
 +  }
 +
 +  RepaintGraphWindow();
 +  return 0;
  }
  
- static command_t CommandTable[] = 
+ static command_t CommandTable[] =
  {
 -      {"help",          CmdHelp,            1, "This help"},
 -      {"amp",           CmdAmp,             1, "Amplify peaks"},
 -      {"askdemod",      Cmdaskdemod,        1, "<0 or 1> -- Attempt to demodulate simple ASK tags"},
 +  {"help",          CmdHelp,            1, "This help"},
 +  {"amp",           CmdAmp,             1, "Amplify peaks"},
 +  {"askdemod",      Cmdaskdemod,        1, "<0 or 1> -- Attempt to demodulate simple ASK tags"},
-   {"askmandemod",   Cmdaskmandemod,     1, "[clock] [invert <0|1>] -- Attempt to demodulate ASK/Manchester tags and output binary"},
-   {"askrawdemod",   Cmdaskrawdemod,     1, "[clock] [invert <0|1>] -- Attempt to demodulate ASK tags and output binary"},
+       {"askmandemod",   Cmdaskmandemod,     1, "[clock] [invert<0|1>] -- Attempt to demodulate ASK/Manchester tags and output binary (args optional[clock will try Auto-detect])"},
+       {"askrawdemod",   Cmdaskrawdemod,     1, "[clock] [invert<0|1>] -- Attempt to demodulate ASK tags and output binary (args optional[clock will try Auto-detect])"},
 -      {"autocorr",      CmdAutoCorr,        1, "<window length> -- Autocorrelation over window"},
 -      {"biphaserawdecode",CmdBiphaseDecodeRaw,1,"[offset] Biphase decode binary stream already in graph buffer (offset = bit to start decode from)"},
 -      {"bitsamples",    CmdBitsamples,      0, "Get raw samples as bitstring"},
 -      {"bitstream",     CmdBitstream,       1, "[clock rate] -- Convert waveform into a bitstream"},
 -      {"buffclear",     CmdBuffClear,       1, "Clear sample buffer and graph window"},
 -      {"dec",           CmdDec,             1, "Decimate samples"},
 +  {"autocorr",      CmdAutoCorr,        1, "<window length> -- Autocorrelation over window"},
 +  {"biphaserawdecode",CmdBiphaseDecodeRaw,1,"[offset] Biphase decode binary stream already in graph buffer (offset = bit to start decode from)"},
 +  {"bitsamples",    CmdBitsamples,      0, "Get raw samples as bitstring"},
 +  {"bitstream",     CmdBitstream,       1, "[clock rate] -- Convert waveform into a bitstream"},
 +  {"buffclear",     CmdBuffClear,       1, "Clear sample buffer and graph window"},
 +  {"dec",           CmdDec,             1, "Decimate samples"},
-   {"detectaskclock",CmdDetectClockRate, 1, "Detect ASK clock rate"},
+       {"detectclock",   CmdDetectClockRate, 1, "Detect ASK clock rate"},
 -      {"fskdemod",      CmdFSKdemod,        1, "Demodulate graph window as a HID FSK"},
 -      {"fskhiddemod",   CmdFSKdemodHID,     1, "Demodulate graph window as a HID FSK using raw"},
 -      {"fskiodemod",    CmdFSKdemodIO,      1, "Demodulate graph window as an IO Prox FSK using raw"},
 +  {"fskdemod",      CmdFSKdemod,        1, "Demodulate graph window as a HID FSK"},
 +  {"fskhiddemod",   CmdFSKdemodHID,     1, "Demodulate graph window as a HID FSK using raw"},
 +  {"fskiodemod",    CmdFSKdemodIO,      1, "Demodulate graph window as an IO Prox FSK using raw"},
-   {"fskrawdemod",   CmdFSKrawdemod,     1, "[clock rate] [invert] [rchigh] [rclow] Demodulate graph window from FSK to binary (clock = 50)(invert = 1 or 0)(rchigh = 10)(rclow=8)"},
+       {"fskrawdemod",   CmdFSKrawdemod,     1, "[clock rate] [invert] [rchigh] [rclow] Demodulate graph window from FSK to binary (clock = 50)(invert = 1|0)(rchigh = 10)(rclow=8)"},
 -      {"grid",          CmdGrid,            1, "<x> <y> -- overlay grid on graph window, use zero value to turn off either"},
 +  {"grid",          CmdGrid,            1, "<x> <y> -- overlay grid on graph window, use zero value to turn off either"},
-   {"hexsamples",    CmdHexsamples,      0, "<bytes> [<offset>] -- Dump big buffer as hex bytes"},  
+       {"hexsamples",    CmdHexsamples,      0, "<bytes> [<offset>] -- Dump big buffer as hex bytes"},
 -      {"hide",          CmdHide,            1, "Hide graph window"},
 -      {"hpf",           CmdHpf,             1, "Remove DC offset from trace"},
 -      {"load",          CmdLoad,            1, "<filename> -- Load trace (to graph window"},
 -      {"ltrim",         CmdLtrim,           1, "<samples> -- Trim samples from left of trace"},
 -      {"rtrim",         CmdRtrim,           1, "<location to end trace> -- Trim samples from right of trace"},
 -      {"mandemod",      CmdManchesterDemod, 1, "[i] [clock rate] -- Manchester demodulate binary stream (option 'i' to invert output)"},
 -      {"manrawdecode",  Cmdmandecoderaw,    1, "Manchester decode binary stream already in graph buffer"},
 -      {"manmod",        CmdManchesterMod,   1, "[clock rate] -- Manchester modulate a binary stream"},
 +  {"hide",          CmdHide,            1, "Hide graph window"},
 +  {"hpf",           CmdHpf,             1, "Remove DC offset from trace"},
 +  {"load",          CmdLoad,            1, "<filename> -- Load trace (to graph window"},
 +  {"ltrim",         CmdLtrim,           1, "<samples> -- Trim samples from left of trace"},
 +  {"rtrim",         CmdRtrim,           1, "<location to end trace> -- Trim samples from right of trace"},
 +  {"mandemod",      CmdManchesterDemod, 1, "[i] [clock rate] -- Manchester demodulate binary stream (option 'i' to invert output)"},
 +  {"manrawdecode",  Cmdmandecoderaw,    1, "Manchester decode binary stream already in graph buffer"},
 +  {"manmod",        CmdManchesterMod,   1, "[clock rate] -- Manchester modulate a binary stream"},
-   {"norm",          CmdNorm,            1, "Normalize max/min to +/-500"},
+       {"norm",          CmdNorm,            1, "Normalize max/min to +/-128"},
 -      {"plot",          CmdPlot,            1, "Show graph window (hit 'h' in window for keystroke help)"},
 +  {"plot",          CmdPlot,            1, "Show graph window (hit 'h' in window for keystroke help)"},
+       {"pskclean",      CmdPskClean,        1, "Attempt to clean psk wave"},
+       {"pskdetectclock",CmdDetectNRZpskClockRate, 1, "Detect ASK, PSK, or NRZ clock rate"},
+       {"pskindalademod",CmdIndalaDecode,    1, "[clock] [invert<0|1>] -- Attempt to demodulate psk indala tags and output ID binary & hex (args optional[clock will try Auto-detect])"},
+       {"psknrzrawdemod",CmdpskNRZrawDemod,  1, "[clock] [invert<0|1>] -- Attempt to demodulate psk or nrz tags and output binary (args optional[clock will try Auto-detect])"},
 -      {"samples",       CmdSamples,         0, "[512 - 40000] -- Get raw samples for graph window"},
 -      {"save",          CmdSave,            1, "<filename> -- Save trace (from graph window)"},
 -      {"scale",         CmdScale,           1, "<int> -- Set cursor display scale"},
 -      {"threshold",     CmdThreshold,       1, "<threshold> -- Maximize/minimize every value in the graph window depending on threshold"},
 +  {"samples",       CmdSamples,         0, "[512 - 40000] -- Get raw samples for graph window"},
-   {"tune",          CmdTuneSamples,     0, "Get hw tune samples for graph window"},
 +  {"save",          CmdSave,            1, "<filename> -- Save trace (from graph window)"},
 +  {"scale",         CmdScale,           1, "<int> -- Set cursor display scale"},
 +  {"threshold",     CmdThreshold,       1, "<threshold> -- Maximize/minimize every value in the graph window depending on threshold"},
+       {"dirthreshold",  CmdDirectionalThreshold,   1, "<thres up> <thres down> -- Max rising higher up-thres/ Min falling lower down-thres, keep rest as prev."},
+       {"tune",          CmdTuneSamples,     0, "Get hw tune samples for graph window"},
 -      {"zerocrossings", CmdZerocrossings,   1, "Count time between zero-crossings"},
 -      {NULL, NULL, 0, NULL}
 +  {"zerocrossings", CmdZerocrossings,   1, "Count time between zero-crossings"},
-   {"dirthreshold",  CmdDirectionalThreshold,   1, "<thres up> <thres down> -- Max rising higher up-thres/ Min falling lower down-thres, keep rest as prev."},
 +  {NULL, NULL, 0, NULL}
  };
  
  int CmdData(const char *Cmd)
Simple merge
diff --cc client/graph.c
index a2753af7b011686fd22002dce5019c5acbbd2281,9079e07388fbb8ffa08c236383bb1dae8d651e12..6362c8fe242dc438914b5f34135db9874737b91d
@@@ -20,172 -20,93 +20,95 @@@ int GraphTraceLen
  /* write a bit to the graph */
  void AppendGraph(int redraw, int clock, int bit)
  {
 -      int i;
 +  int i;
  
 -      for (i = 0; i < (int)(clock / 2); ++i)
 -              GraphBuffer[GraphTraceLen++] = bit ^ 1;
 +  for (i = 0; i < (int)(clock / 2); ++i)
 +    GraphBuffer[GraphTraceLen++] = bit ^ 1;
-   
 -      for (i = (int)(clock / 2); i < clock; ++i)
 -              GraphBuffer[GraphTraceLen++] = bit;
 +  for (i = (int)(clock / 2); i < clock; ++i)
 +    GraphBuffer[GraphTraceLen++] = bit;
  
 -      if (redraw)
 -              RepaintGraphWindow();
 +  if (redraw)
 +    RepaintGraphWindow();
  }
  
- /* clear out our graph window */
+ // clear out our graph window
  int ClearGraph(int redraw)
  {
 -      int gtl = GraphTraceLen;
 -      GraphTraceLen = 0;
 +  int gtl = GraphTraceLen;
 +  memset(GraphBuffer, 0x00, GraphTraceLen);
  
 -      if (redraw)
 -              RepaintGraphWindow();
 +  GraphTraceLen = 0;
  
 -      return gtl;
 +  if (redraw)
 +    RepaintGraphWindow();
 +
 +  return gtl;
  }
  
- /*
-  * Detect clock rate
-  */
-  //decommissioned - has difficulty detecting rf/32 
- /*
- int DetectClockOld(int peak)
- {
-   int i;
-   int clock = 0xFFFF;
-   int lastpeak = 0;
-   // Detect peak if we don't have one 
-   if (!peak)
-     for (i = 0; i < GraphTraceLen; ++i)
-       if (GraphBuffer[i] > peak)
-         peak = GraphBuffer[i];
+ // DETECT CLOCK NOW IN LFDEMOD.C
  
-  // peak=(int)(peak*.75);
-   for (i = 1; i < GraphTraceLen; ++i)
-   {
-     // If this is the beginning of a peak 
-     if (GraphBuffer[i - 1] != GraphBuffer[i] && GraphBuffer[i] >= peak)
-     {
-       // Find lowest difference between peaks 
-       if (lastpeak && i - lastpeak < clock)
-         clock = i - lastpeak;
-       lastpeak = i;
-     }
-   }
-   return clock;
- }
- */
- /*
- NOW IN LFDEMOD.C
- // by marshmellow
- // not perfect especially with lower clocks or VERY good antennas (heavy wave clipping)
- // maybe somehow adjust peak trimming value based on samples to fix?
- int DetectASKClock(int peak)
- {
-   int i=0;
-   int low=0;
-   int clk[]={16,32,40,50,64,100,128,256};
-   int loopCnt = 256;
-   if (GraphTraceLen<loopCnt) loopCnt = GraphTraceLen;
-   if (!peak){
-     for (i=0;i<loopCnt;++i){
-       if(GraphBuffer[i]>peak){
-         peak = GraphBuffer[i]; 
-       }
-       if(GraphBuffer[i]<low){
-         low = GraphBuffer[i];
-       }
-     }
-     peak=(int)(peak*.75);
-     low= (int)(low*.75);
-   }
-   int ii;
-   int clkCnt;
-   int tol = 0;
-   int bestErr=1000;
-   int errCnt[]={0,0,0,0,0,0,0,0};
-   for(clkCnt=0; clkCnt<6;++clkCnt){
-     if (clk[clkCnt]==32){
-       tol=1;
-     }else{
-       tol=0;
-     }
-     bestErr=1000;
-     for (ii=0; ii<loopCnt; ++ii){
-       if ((GraphBuffer[ii]>=peak) || (GraphBuffer[ii]<=low)){
-          errCnt[clkCnt]=0;
-         for (i=0; i<((int)(GraphTraceLen/clk[clkCnt])-1); ++i){
-           if (GraphBuffer[ii+(i*clk[clkCnt])]>=peak || GraphBuffer[ii+(i*clk[clkCnt])]<=low){
-           }else if(GraphBuffer[ii+(i*clk[clkCnt])-tol]>=peak || GraphBuffer[ii+(i*clk[clkCnt])-tol]<=low){
-           }else if(GraphBuffer[ii+(i*clk[clkCnt])+tol]>=peak || GraphBuffer[ii+(i*clk[clkCnt])+tol]<=low){
-           }else{  //error no peak detected
-             errCnt[clkCnt]++;
-           }    
-         }
-         if(errCnt[clkCnt]==0) return clk[clkCnt];
-         if(errCnt[clkCnt]<bestErr) bestErr=errCnt[clkCnt];
-       }
-     } 
-   }
-   int iii=0;
-   int best=0;
-   for (iii=0; iii<6;++iii){
-     if (errCnt[iii]<errCnt[best]){
-       best = iii;
-     }
-   }
-   // PrintAndLog("DEBUG: clkCnt: %d, ii: %d, i: %d peak: %d, low: %d, errcnt: %d, errCnt64: %d",clkCnt,ii,i,peak,low,errCnt[best],errCnt[4]);
-   return clk[best];
- }
- */
- void setGraphBuf(uint8_t *buff,int size) 
+ void setGraphBuf(uint8_t *buff, size_t size)
  {
 -      int i=0;
 -      ClearGraph(0);
 -      for (; i < size; ++i){
 +  int i=0;
 +  ClearGraph(0);
 +  for (; i < size; ++i){
-     GraphBuffer[i]=buff[i];
+               GraphBuffer[i]=buff[i]-128;
 -      }
 -      GraphTraceLen=size;
 -      RepaintGraphWindow();
 -      return;
 +  }
 +  GraphTraceLen=size;
 +  RepaintGraphWindow();
 +  return;
  }
int getFromGraphBuf(uint8_t *buff)
size_t getFromGraphBuf(uint8_t *buff)
  {
 -      uint32_t i;
 -      for (i=0;i<GraphTraceLen;++i){
 -              if (GraphBuffer[i]>127) GraphBuffer[i]=127; //trim
 -              if (GraphBuffer[i]<-127) GraphBuffer[i]=-127; //trim
 -              buff[i]=(uint8_t)(GraphBuffer[i]+128);
 -      }
 -      return i;
 +  uint32_t i;
 +  for (i=0;i<GraphTraceLen;++i){
 +    if (GraphBuffer[i]>127) GraphBuffer[i]=127; //trim
 +    if (GraphBuffer[i]<-127) GraphBuffer[i]=-127; //trim
 +    buff[i]=(uint8_t)(GraphBuffer[i]+128);
 +  }
 +  return i;
  }
- /* Get or auto-detect clock rate */
+ // Get or auto-detect clock rate
  int GetClock(const char *str, int peak, int verbose)
  {
 -      int clock;
 -      sscanf(str, "%i", &clock);
 -      if (!strcmp(str, ""))
 -              clock = 0;
 +  int clock;
- //  int clock2;
 +  sscanf(str, "%i", &clock);
 +  if (!strcmp(str, ""))
 +    clock = 0;
  
-   /* Auto-detect clock */
+       // Auto-detect clock
 -      if (!clock)
 -      {
 -              uint8_t grph[MAX_GRAPH_TRACE_LEN]={0};
 +  if (!clock)
 +  {
 +    uint8_t grph[MAX_GRAPH_TRACE_LEN]={0};
-     int size = getFromGraphBuf(grph);
+               size_t size = getFromGraphBuf(grph);
 -              clock = DetectASKClock(grph,size,0);
 +    clock = DetectASKClock(grph,size,0);
-     //clock2 = DetectClock2(peak);
-     /* Only print this message if we're not looping something */
+               // Only print this message if we're not looping something
 -              if (!verbose){
 -                      PrintAndLog("Auto-detected clock rate: %d", clock);
 -              }
 -      }
 +    if (!verbose){
 +      PrintAndLog("Auto-detected clock rate: %d", clock);
-       //PrintAndLog("clock2: %d",clock2);
 +    }
 +  }
  
 -      return clock;
 +  return clock;
  }
+ int GetNRZpskClock(const char *str, int peak, int verbose)
+ {
+       int clock;
+       sscanf(str, "%i", &clock);
+       if (!strcmp(str, ""))
+               clock = 0;
+       // Auto-detect clock
+       if (!clock)
+       {
+               uint8_t grph[MAX_GRAPH_TRACE_LEN]={0};
+               size_t size = getFromGraphBuf(grph);
+               clock = DetectpskNRZClock(grph,size,0);
+               // Only print this message if we're not looping something
+               if (!verbose){
+                       PrintAndLog("Auto-detected clock rate: %d", clock);
+               }
+       }
+       return clock;
+ }
Impressum, Datenschutz